naming: @generic_addmethod more descriptive than @generic_for

Technologicat · Technologicat · commit d191fbea639c · 2021-05-05T13:23:19.000+03:00
Avoid semantically loaded word, it has nothing to do with `for` loops.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -21,7 +21,7 @@ For future plans, see our [Python language version support status](https://githu
 
 - Robustness: several auxiliary syntactic constructs such as `local[]`/`delete[]` (for `do[]`), `call_cc[]` (for `with continuations`), `it` (for `aif[]`), `with expr`/`with block` (for `let_syntax`/`abbrev`), and `q`/`u`/`kw` (for `prefix`) now detect *at macro expansion time* if they appear outside any valid lexical context, and raise `SyntaxError` (with a descriptive message) if so. That is, the error is now raised *at compile time*. Previously these constructs could only raise an error at run time, and not all of them could detect the error even then.
 
-- `unpythonic.dispatch.generic_for`: add methods to a generic function defined elsewhere.
+- `unpythonic.dispatch.generic_addmethod`: add methods to a generic function defined elsewhere.
 
 - Python 3.8 and 3.9 support added.
 
diff --git a/doc/features.md b/doc/features.md
@@ -2986,7 +2986,7 @@ The core idea can be expressed in fewer than 100 lines of Python; ours is (as of
 
 **Changed in v0.14.3**. *The `@generic` and `@typed` decorators can now decorate also instance methods, class methods and static methods (beside regular functions, as previously in 0.14.2).*
 
-**Changed in v0.15.0**. *The `dispatch` and `typecheck` modules providing this functionality are now considered stable (no longer experimental). Added the `@generic_for` parametric decorator that can register a new method on an existing generic function originally defined in another lexical scope.* 
+**Changed in v0.15.0**. *The `dispatch` and `typecheck` modules providing this functionality are now considered stable (no longer experimental). Added the `@generic_addmethod` parametric decorator that can register a new method on an existing generic function originally defined in another lexical scope.* 
 
 The ``generic`` decorator allows creating multiple-dispatch generic functions with type annotation syntax.
 
diff --git a/unpythonic/dispatch.py b/unpythonic/dispatch.py
@@ -6,7 +6,7 @@
     https://docs.python.org/3/library/functools.html#functools.singledispatch
 """
 
-__all__ = ["generic", "generic_for", "typed"]
+__all__ = ["generic", "generic_addmethod", "typed"]
 
 from functools import partial, wraps
 from itertools import chain
@@ -37,7 +37,7 @@
 # """
 
 @register_decorator(priority=98)
-def generic_for(target):
+def generic_addmethod(target):
     """Parametric decorator. Add a method to function `target`.
 
     Like `@generic`, but the target function on which the method will be
@@ -55,10 +55,10 @@ def f(x: int):
 
 
         # main.py
-        from unpythonic import generic_for
+        from unpythonic import generic_addmethod
         import example
 
-        @generic_for(example.f)
+        @generic_addmethod(example.f)
         def f(x: float):
             ...
     """
@@ -212,7 +212,7 @@ def _getfullname(f):
 def _register_generic(fullname, f):
     """Register a method for a generic function.
 
-    This is a low-level function; you'll likely want `generic` or `generic_for`.
+    This is a low-level function; you'll likely want `generic` or `generic_addmethod`.
 
     fullname: str, fully qualified name of target function to register
               the method on, used as key in the dispatcher registry.
diff --git a/unpythonic/tests/test_dispatch.py b/unpythonic/tests/test_dispatch.py
@@ -5,7 +5,7 @@
 
 import typing
 from ..fun import curry
-from ..dispatch import generic, generic_for, typed
+from ..dispatch import generic, generic_addmethod, typed
 
 @generic
 def zorblify(x: int, y: int):
@@ -91,20 +91,20 @@ def runtests():
         test[gargle(42, 6.022e23, "hello") == "int, float, str"]
         test[gargle(1, 2, 3) == "int"]  # as many as in the [int, float, str] case
 
-    with testset("@generic_for"):
+    with testset("@generic_addmethod"):
         @generic
         def f1(x: typing.Any):
             return False
-        @generic_for(f1)
+        @generic_addmethod(f1)
         def f2(x: int):
             return x
         test[f1("hello") is False]
         test[f1(42) == 42]
 
         def f3(x: typing.Any):  # not @generic!
             return False
-        with test_raises[TypeError, "should not be able to @generic_for a non-generic function"]:
-            @generic_for(f3)
+        with test_raises[TypeError, "should not be able to @generic_addmethod a non-generic function"]:
+            @generic_addmethod(f3)
             def f4(x: int):
                 return x
 
@@ -269,12 +269,12 @@ def flippable(x: typing.Any):  # default
         # Since these are in the same lexical scope as the original definition of the
         # generic function `flippable`, we could do this using `@generic`, but
         # later extensions (which are the whole point of traits) will need to specify
-        # on which function the new methods are to be registered, using `@generic_for`.
+        # on which function the new methods are to be registered, using `@generic_addmethod`.
         # So let's do that to show how it's done.
-        @generic_for(flippable)
+        @generic_addmethod(flippable)
         def flippable(x: str):  # noqa: F811
             return IsFlippable()
-        @generic_for(flippable)
+        @generic_addmethod(flippable)
         def flippable(x: int):  # noqa: F811
             return IsNotFlippable()
 
@@ -289,7 +289,7 @@ def flippable(x: int):  # noqa: F811
         def flip(x: typing.Any):
             return flip(flippable(x), x)
 
-        # Implementation of `flip`. Same comment about `@generic_for` as above.
+        # Implementation of `flip`. Same comment about `@generic_addmethod` as above.
         #
         # Here we provide one implementation for "flippable" objects and another one
         # for "nonflippable" objects. Note this dispatches regardless of the actual
@@ -299,10 +299,10 @@ def flip(x: typing.Any):
         # We could also add methods for specific types if needed. Note this is not
         # Julia, so the first matching definition wins, instead of the most specific
         # one.
-        @generic_for(flip)
+        @generic_addmethod(flip)
         def flip(traitvalue: IsFlippable, x: typing.Any):  # noqa: F811
             return x[::-1]
-        @generic_for(flip)
+        @generic_addmethod(flip)
         def flip(traitvalue: IsNotFlippable, x: typing.Any):  # noqa: F811
             raise TypeError(f"{repr(x)} is IsNotFlippable")
 
