make use_task with overload

solara/lab/__init__.py

@@ -2,6 +2,7 @@
 from .components import *  # noqa: F401, F403
 from ..server.kernel_context import on_kernel_start  # noqa: F401
 from ..tasks import task, use_task, Task  # noqa: F401, F403
+from ..toestand import computed  # noqa: F401
 
 
 def __getattr__(name):

solara/tasks.py

@@ -334,7 +334,23 @@ def create_task():
         return wrapper(function)
 
 
-def use_task(f: Callable[P, R], dependencies=[], *, raise_error=True) -> Union[Task[P, R], solara.Result[R]]:
+@overload
+def use_task(
+    f: None = None,
+) -> Callable[[Callable[[], R]], solara.Result[R]]:
+    ...
+
+
+@overload
+def use_task(
+    f: Callable[P, R],
+) -> solara.Result[R]:
+    ...
+
+
+def use_task(
+    f: Union[None, Callable[[], R]] = None, dependencies=[], *, raise_error=True
+) -> Union[Callable[[Callable[[], R]], solara.Result[R]], solara.Result[R]]:
     """Run a function or coroutine as a task and return the result.
 
     ## Example
@@ -398,14 +414,21 @@ async def square():
 
 
     """
-    task_instance = solara.use_memo(lambda: task(f), dependencies=dependencies)
 
-    def run():
-        task_instance()
-        return task_instance.cancel
+    def wrapper(f):
+        task_instance = solara.use_memo(lambda: task(f), dependencies=dependencies)
+
+        def run():
+            task_instance()
+            return task_instance.cancel
 
-    solara.use_effect(run, dependencies=dependencies)
-    if raise_error:
-        if task_instance.state == solara.ResultState.ERROR and task_instance.error is not None:
-            raise task_instance.error
-    return task_instance.result.value
+        solara.use_effect(run, dependencies=dependencies)
+        if raise_error:
+            if task_instance.state == solara.ResultState.ERROR and task_instance.error is not None:
+                raise task_instance.error
+        return task_instance.result.value
+
+    if f is None:
+        return wrapper
+    else:
+        return wrapper(f)

solara/toestand.py

@@ -402,6 +402,72 @@ def __repr__(self):
         return "<Computed" + value[len("<Reactive") : -1]
 
 
+@overload
+def computed(
+    f: None,
+    *,
+    key: Optional[str] = ...,
+) -> Callable[[Callable[[], T]], Reactive[T]]:
+    ...
+
+
+@overload
+def computed(
+    f: Callable[[], T],
+    *,
+    key: Optional[str] = ...,
+) -> Reactive[T]:
+    ...
+
+
+def computed(
+    f: Union[None, Callable[[], T]],
+    *,
+    key: Optional[str] = None,
+) -> Union[Callable[[Callable[[], T]], Reactive[T]], Reactive[T]]:
+    """Creates a reactive variable that is set to the return value of the function.
+
+    The value will be updated when any of the reactive variables used in the function
+    change.
+
+    ## Example
+
+    ```solara
+    import solara
+    import solara.lab
+
+
+    a = solara.reactive(1)
+    b = solara.reactive(2)
+
+    @solara.lab.computed
+    def total():
+        return a.value + b.value
+
+    def reset():
+        a.value = 1
+        b.value = 2
+
+    @solara.component
+    def Page():
+        print(a, b, total)
+        solara.IntSlider("a", value=a)
+        solara.IntSlider("b", value=b)
+        solara.Text(f"a + b = {total.value}")
+        solara.Button("reset", on_click=reset)
+    ```
+
+    """
+
+    def wrapper(f: Callable[[], T]):
+        return Computed(f, key=key)
+
+    if f is None:
+        return wrapper
+    else:
+        return wrapper(f)
+
+
 class ValueSubField(ValueBase[T]):
     def __init__(self, field: "FieldBase"):
         super().__init__()  # type: ignore