egglog 7.0.0__cp312-none-win_amd64.whl → 7.1.0__cp312-none-win_amd64.whl

egglog/bindings.pyi

@@ -494,6 +494,12 @@ class Relation:
 class PrintOverallStatistics:
     def __init__(self) -> None: ...
 
+@final
+class UnstableCombinedRuleset:
+    name: str
+    rulesets: list[str]
+    def __init__(self, name: str, rulesets: list[str]) -> None: ...
+
 _Command: TypeAlias = (
     SetOption
     | Datatype
@@ -521,6 +527,7 @@ _Command: TypeAlias = (
     | CheckProof
     | Relation
     | PrintOverallStatistics
+    | UnstableCombinedRuleset
 )
 
 def termdag_term_to_expr(termdag: TermDag, term: _Term) -> _Expr: ...

egglog/builtins.py

@@ -5,10 +5,14 @@ Builtin sorts and function to egg.
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Generic, Protocol, TypeAlias, TypeVar, Union
+from functools import partial
+from typing import TYPE_CHECKING, Generic, Protocol, TypeAlias, TypeVar, Union, overload
+
+from typing_extensions import TypeVarTuple, Unpack
 
 from .conversion import converter
 from .egraph import Expr, Unit, function, method
+from .runtime import RuntimeFunction
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -31,6 +35,7 @@ __all__ = [
     "py_eval",
     "py_exec",
     "py_eval_fn",
+    "UnstableFn",
 ]
 
 
@@ -461,3 +466,38 @@ def py_exec(code: StringLike, globals: object = PyObject.dict(), locals: object
     """
     Copies the locals, execs the Python code, and returns the locals with any updates.
     """
+
+
+TS = TypeVarTuple("TS")
+
+T1 = TypeVar("T1")
+T2 = TypeVar("T2")
+T3 = TypeVar("T3")
+
+
+class UnstableFn(Expr, Generic[T, Unpack[TS]], builtin=True):
+    @overload
+    def __init__(self, f: Callable[[Unpack[TS]], T]) -> None: ...
+
+    @overload
+    def __init__(self, f: Callable[[T1, Unpack[TS]], T], _a: T1, /) -> None: ...
+
+    @overload
+    def __init__(self, f: Callable[[T1, T2, Unpack[TS]], T], _a: T1, _b: T2, /) -> None: ...
+
+    # Removing due to bug in MyPy
+    # https://github.com/python/mypy/issues/17212
+    # @overload
+    # def __init__(self, f: Callable[[T1, T2, T3, Unpack[TS]], T], _a: T1, _b: T2, _c: T3, /) -> None: ...
+
+    # etc, for partial application
+
+    @method(egg_fn="unstable-fn")
+    def __init__(self, f, *partial) -> None: ...
+
+    @method(egg_fn="unstable-app")
+    def __call__(self, *args: Unpack[TS]) -> T: ...
+
+
+converter(RuntimeFunction, UnstableFn, UnstableFn)
+converter(partial, UnstableFn, lambda p: UnstableFn(p.func, *p.args))

egglog/conversion.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, TypeVar, cast
+from typing import TYPE_CHECKING, NewType, TypeVar, cast
 
 from .declarations import *
 from .pretty import *
@@ -16,7 +16,8 @@ if TYPE_CHECKING:
 
 __all__ = ["convert", "converter", "resolve_literal", "convert_to_same_type"]
 # Mapping from (source type, target type) to and function which takes in the runtimes values of the source and return the target
-CONVERSIONS: dict[tuple[type | JustTypeRef, JustTypeRef], tuple[int, Callable]] = {}
+TypeName = NewType("TypeName", str)
+CONVERSIONS: dict[tuple[type | TypeName, TypeName], tuple[int, Callable]] = {}
 # Global declerations to store all convertable types so we can query if they have certain methods or not
 # Defer it as a thunk so we can register conversions without triggering type signature loading
 CONVERSIONS_DECLS: Callable[[], Declarations] = Thunk.value(Declarations())
@@ -34,12 +35,12 @@ def converter(from_type: type[T], to_type: type[V], fn: Callable[[T], V], cost:
     Register a converter from some type to an egglog type.
     """
     to_type_name = process_tp(to_type)
-    if not isinstance(to_type_name, JustTypeRef):
+    if not isinstance(to_type_name, str):
         raise TypeError(f"Expected return type to be a egglog type, got {to_type_name}")
     _register_converter(process_tp(from_type), to_type_name, fn, cost)
 
 
-def _register_converter(a: type | JustTypeRef, b: JustTypeRef, a_b: Callable, cost: int) -> None:
+def _register_converter(a: type | TypeName, b: TypeName, a_b: Callable, cost: int) -> None:
     """
     Registers a converter from some type to an egglog type, if not already registered.
 
@@ -94,14 +95,17 @@ def convert_to_same_type(source: object, target: RuntimeExpr) -> RuntimeExpr:
     return resolve_literal(tp.to_var(), source)
 
 
-def process_tp(tp: type | RuntimeClass) -> JustTypeRef | type:
+def process_tp(tp: type | RuntimeClass) -> TypeName | type:
     """
     Process a type before converting it, to add it to the global declerations and resolve to a ref.
     """
     global CONVERSIONS_DECLS
     if isinstance(tp, RuntimeClass):
         CONVERSIONS_DECLS = Thunk.fn(_combine_decls, CONVERSIONS_DECLS, tp)
-        return tp.__egg_tp__.to_just()
+        egg_tp = tp.__egg_tp__
+        if egg_tp.args:
+            raise TypeError(f"Cannot register a converter for a generic type, got {tp}")
+        return TypeName(egg_tp.name)
     return tp
 
 
@@ -109,7 +113,7 @@ def _combine_decls(d: Callable[[], Declarations], x: HasDeclerations) -> Declara
     return Declarations.create(d(), x)
 
 
-def min_convertable_tp(a: object, b: object, name: str) -> JustTypeRef:
+def min_convertable_tp(a: object, b: object, name: str) -> TypeName:
     """
     Returns the minimum convertable type between a and b, that has a method `name`, raising a ConvertError if no such type exists.
     """
@@ -117,14 +121,14 @@ def min_convertable_tp(a: object, b: object, name: str) -> JustTypeRef:
     a_tp = _get_tp(a)
     b_tp = _get_tp(b)
     a_converts_to = {
-        to: c for ((from_, to), (c, _)) in CONVERSIONS.items() if from_ == a_tp and decls.has_method(to.name, name)
+        to: c for ((from_, to), (c, _)) in CONVERSIONS.items() if from_ == a_tp and decls.has_method(to, name)
     }
     b_converts_to = {
-        to: c for ((from_, to), (c, _)) in CONVERSIONS.items() if from_ == b_tp and decls.has_method(to.name, name)
+        to: c for ((from_, to), (c, _)) in CONVERSIONS.items() if from_ == b_tp and decls.has_method(to, name)
     }
-    if isinstance(a_tp, JustTypeRef):
+    if isinstance(a_tp, str):
         a_converts_to[a_tp] = 0
-    if isinstance(b_tp, JustTypeRef):
+    if isinstance(b_tp, str):
         b_converts_to[b_tp] = 0
     common = set(a_converts_to) & set(b_converts_to)
     if not common:
@@ -143,28 +147,29 @@ def resolve_literal(tp: TypeOrVarRef, arg: object) -> RuntimeExpr:
     try:
         tp_just = tp.to_just()
     except NotImplementedError:
-        # If this is a var, it has to be a runtime exprssions
+        # If this is a var, it has to be a runtime expession
         assert isinstance(arg, RuntimeExpr)
         return arg
-    if arg_type == tp_just:
+    tp_name = TypeName(tp_just.name)
+    if arg_type == tp_name:
         # If the type is an egg type, it has to be a runtime expr
         assert isinstance(arg, RuntimeExpr)
         return arg
     # Try all parent types as well, if we are converting from a Python type
     for arg_type_instance in arg_type.__mro__ if isinstance(arg_type, type) else [arg_type]:
         try:
-            fn = CONVERSIONS[(cast(JustTypeRef | type, arg_type_instance), tp_just)][1]
+            fn = CONVERSIONS[(cast(TypeName | type, arg_type_instance), tp_name)][1]
         except KeyError:
             continue
         break
     else:
-        raise ConvertError(f"Cannot convert {arg_type} to {tp_just}")
+        raise ConvertError(f"Cannot convert {arg_type} to {tp_name}")
     return fn(arg)
 
 
-def _get_tp(x: object) -> JustTypeRef | type:
+def _get_tp(x: object) -> TypeName | type:
     if isinstance(x, RuntimeExpr):
-        return x.__egg_typed_expr__.tp
+        return TypeName(x.__egg_typed_expr__.tp.name)
     tp = type(x)
     # If this value has a custom metaclass, let's use that as our index instead of the type
     if type(tp) != type:

egglog/declarations.py

@@ -39,6 +39,7 @@ __all__ = [
     "CallableDecl",
     "VarDecl",
     "PyObjectDecl",
+    "PartialCallDecl",
     "LitType",
     "LitDecl",
     "CallDecl",
@@ -46,6 +47,7 @@ __all__ = [
     "TypedExprDecl",
     "ClassDecl",
     "RulesetDecl",
+    "CombinedRulesetDecl",
     "SaturateDecl",
     "RepeatDecl",
     "SequenceDecl",
@@ -67,6 +69,8 @@ __all__ = [
     "RewriteOrRuleDecl",
     "ActionCommandDecl",
     "CommandDecl",
+    "SpecialFunctions",
+    "FunctionSignature",
 ]
 
 
@@ -88,9 +92,6 @@ class HasDeclerations(Protocol):
 DeclerationsLike: TypeAlias = Union[HasDeclerations, None, "Declarations"]
 
 
-# TODO: Make all ClassDecls take deferred type refs, which return new decls when resolving.
-
-
 def upcast_declerations(declerations_like: Iterable[DeclerationsLike]) -> list[Declarations]:
     d = []
     for l in declerations_like:
@@ -110,7 +111,7 @@ class Declarations:
     _functions: dict[str, FunctionDecl | RelationDecl] = field(default_factory=dict)
     _constants: dict[str, ConstantDecl] = field(default_factory=dict)
     _classes: dict[str, ClassDecl] = field(default_factory=dict)
-    _rulesets: dict[str, RulesetDecl] = field(default_factory=lambda: {"": RulesetDecl([])})
+    _rulesets: dict[str, RulesetDecl | CombinedRulesetDecl] = field(default_factory=lambda: {"": RulesetDecl([])})
 
     @classmethod
     def create(cls, *others: DeclerationsLike) -> Declarations:
@@ -196,7 +197,7 @@ class ClassDecl:
     preserved_methods: dict[str, Callable] = field(default_factory=dict)
 
 
-@dataclass
+@dataclass(frozen=True)
 class RulesetDecl:
     rules: list[RewriteOrRuleDecl]
 
@@ -206,6 +207,11 @@ class RulesetDecl:
         return hash((type(self), tuple(self.rules)))
 
 
+@dataclass(frozen=True)
+class CombinedRulesetDecl:
+    rulesets: tuple[str, ...]
+
+
 # Have two different types of type refs, one that can include vars recursively and one that cannot.
 # We only use the one with vars for classmethods and methods, and the other one for egg references as
 # well as runtime values.
@@ -316,10 +322,12 @@ class RelationDecl:
 
     def to_function_decl(self) -> FunctionDecl:
         return FunctionDecl(
-            arg_types=tuple(a.to_var() for a in self.arg_types),
-            arg_names=tuple(f"__{i}" for i in range(len(self.arg_types))),
-            arg_defaults=self.arg_defaults,
-            return_type=TypeRefWithVars("Unit"),
+            FunctionSignature(
+                arg_types=tuple(a.to_var() for a in self.arg_types),
+                arg_names=tuple(f"__{i}" for i in range(len(self.arg_types))),
+                arg_defaults=self.arg_defaults,
+                return_type=TypeRefWithVars("Unit"),
+            ),
             egg_name=self.egg_name,
             default=LitDecl(None),
         )
@@ -336,25 +344,41 @@ class ConstantDecl:
 
     def to_function_decl(self) -> FunctionDecl:
         return FunctionDecl(
-            arg_types=(),
-            arg_names=(),
-            arg_defaults=(),
-            return_type=self.type_ref.to_var(),
+            FunctionSignature(return_type=self.type_ref.to_var()),
             egg_name=self.egg_name,
         )
 
 
+# special cases for partial function creation and application, which cannot use the normal python rules
+SpecialFunctions: TypeAlias = Literal["fn-partial", "fn-app"]
+
+
 @dataclass(frozen=True)
-class FunctionDecl:
-    # All args are delayed except for relations converted to function decls
-    arg_types: tuple[TypeOrVarRef, ...]
-    arg_names: tuple[str, ...]
+class FunctionSignature:
+    arg_types: tuple[TypeOrVarRef, ...] = ()
+    arg_names: tuple[str, ...] = ()
     # List of defaults. None for any arg which doesn't have one.
-    arg_defaults: tuple[ExprDecl | None, ...]
+    arg_defaults: tuple[ExprDecl | None, ...] = ()
     # If None, then the first arg is mutated and returned
-    return_type: TypeOrVarRef | None
+    return_type: TypeOrVarRef | None = None
     var_arg_type: TypeOrVarRef | None = None
 
+    @property
+    def semantic_return_type(self) -> TypeOrVarRef:
+        """
+        The type that is returned by the function, which wil be in the first arg if it mutates it.
+        """
+        return self.return_type or self.arg_types[0]
+
+    @property
+    def mutates(self) -> bool:
+        return self.return_type is None
+
+
+@dataclass(frozen=True)
+class FunctionDecl:
+    signature: FunctionSignature | SpecialFunctions = field(default_factory=FunctionSignature)
+
     # Egg params
     builtin: bool = False
     egg_name: str | None = None
@@ -367,17 +391,6 @@ class FunctionDecl:
     def to_function_decl(self) -> FunctionDecl:
         return self
 
-    @property
-    def semantic_return_type(self) -> TypeOrVarRef:
-        """
-        The type that is returned by the function, which wil be in the first arg if it mutates it.
-        """
-        return self.return_type or self.arg_types[0]
-
-    @property
-    def mutates(self) -> bool:
-        return self.return_type is None
-
 
 CallableDecl: TypeAlias = RelationDecl | ConstantDecl | FunctionDecl
 
@@ -463,7 +476,20 @@ class CallDecl:
         return hash(self) == hash(other)
 
 
-ExprDecl: TypeAlias = VarDecl | LitDecl | CallDecl | PyObjectDecl
+@dataclass(frozen=True)
+class PartialCallDecl:
+    """
+    A partially applied function aka a function sort.
+
+    Note it does not need to have any args, in which case it's just a function pointer.
+
+    Seperated from the call decl so it's clear it is translated to a `unstable-fn` call.
+    """
+
+    call: CallDecl
+
+
+ExprDecl: TypeAlias = VarDecl | LitDecl | CallDecl | PyObjectDecl | PartialCallDecl
 
 
 @dataclass(frozen=True)

egglog/egraph.py

@@ -75,6 +75,7 @@ __all__ = [
     "seq",
     "Command",
     "simplify",
+    "unstable_combine_rulesets",
     "check",
     "GraphvizKwargs",
     "Ruleset",
@@ -88,6 +89,7 @@ __all__ = [
     "Fact",
     "Action",
     "Command",
+    "check_eq",
 ]
 
 T = TypeVar("T")
@@ -145,6 +147,23 @@ def simplify(x: EXPR, schedule: Schedule | None = None) -> EXPR:
     return EGraph().extract(x)
 
 
+def check_eq(x: EXPR, y: EXPR, schedule: Schedule | None = None) -> EGraph:
+    """
+    Verifies that two expressions are equal after running the schedule.
+    """
+    egraph = EGraph()
+    x_var = egraph.let("__check_eq_x", x)
+    y_var = egraph.let("__check_eq_y", y)
+    if schedule:
+        egraph.run(schedule)
+    fact = eq(x_var).to(y_var)
+    try:
+        egraph.check(fact)
+    except bindings.EggSmolError as err:
+        raise AssertionError(f"Failed {eq(x).to(y)}\n -> {ne(egraph.extract(x)).to(egraph.extract(y))})") from err
+    return egraph
+
+
 def check(x: FactLike, schedule: Schedule | None = None, *given: ActionLike) -> None:
     """
     Verifies that the fact is true given some assumptions and after running the schedule.
@@ -456,7 +475,7 @@ class _ExprMetaclass(type):
         return isinstance(instance, RuntimeExpr)
 
 
-def _generate_class_decls(
+def _generate_class_decls(  # noqa: C901
     namespace: dict[str, Any], frame: FrameType, builtin: bool, egg_sort: str | None, cls_name: str
 ) -> Declarations:
     """
@@ -518,6 +537,16 @@ def _generate_class_decls(
         locals = frame.f_locals
 
         def create_decl(fn: object, first: Literal["cls"] | TypeRefWithVars) -> FunctionDecl:
+            special_function_name: SpecialFunctions | None = (
+                "fn-partial" if egg_fn == "unstable-fn" else "fn-app" if egg_fn == "unstable-app" else None  # noqa: B023
+            )
+            if special_function_name:
+                return FunctionDecl(
+                    special_function_name,
+                    builtin=True,
+                    egg_name=egg_fn,  # noqa: B023
+                )
+
             return _fn_decl(
                 decls,
                 egg_fn,  # noqa: B023
@@ -649,6 +678,10 @@ def _fn_decl(
         raise NotImplementedError(f"Can only generate function decls for functions not {fn}  {type(fn)}")
 
     hint_globals = fn.__globals__.copy()
+    # Copy Callable into global if not present bc sometimes it gets automatically removed by ruff to type only block
+    # https://docs.astral.sh/ruff/rules/typing-only-standard-library-import/
+    if "Callable" not in hint_globals:
+        hint_globals["Callable"] = Callable
 
     hints = get_type_hints(fn, hint_globals, hint_locals)
 
@@ -715,11 +748,13 @@ def _fn_decl(
     )
     decls.update(*merge_action)
     return FunctionDecl(
-        return_type=None if mutates_first_arg else return_type,
-        var_arg_type=var_arg_type,
-        arg_types=arg_types,
-        arg_names=tuple(t.name for t in params),
-        arg_defaults=tuple(a.__egg_typed_expr__.expr if a is not None else None for a in arg_defaults),
+        FunctionSignature(
+            return_type=None if mutates_first_arg else return_type,
+            var_arg_type=var_arg_type,
+            arg_types=arg_types,
+            arg_names=tuple(t.name for t in params),
+            arg_defaults=tuple(a.__egg_typed_expr__.expr if a is not None else None for a in arg_defaults),
+        ),
         cost=cost,
         egg_name=egg_name,
         merge=merged.__egg_typed_expr__.expr if merged is not None else None,
@@ -933,13 +968,12 @@ class EGraph(_BaseModule):
         """
         Displays the e-graph in the notebook.
         """
-        graphviz = self.graphviz(**kwargs)
         if IN_IPYTHON:
             from IPython.display import SVG, display
 
             display(SVG(self.graphviz_svg(**kwargs)))
         else:
-            graphviz.render(view=True, format="svg", quiet=True)
+            self.graphviz(**kwargs).render(view=True, format="svg", quiet=True)
 
     def input(self, fn: Callable[..., String], path: str) -> None:
         """
@@ -1059,7 +1093,7 @@ class EGraph(_BaseModule):
         runtime_expr = to_runtime_expr(expr)
         self._add_decls(runtime_expr)
         typed_expr = runtime_expr.__egg_typed_expr__
-        extract_report = self._run_extract(typed_expr.expr, 0)
+        extract_report = self._run_extract(typed_expr, 0)
 
         if not isinstance(extract_report, bindings.Best):
             msg = "No extract report saved"
@@ -1079,15 +1113,16 @@ class EGraph(_BaseModule):
         self._add_decls(runtime_expr)
         typed_expr = runtime_expr.__egg_typed_expr__
 
-        extract_report = self._run_extract(typed_expr.expr, n)
+        extract_report = self._run_extract(typed_expr, n)
         if not isinstance(extract_report, bindings.Variants):
             msg = "Wrong extract report type"
             raise ValueError(msg)  # noqa: TRY004
         new_exprs = self._state.exprs_from_egg(extract_report.termdag, extract_report.terms, typed_expr.tp)
         return [cast(EXPR, RuntimeExpr.__from_value__(self.__egg_decls__, expr)) for expr in new_exprs]
 
-    def _run_extract(self, expr: ExprDecl, n: int) -> bindings._ExtractReport:
-        expr = self._state.expr_to_egg(expr)
+    def _run_extract(self, typed_expr: TypedExprDecl, n: int) -> bindings._ExtractReport:
+        self._state.type_ref_to_egg(typed_expr.tp)
+        expr = self._state.expr_to_egg(typed_expr.expr)
         self._egraph.run_program(bindings.ActionCommand(bindings.Extract(expr, bindings.Lit(bindings.Int(n)))))
         extract_report = self._egraph.extract_report()
         if not extract_report:
@@ -1276,8 +1311,10 @@ def ruleset(
     """
     Creates a ruleset with the following rules.
 
-    If no name is provided, one is generated based on the current module
+    If no name is provided, try using the name of the funciton.
     """
+    if isinstance(rule_or_generator, FunctionType):
+        name = name or rule_or_generator.__name__
     r = Ruleset(name)
     if rule_or_generator is not None:
         r.register(rule_or_generator, *rules, _increase_frame=True)
@@ -1388,12 +1425,48 @@ class Ruleset(Schedule):
     def __repr__(self) -> str:
         return str(self)
 
+    def __or__(self, other: Ruleset | UnstableCombinedRuleset) -> UnstableCombinedRuleset:
+        return unstable_combine_rulesets(self, other)
+
     # Create a unique name if we didn't pass one from the user
     @property
     def __egg_name__(self) -> str:
         return self.name or f"ruleset_{id(self)}"
 
 
+@dataclass
+class UnstableCombinedRuleset(Schedule):
+    __egg_decls_thunk__: Callable[[], Declarations] = field(init=False)
+    schedule: RunDecl = field(init=False)
+    name: str | None
+    rulesets: InitVar[list[Ruleset | UnstableCombinedRuleset]]
+
+    def __post_init__(self, rulesets: list[Ruleset | UnstableCombinedRuleset]) -> None:
+        self.schedule = RunDecl(self.__egg_name__, ())
+        self.__egg_decls_thunk__ = Thunk.fn(self._create_egg_decls, *rulesets)
+
+    @property
+    def __egg_name__(self) -> str:
+        return self.name or f"combined_ruleset_{id(self)}"
+
+    def _create_egg_decls(self, *rulesets: Ruleset | UnstableCombinedRuleset) -> Declarations:
+        decls = Declarations.create(*rulesets)
+        decls._rulesets[self.__egg_name__] = CombinedRulesetDecl(tuple(r.__egg_name__ for r in rulesets))
+        return decls
+
+    def __or__(self, other: Ruleset | UnstableCombinedRuleset) -> UnstableCombinedRuleset:
+        return unstable_combine_rulesets(self, other)
+
+
+def unstable_combine_rulesets(
+    *rulesets: Ruleset | UnstableCombinedRuleset, name: str | None = None
+) -> UnstableCombinedRuleset:
+    """
+    Combine multiple rulesets into a single ruleset.
+    """
+    return UnstableCombinedRuleset(name, list(rulesets))
+
+
 @dataclass
 class RewriteOrRule:
     __egg_decls__: Declarations
@@ -1556,9 +1629,9 @@ def var(name: str, bound: type[EXPR]) -> EXPR:
 
 def _var(name: str, bound: object) -> RuntimeExpr:
     """Create a new variable with the given name and type."""
-    if not isinstance(bound, RuntimeClass):
-        raise TypeError(f"Unexpected type {type(bound)}")
-    return RuntimeExpr.__from_value__(bound.__egg_decls__, TypedExprDecl(bound.__egg_tp__.to_just(), VarDecl(name)))
+    decls = Declarations()
+    type_ref = resolve_type_annotation(decls, bound)
+    return RuntimeExpr.__from_value__(decls, TypedExprDecl(type_ref.to_just(), VarDecl(name)))
 
 
 def vars_(names: str, bound: type[EXPR]) -> Iterable[EXPR]:
@@ -1801,8 +1874,10 @@ def _rewrite_or_rule_generator(gen: RewriteOrRuleGenerator, frame: FrameType) ->
     """
     # Get the local scope from where the function is defined, so that we can get any type hints that are in the scope
     # but not in the globals
-
-    hints = get_type_hints(gen, gen.__globals__, frame.f_locals)
+    globals = gen.__globals__.copy()
+    if "Callable" not in globals:
+        globals["Callable"] = Callable
+    hints = get_type_hints(gen, globals, frame.f_locals)
     args = [_var(p.name, hints[p.name]) for p in signature(gen).parameters.values()]
     return list(gen(*args))  # type: ignore[misc]