Add type inference module for embedding polymorphic types (#299)

* first commit

* format

* test passes

* types

* add docstring with doctests for unify

* more test cases

* case

* docstring and test cases for infer_return_type

* canonicalize

* fixes

* fix error type

* add _nested_type for sequences

* make _nested_type singledispatch extensible

* term case

* nit

* docstrings and tests for canonicalize and nested_type

* no notimmplentederror

* variadic params

* remove dead code paths in unify

* simplify unify

* union

* tweak

* cleanup

* fix none case

* more aggressive canonicalize applied only during unification

* update canonicalize test

* remove dead path

* paramspec failure

* literal and optional

* paramspec canonicalize

* simplify alias

* single unify call

* fast paths

* union handling

* freshen

* type of freshen

* reorder

* fixpoint in substitute

* tweak types

* empty params

* tweak substitute type

* doctest

* separate nested_type

* handle defaults

* update

* remove test ids

* add to sphinx

* fix doctests

* fix type checking

* str

* lint and format

* freshen -> _freshen

* factor out freetypevars and susbtitute

* truncate names

* doctest

* doctest

* add compositional tests

* add tests for function types

* ellipsis and paramspec

* variadic tuple logic and union tests

* fix union unify pattern

* Use unification to implement `Operation.__type_rule__` (#300)

* Use infer_return_type to implement Operation.__type_rule__

* move some logic out of infer_return_type

* dont add defaults

* update

* remove duplicate default param logic

* fix and format

* lint

* fix semiring test

* address comment

* update to 3.12

* union

* try truncating??

* tweaks

* split up expression in _freshen

* no parallel build

* revert script

* break expressions u

* script

* try again with old script??

* rewrite

* simplify

* finer error type

* pin jax

* use typing internal api for substitute and freetypevars, and make canonicalize more robust

* internal api

* revert api

* add test

* fix doctest

* remove unused var

* address some comments

* default attr

* union soundness

* fix union and add variadic assertion

* reinstate support for bounds to make tests pass

* nodefault

* lint

* forwardref

Author: eb8680

docs/source/effectful.rst

@@ -98,3 +98,7 @@ Internals
 .. automodule:: effectful.internals.runtime
    :members:
    :undoc-members:
+
+.. automodule:: effectful.internals.unification
+   :members:
+   :undoc-members:

docs/source/semi_ring.py

@@ -62,17 +62,17 @@ def Let[S, T, A, B](
 
 
 @defop
-def Record[T](**kwargs: T) -> dict[str, T]:
+def Record[T](**kwargs: T) -> collections.abc.Mapping[str, T]:
     raise NotImplementedError
 
 
 @defop
-def Field[T](record: dict[str, T], key: str) -> T:
+def Field[T](record: collections.abc.Mapping[str, T], key: str) -> T:
     raise NotImplementedError
 
 
 @defop
-def Dict[K, V](*contents: Union[K, V]) -> SemiRingDict[K, V]:
+def Dict[K, V](*contents: tuple[K, V]) -> SemiRingDict[K, V]:
     raise NotImplementedError
 
 
@@ -92,20 +92,14 @@ def add[T](x: T, y: T) -> T:
 ops.Field = Field
 
 
-def eager_dict[K, V](*contents: Tuple[K, V]) -> SemiRingDict[K, V]:
-    if not any(isinstance(v, Term) for v in contents):
-        if len(contents) % 2 != 0:
-            raise ValueError("Dict requires an even number of arguments")
-
-        kv = []
-        for i in range(0, len(contents), 2):
-            kv.append((contents[i], contents[i + 1]))
-        return SemiRingDict(kv)
+def eager_dict[K, V](*contents: tuple[K, V]) -> SemiRingDict[K, V]:
+    if not any(isinstance(v, Term) for kv in contents for v in kv):
+        return SemiRingDict(list(contents))
     else:
         return fwd()
 
 
-def eager_record[T](**kwargs: T) -> dict[str, T]:
+def eager_record[T](**kwargs: T) -> collections.abc.Mapping[str, T]:
     if not any(isinstance(v, Term) for v in kwargs.values()):
         return dict(**kwargs)
     else:
@@ -215,7 +209,7 @@ def vertical_fusion[S, T](e1: T, x: Operation[[], T], e2: S) -> S:
     )
 
     term: SemiRingDict[int, int] = Let(
-        Sum(x(), k, v, Dict(k(), v() + 1)), y, Sum(y(), k, v, Dict(k(), v() + 1))
+        Sum(x(), k, v, Dict((k(), v() + 1))), y, Sum(y(), k, v, Dict((k(), v() + 1)))
     )
 
     print("Without optimization:", term)