From 488d1e8bff1d01a8ece1be31cead6a755465cb17 Mon Sep 17 00:00:00 2001
From: DomNomNomVR <108088541+DomNomNomVR@users.noreply.github.com>
Date: Sun, 9 Mar 2025 20:11:48 +1300
Subject: [PATCH] revert to older effect_of_N style

---
 gears/effect.py | 52 ++++++++++++++++++++++++++-----------------------
 gears/gear.py   | 10 +++-------
 2 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/gears/effect.py b/gears/effect.py
index 165e13a..5e7e884 100644
--- a/gears/effect.py
+++ b/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
diff --git a/gears/gear.py b/gears/gear.py
index 840b215..4aa5438 100644
--- a/gears/gear.py
+++ b/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)