revert to older effect_of_N style

gears/effect.py

@@ -1,36 +1,40 @@
-from __future__ import annotations
-from typing import Any, Callable, cast
-from .wrap_aware_tuple import WrapAwareTuple
+from gears import Gear
+from typing import Any, Generic, Hashable, TypeVar, Callable, TypeVarTuple
 
 
-class Effect[*Ts]:
-    def __init__(self, fn: Callable[[*Ts], None], gears: WrapAwareTuple[Gear, *Ts]):
-        for gear in gears:
-            gear.effects.append(self)
+class Effect:
+    def __init__(self, fn: Callable[..., None], *gears: Gear):
         self._fn = fn
         self._gears = gears
+        for gear in gears:
+            gear.effects.append(self)
 
-        self.on_change()
+        self.on_change(gears[0]())
 
-    def on_change(self):
-        self._fn(*self._gears.unwrap(lambda x: x()))
+    def on_change(self, _value: Any):
+        self._fn(*(gear() for gear in self._gears))
 
 
-def effect_of[*Ts](
-    *gears: Gear[Any],
-) -> Callable[[Callable[[*Ts], None]], Effect]:
-    # No deduction, no tears, only cast now
-    ts_gears = cast(WrapAwareTuple[Gear, *Ts], WrapAwareTuple.prewrapped(gears))
-    return effect_of_typechecked(ts_gears)
-
-
-def effect_of_typechecked[*Ts](
-    gears: WrapAwareTuple[Gear, *Ts],
-) -> Callable[[Callable[[*Ts], None]], Effect]:
-    def decorator(fn: Callable[[*Ts], None]) -> Effect:
-        return Effect(fn, gears)
+def effect_of[T0: Hashable](g0: Gear[T0]) -> Callable[[Callable[[T0], None]], Effect]:
+    def decorator(fn: Callable[[T0], None]) -> Effect:
+        return Effect(fn, g0)
 
     return decorator
 
 
-from gears import Gear
+def effect_of_2[T0: Hashable, T1: Hashable](
+    g0: Gear[T0], g1: Gear[T1]
+) -> Callable[[Callable[[T0, T1], None]], Effect]:
+    def decorator(fn: Callable[[T0, T1], None]) -> Effect:
+        return Effect(fn, g0, g1)
+
+    return decorator
+
+
+def effect_of_3[T0: Hashable, T1: Hashable, T2: Hashable](
+    g0: Gear[T0], g1: Gear[T1], g2: Gear[T2]
+) -> Callable[[Callable[[T0, T1, T2], None]], Effect]:
+    def decorator(fn: Callable[[T0, T1, T2], None]) -> Effect:
+        return Effect(fn, g0, g1, g2)
+
+    return decorator

gears/gear.py

@@ -1,14 +1,10 @@
-from __future__ import annotations
-from typing import Any, Hashable, TypeVar, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from gears.effect import Effect
+from typing import Any, Generic, Hashable, TypeVar, Callable
 
 
 class Gear[T: Hashable]:
     def __init__(self, value: T):
         self._value = value
-        self.effects: list[Effect] = []
+        self.effects = []
 
     def get(self) -> T:
         return self._value
@@ -21,4 +17,4 @@ class Gear[T: Hashable]:
             return
         self._value = value
         for effect in self.effects:
-            effect.on_change()
+            effect.on_change(value)