Technologicat
diff --git a/‎CHANGELOG.md‎
Lines changed: 2 additions & 0 deletions b/‎CHANGELOG.md‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎doc/features.md‎
Lines changed: 4 additions & 4 deletions b/‎doc/features.md‎
Lines changed: 4 additions & 4 deletions
diff --git a/‎unpythonic/arity.py‎
Lines changed: 38 additions & 6 deletions b/‎unpythonic/arity.py‎
Lines changed: 38 additions & 6 deletions
@@ -87,6 +87,8 @@ The same applies if you need the macro parts of `unpythonic` (i.e. import anythi
     - Add function `isgeneric` to detect whether a callable has been declared `@generic`.
     - Add function `methods`: display a list of multimethods of a generic function.
     - It is now possible to dispatch on a homogeneous type of contents collected by a `**kwargs` parameter.
+    - `curry` now supports `@generic` functions.
+    - The utilities `arities`, `required_kwargs`, and `optional_kwargs` now support `@generic` functions.
   - Add `unpythonic.excutil.reraise_in` (expr form), `unpythonic.excutil.reraise` (block form): conveniently remap library exception types to application exception types. Idea from [Alexis King (2016): Four months with Haskell](https://lexi-lambda.github.io/blog/2016/06/12/four-months-with-haskell/).
   - Add variants of the above for the conditions-and-restarts system: `unpythonic.conditions.resignal_in`, `unpythonic.conditions.resignal`. The new signal is sent using the same error-handling protocol as the original signal, so that e.g. an `error` remains an `error` even if re-signaling changes its type.
   - All documentation files now have a quick navigation section to skip to another part of the docs. (For all except the README, it's at the top.)
 
@@ -3015,6 +3015,10 @@ The core idea can be expressed in fewer than 100 lines of Python; ours is (as of
 
 *Docstrings of the multimethods are now automatically concatenated to make up the docstring of the generic function, so you can document each multimethod separately.*
 
+*`curry` now supports `@generic`. In the case where the **number** of positional arguments supplied so far matches at least one multimethod, but there is no match for the given combination of argument **types**, `curry` waits for more arguments (returning the curried function).*
+
+**CAUTION**: *Determining whether there **could** be a match for a `@generic` is the only type checking performed by ``curry``. When using ``curry`` with ``@generic`` or ``@typed``, argument type errors are only detected when the actual call triggers - just like in code using ``curry`` and traditional run-time ``isinstance`` checks. This may make it hard to debug.*
+
 *It is now possible to dispatch also on a homogeneous type of contents collected by a `**kwargs` parameter. In the type signature, use `typing.Dict[str, mytype]`. Note that in this use, the key type is always `str`.*
 
 The ``generic`` decorator allows creating multiple-dispatch generic functions with type annotation syntax. We also provide some friendly utilities: ``typed`` creates a single-method generic with the same syntax (i.e. provides a compact notation for writing dynamic type checking code), and ``isoftype`` (which powers the first two) is the big sister of ``isinstance``, with support for many (but unfortunately not all) features of the ``typing`` standard library module.
@@ -3036,8 +3040,6 @@ If several multimethods of the same generic function match the arguments given,
 
 **CAUTION**: The winning multimethod is chosen differently from Julia, where the most specific multimethod wins. Doing that requires a more careful type analysis than what we have here.
 
-**CAUTION**: `@generic` does not currently work with `curry`. Adding support requires changes to the already complex logic in `curry`; it is not high on the priority list.
-
 The details are best explained by example:
 
 ```python
@@ -3165,8 +3167,6 @@ jack(3.14)  # TypeError
 
 For which features of the ``typing`` stdlib module are supported, see ``isoftype`` below.
 
-**CAUTION**: When using ``typed`` with ``curry``, the type checking (and hence ``TypeError``, if any) only occurs when the actual call triggers. Code using that combination may be hard to debug.
-
 
 #### ``isoftype``: the big sister of ``isinstance``
 
 
@@ -217,6 +217,9 @@ def arities(f):
      does not implicitly provide a `self`, because there is none to be had. This
      behavior is reflected in the return value of `arities`.)
 
+    If `f` is `@generic` (see `unpythonic.dispatch`), we scan its multimethods,
+    and return the smallest `min_arity` and the largest `max_arity`.
+
     Parameters:
         `f`: function
             The function to inspect.
@@ -238,6 +241,20 @@ def arities(f):
             return _builtin_arities[f]
     except TypeError:  # f is of an unhashable type
         pass
+
+    # Integration with the multiple-dispatch system (multimethods).
+    from .dispatch import isgeneric, list_methods  # circular import
+    if isgeneric(f):
+        min_lower = _infty
+        max_upper = 0
+        for (thecallable, type_signature) in list_methods(f):
+            lower, upper = arities(thecallable)  # let UnknownArity propagate
+            if lower < min_lower:
+                min_lower = lower
+            if upper > max_upper:
+                max_upper = upper
+        return min_lower, max_upper
+
     try:
         lower = 0
         upper = 0
@@ -258,25 +275,40 @@ def arities(f):
         raise UnknownArity(*e.args)
 
 def required_kwargs(f):
-    """Return a set containing the names of required name-only arguments of f.
+    """Return a set containing the names of required name-only arguments of `f`.
 
-    "Required": has no default.
+    *Required* means the parameter has no default.
 
-    Raises UnknownArity if inspection failed.
+    If `f` is `@generic` (see `unpythonic.dispatch`), we scan its multimethods,
+    and return the names of required kwargs accepted by *any* of its multimethods.
+
+    Raises `UnknownArity` if inspection failed.
     """
     return _kwargs(f, optionals=False)
 
 def optional_kwargs(f):
-    """Return a set containing the names of optional name-only arguments of f.
+    """Return a set containing the names of optional name-only arguments of `f`.
 
-    "Optional": has a default.
+    *Optional* means the parameter has a default.
 
-    Raises UnknownArity if inspection failed.
+    If `f` is `@generic` (see `unpythonic.dispatch`), we scan its multimethods,
+    and return the names of optional kwargs accepted by *any* of its multimethods.
+
+    Raises `UnknownArity` if inspection failed.
     """
     return _kwargs(f, optionals=True)
 
 def _kwargs(f, optionals=True):
     f, _ = getfunc(f)
+
+    # Integration with the multiple-dispatch system (multimethods).
+    from .dispatch import isgeneric, list_methods  # circular import
+    if isgeneric(f):
+        thekwargs = {}
+        for (thecallable, type_signature) in list_methods(f):
+            thekwargs.update(_kwargs(thecallable, optionals=optionals))
+        return thekwargs
+
     try:
         if optionals:
             pred = lambda v: v.default is not Parameter.empty  # optionals