effectful 0.0.1__py3-none-any.whl → 0.1.0__py3-none-any.whl

effectful/ops/types.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
 import abc
+import collections.abc
+import inspect
 import typing
-from typing import Any, Callable, Generic, Mapping, Sequence, Set, Type, TypeVar, Union
+from typing import Any, Callable, Generic, Mapping, Sequence, Type, TypeVar, Union
 
 from typing_extensions import ParamSpec
 
@@ -22,6 +24,9 @@ class Operation(abc.ABC, Generic[Q, V]):
 
     """
 
+    __signature__: inspect.Signature
+    __name__: str
+
     @abc.abstractmethod
     def __eq__(self, other):
         raise NotImplementedError
@@ -38,19 +43,24 @@ class Operation(abc.ABC, Generic[Q, V]):
         """
         raise NotImplementedError
 
-    @abc.abstractmethod
-    def __free_rule__(self, *args: Q.args, **kwargs: Q.kwargs) -> "Expr[V]":
-        """Returns a term for the operation applied to arguments."""
-        raise NotImplementedError
-
     @abc.abstractmethod
     def __type_rule__(self, *args: Q.args, **kwargs: Q.kwargs) -> Type[V]:
         """Returns the type of the operation applied to arguments."""
         raise NotImplementedError
 
     @abc.abstractmethod
-    def __fvs_rule__(self, *args: Q.args, **kwargs: Q.kwargs) -> Set["Operation"]:
-        """Returns the free variables of the operation applied to arguments."""
+    def __fvs_rule__(self, *args: Q.args, **kwargs: Q.kwargs) -> tuple[
+        tuple[collections.abc.Set["Operation"], ...],
+        dict[str, collections.abc.Set["Operation"]],
+    ]:
+        """
+        Returns the sets of variables that appear free in each argument and keyword argument
+        but not in the result of the operation, i.e. the variables bound by the operation.
+
+        These are used by :func:`fvsof` to determine the free variables of a term by
+        subtracting the results of this method from the free variables of the subterms,
+        allowing :func:`fvsof` to be implemented in terms of :func:`evaluate` .
+        """
         raise NotImplementedError
 
     @abc.abstractmethod
@@ -77,19 +87,19 @@ class Term(abc.ABC, Generic[T]):
     @abc.abstractmethod
     def op(self) -> Operation[..., T]:
         """Abstract property for the operation."""
-        pass
+        raise NotImplementedError
 
     @property
     @abc.abstractmethod
     def args(self) -> Sequence["Expr[Any]"]:
         """Abstract property for the arguments."""
-        pass
+        raise NotImplementedError
 
     @property
     @abc.abstractmethod
     def kwargs(self) -> Mapping[str, "Expr[Any]"]:
         """Abstract property for the keyword arguments."""
-        pass
+        raise NotImplementedError
 
     def __repr__(self) -> str:
         from effectful.internals.runtime import interpreter
@@ -106,5 +116,9 @@ Expr = Union[T, Term[T]]
 Interpretation = Mapping[Operation[..., T], Callable[..., V]]
 
 
-class ArgAnnotation:
-    pass
+class Annotation(abc.ABC):
+
+    @classmethod
+    @abc.abstractmethod
+    def infer_annotations(cls, sig: inspect.Signature) -> inspect.Signature:
+        raise NotImplementedError

{effectful-0.0.1.dist-info → effectful-0.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: effectful
-Version: 0.0.1
+Version: 0.1.0
 Summary: Metaprogramming infrastructure
 Home-page: https://www.basis.ai/
 Author: Basis
@@ -28,6 +28,12 @@ Provides-Extra: dev
 Requires-Dist: torch; extra == "dev"
 Requires-Dist: pyro-ppl; extra == "dev"
 Requires-Dist: torch; extra == "dev"
+Requires-Dist: setuptools; extra == "dev"
+Requires-Dist: sphinx; extra == "dev"
+Requires-Dist: sphinxcontrib-bibtex; extra == "dev"
+Requires-Dist: sphinx_rtd_theme; extra == "dev"
+Requires-Dist: myst-parser; extra == "dev"
+Requires-Dist: nbsphinx; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: pytest-xdist; extra == "dev"
@@ -36,13 +42,15 @@ Requires-Dist: mypy; extra == "dev"
 Requires-Dist: black; extra == "dev"
 Requires-Dist: flake8; extra == "dev"
 Requires-Dist: isort; extra == "dev"
-Requires-Dist: sphinx; extra == "dev"
-Requires-Dist: sphinxcontrib-bibtex; extra == "dev"
-Requires-Dist: sphinx_rtd_theme; extra == "dev"
-Requires-Dist: myst-parser; extra == "dev"
-Requires-Dist: nbsphinx; extra == "dev"
 Requires-Dist: nbval; extra == "dev"
 Requires-Dist: nbqa; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: setuptools; extra == "docs"
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinxcontrib-bibtex; extra == "docs"
+Requires-Dist: sphinx_rtd_theme; extra == "docs"
+Requires-Dist: myst-parser; extra == "docs"
+Requires-Dist: nbsphinx; extra == "docs"
 Dynamic: author
 Dynamic: classifier
 Dynamic: description
@@ -55,6 +63,7 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
+
 .. index-inclusion-marker
 
 Effectful 
@@ -75,7 +84,7 @@ Install From Source
    git clone git@github.com:BasisResearch/effectful.git
    cd effectful
    git checkout master
-   pip install -e .[test]
+   pip install -e .[pyro]
 
 Install With Optional PyTorch/Pyro Support
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -103,16 +112,12 @@ Here's an example demonstrating how ``effectful`` can be used to implement a sim
 
 .. code:: python
 
-   import operator
    import functools
 
-   from effectful.handlers.operator import OPERATORS
    from effectful.ops.types import Term
    from effectful.ops.syntax import defop
    from effectful.ops.semantics import handler, evaluate, coproduct, fwd
-   import effectful.handlers.operator
-
-   add = OPERATORS[operator.add]
+   from effectful.handlers.numbers import add
 
    def beta_add(x: int, y: int) -> int:        
        match x, y:

effectful-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+effectful/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+effectful/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+effectful/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+effectful/handlers/indexed.py,sha256=k98C-Gtm8rQPfCYRCUVEPlElwiD3PwWGZ5hwNTTaIt8,12651
+effectful/handlers/numbers.py,sha256=X-RI9IcOahSrwDNF0xZtQwxBvgKbNQpJRB_m9Vzy-Ew,6656
+effectful/handlers/pyro.py,sha256=r0Zyv9nNDaAdwujI3J-nlsIrlAHp-AAuLQ5DfG8S2q4,15294
+effectful/handlers/torch.py,sha256=cQxrIJUiC2Zmiz6e_OS-DgtVsHGr_MCsoTY2kvZ05Y4,18945
+effectful/internals/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+effectful/internals/runtime.py,sha256=E0ce5mfG0-DlTeALYZePWtdxr0AK3y0CPl_LE5pp_0k,1908
+effectful/ops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+effectful/ops/semantics.py,sha256=w5UWCkUH1UznIB4NKaQE1TCA2cOLlnbRKd0PNma30Rg,10252
+effectful/ops/syntax.py,sha256=U2URezErfQPySVpLNd7Wzx6ZXZwHDo4LZOvhalaXeBI,38241
+effectful/ops/types.py,sha256=vTg6eQQN5Xq1KIelUfEUvpofO2iJ3x8YbiyPzNESTjQ,3823
+effectful-0.1.0.dist-info/LICENSE.md,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+effectful-0.1.0.dist-info/METADATA,sha256=mBVk7m_Lf3GkcR1WVQaKCMJ5f4AeAykMYCocITL7cko,5165
+effectful-0.1.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+effectful-0.1.0.dist-info/top_level.txt,sha256=gtuJfrE2nXil_lZLCnqWF2KAbOnJs9ILNvK8WnkRzbs,10
+effectful-0.1.0.dist-info/RECORD,,

effectful/internals/base_impl.py

@@ -1,259 +0,0 @@
-import collections
-import functools
-import inspect
-import typing
-from typing import Callable, Generic, Mapping, Sequence, Set, Type, TypeVar
-
-import tree
-from typing_extensions import ParamSpec
-
-from effectful.ops.types import Expr, Operation, Term
-
-P = ParamSpec("P")
-Q = ParamSpec("Q")
-S = TypeVar("S")
-T = TypeVar("T")
-V = TypeVar("V")
-
-
-def rename(
-    subs: Mapping[Operation[..., S], Operation[..., S]],
-    leaf_value: V,  # Union[Term[V], Operation[..., V], V],
-) -> V:  # Union[Term[V], Operation[..., V], V]:
-    from effectful.internals.runtime import interpreter
-    from effectful.ops.semantics import apply, evaluate
-
-    if isinstance(leaf_value, Operation):
-        return subs.get(leaf_value, leaf_value)  # type: ignore
-    elif isinstance(leaf_value, Term):
-        with interpreter(
-            {apply: lambda _, op, *a, **k: op.__free_rule__(*a, **k), **subs}
-        ):
-            return evaluate(leaf_value)  # type: ignore
-    else:
-        return leaf_value
-
-
-class _BaseOperation(Generic[Q, V], Operation[Q, V]):
-    signature: Callable[Q, V]
-
-    def __init__(self, signature: Callable[Q, V]):
-        functools.update_wrapper(self, signature)
-        self.signature = signature
-
-    def __eq__(self, other):
-        if not isinstance(other, Operation):
-            return NotImplemented
-        return self.signature == other.signature
-
-    def __hash__(self):
-        return hash(self.signature)
-
-    def __default_rule__(self, *args: Q.args, **kwargs: Q.kwargs) -> "Expr[V]":
-        from effectful.ops.syntax import NoDefaultRule
-
-        try:
-            return self.signature(*args, **kwargs)
-        except NoDefaultRule:
-            return self.__free_rule__(*args, **kwargs)
-
-    def __free_rule__(self, *args: Q.args, **kwargs: Q.kwargs) -> "Expr[V]":
-        from effectful.ops.syntax import Bound, Scoped, defdata, defop
-
-        sig = inspect.signature(self.signature)
-        bound_sig = sig.bind(*args, **kwargs)
-        bound_sig.apply_defaults()
-
-        bound_vars: dict[int, set[Operation]] = collections.defaultdict(set)
-        scoped_args: dict[int, set[str]] = collections.defaultdict(set)
-        unscoped_args: set[str] = set()
-        for param_name, param in bound_sig.signature.parameters.items():
-            if typing.get_origin(param.annotation) is typing.Annotated:
-                for anno in param.annotation.__metadata__:
-                    if isinstance(anno, Bound):
-                        scoped_args[anno.scope].add(param_name)
-                        if param.kind is inspect.Parameter.VAR_POSITIONAL:
-                            assert isinstance(bound_sig.arguments[param_name], tuple)
-                            for bound_var in bound_sig.arguments[param_name]:
-                                bound_vars[anno.scope].add(bound_var)
-                        elif param.kind is inspect.Parameter.VAR_KEYWORD:
-                            assert isinstance(bound_sig.arguments[param_name], dict)
-                            for bound_var in bound_sig.arguments[param_name].values():
-                                bound_vars[anno.scope].add(bound_var)
-                        else:
-                            bound_vars[anno.scope].add(bound_sig.arguments[param_name])
-                    elif isinstance(anno, Scoped):
-                        scoped_args[anno.scope].add(param_name)
-            else:
-                unscoped_args.add(param_name)
-
-        # TODO replace this temporary check with more general scope level propagation
-        if bound_vars:
-            min_scope = min(bound_vars.keys(), default=0)
-            scoped_args[min_scope] |= unscoped_args
-            max_scope = max(bound_vars.keys(), default=0)
-            assert all(s in bound_vars or s > max_scope for s in scoped_args.keys())
-
-        # recursively rename bound variables from innermost to outermost scope
-        for scope in sorted(bound_vars.keys()):
-            # create fresh variables for each bound variable in the scope
-            renaming_map = {var: defop(var) for var in bound_vars[scope]}
-            # get just the arguments that are in the scope
-            for name in scoped_args[scope]:
-                bound_sig.arguments[name] = tree.map_structure(
-                    lambda a: rename(renaming_map, a),
-                    bound_sig.arguments[name],
-                )
-
-        return defdata(_BaseTerm(self, bound_sig.args, bound_sig.kwargs))
-
-    def __type_rule__(self, *args: Q.args, **kwargs: Q.kwargs) -> Type[V]:
-        sig = inspect.signature(self.signature)
-        bound_sig = sig.bind(*args, **kwargs)
-        bound_sig.apply_defaults()
-
-        anno = sig.return_annotation
-        if anno is inspect.Signature.empty:
-            return typing.cast(Type[V], object)
-        elif isinstance(anno, typing.TypeVar):
-            # rudimentary but sound special-case type inference sufficient for syntax ops:
-            # if the return type annotation is a TypeVar,
-            # look for a parameter with the same annotation and return its type,
-            # otherwise give up and return Any/object
-            for name, param in bound_sig.signature.parameters.items():
-                if param.annotation is anno and param.kind not in (
-                    inspect.Parameter.VAR_POSITIONAL,
-                    inspect.Parameter.VAR_KEYWORD,
-                ):
-                    arg = bound_sig.arguments[name]
-                    tp: Type[V] = type(arg) if not isinstance(arg, type) else arg
-                    return tp
-            return typing.cast(Type[V], object)
-        elif typing.get_origin(anno) is typing.Annotated:
-            tp = typing.get_args(anno)[0]
-            if not typing.TYPE_CHECKING:
-                tp = tp if typing.get_origin(tp) is None else typing.get_origin(tp)
-            return tp
-        elif typing.get_origin(anno) is not None:
-            return typing.get_origin(anno)
-        else:
-            return anno
-
-    def __fvs_rule__(self, *args: Q.args, **kwargs: Q.kwargs) -> Set[Operation]:
-        from effectful.ops.syntax import Bound
-
-        sig = inspect.signature(self.signature)
-        bound_sig = sig.bind(*args, **kwargs)
-        bound_sig.apply_defaults()
-
-        bound_vars: Set[Operation] = set()
-        for param_name, param in bound_sig.signature.parameters.items():
-            if typing.get_origin(param.annotation) is typing.Annotated:
-                for anno in param.annotation.__metadata__:
-                    if isinstance(anno, Bound):
-                        if param.kind is inspect.Parameter.VAR_POSITIONAL:
-                            for bound_var in bound_sig.arguments[param_name]:
-                                bound_vars.add(bound_var)
-                        elif param.kind is inspect.Parameter.VAR_KEYWORD:
-                            for bound_var in bound_sig.arguments[param_name].values():
-                                bound_vars.add(bound_var)
-                        else:
-                            bound_var = bound_sig.arguments[param_name]
-                            bound_vars.add(bound_var)
-
-        return bound_vars
-
-    def __repr_rule__(self, *args: Q.args, **kwargs: Q.kwargs) -> str:
-        args_str = ", ".join(map(str, args)) if args else ""
-        kwargs_str = (
-            ", ".join(f"{k}={str(v)}" for k, v in kwargs.items()) if kwargs else ""
-        )
-
-        ret = f"{self.signature.__name__}({args_str}"
-        if kwargs:
-            ret += f"{', ' if args else ''}"
-        ret += f"{kwargs_str})"
-        return ret
-
-    def __repr__(self):
-        return self.signature.__name__
-
-
-class _BaseTerm(Generic[T], Term[T]):
-    _op: Operation[..., T]
-    _args: Sequence[Expr]
-    _kwargs: Mapping[str, Expr]
-
-    def __init__(
-        self,
-        op: Operation[..., T],
-        args: Sequence[Expr],
-        kwargs: Mapping[str, Expr],
-    ):
-        self._op = op
-        self._args = args
-        self._kwargs = kwargs
-
-    def __eq__(self, other) -> bool:
-        from effectful.ops.syntax import syntactic_eq
-
-        return syntactic_eq(self, other)
-
-    @property
-    def op(self):
-        return self._op
-
-    @property
-    def args(self):
-        return self._args
-
-    @property
-    def kwargs(self):
-        return self._kwargs
-
-
-class _CallableTerm(Generic[P, T], _BaseTerm[collections.abc.Callable[P, T]]):
-    def __call__(self, *args: Expr, **kwargs: Expr) -> Expr[T]:
-        from effectful.ops.semantics import call
-
-        return call(self, *args, **kwargs)  # type: ignore
-
-
-def _unembed_callable(value: Callable[P, T]) -> Expr[Callable[P, T]]:
-    from effectful.internals.runtime import interpreter
-    from effectful.ops.semantics import apply, call
-    from effectful.ops.syntax import deffn, defop
-
-    assert not isinstance(value, Term)
-
-    try:
-        sig = inspect.signature(value)
-    except ValueError:
-        return value
-
-    for name, param in sig.parameters.items():
-        if param.kind in (
-            inspect.Parameter.VAR_POSITIONAL,
-            inspect.Parameter.VAR_KEYWORD,
-        ):
-            raise NotImplementedError(
-                f"cannot unembed {value}: parameter {name} is variadic"
-            )
-
-    bound_sig = sig.bind(
-        **{name: defop(param.annotation) for name, param in sig.parameters.items()}
-    )
-    bound_sig.apply_defaults()
-
-    with interpreter(
-        {
-            apply: lambda _, op, *a, **k: op.__free_rule__(*a, **k),
-            call: call.__default_rule__,
-        }
-    ):
-        body = value(
-            *[a() for a in bound_sig.args],
-            **{k: v() for k, v in bound_sig.kwargs.items()},
-        )
-
-    return deffn(body, *bound_sig.args, **bound_sig.kwargs)

effectful-0.0.1.dist-info/RECORD

@@ -1,19 +0,0 @@
-effectful/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-effectful/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-effectful/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-effectful/handlers/indexed.py,sha256=lNqlHZqD8JBs-KaC3YdCoQDAXHuQ9KhAH0ZhpIqMdFM,13184
-effectful/handlers/numbers.py,sha256=aKVCJ-l3ISvOGHTfXsQIEp4uEsQsYy7bP-YUCsSO_3o,6557
-effectful/handlers/pyro.py,sha256=s_CAXe65gqXmKiYLUXJ0_uLQzEEgyQbZv0hQWMMdQJ4,15312
-effectful/handlers/torch.py,sha256=LJYwud6Dq3xg7A6_6aaDEyP1hT0IB4G_55Gki6izRvo,18401
-effectful/internals/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-effectful/internals/base_impl.py,sha256=6Yxxg5tS_R2RLlHvtOhj_fuA_9hEa_YKf0LhQOX2448,9671
-effectful/internals/runtime.py,sha256=E0ce5mfG0-DlTeALYZePWtdxr0AK3y0CPl_LE5pp_0k,1908
-effectful/ops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-effectful/ops/semantics.py,sha256=Ihaj2ycildtMg18GSujSJSaAAKsArKoyMmR-gBoWx8E,10208
-effectful/ops/syntax.py,sha256=nRfguHAol5lDnUv0UMOB0AL6y6By2DCW7hlCYsN3OnM,15331
-effectful/ops/types.py,sha256=DmVqX8naWNQEW1A6w7ShrXp_LZV6qoK4p_OAM3NitTI,3241
-effectful-0.0.1.dist-info/LICENSE.md,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-effectful-0.0.1.dist-info/METADATA,sha256=WN7j_mJwZao1T1MTWyAIo_1hP6YUCS4L6rPI9wWCScA,4930
-effectful-0.0.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-effectful-0.0.1.dist-info/top_level.txt,sha256=gtuJfrE2nXil_lZLCnqWF2KAbOnJs9ILNvK8WnkRzbs,10
-effectful-0.0.1.dist-info/RECORD,,