enh: namelambda: be more FP, return a modified copy instead of mutating the original function object

Author: Technologicat

README.md

@@ -2426,6 +2426,8 @@ assert tuple(myzip(lol)) == ((1, 3, 5), (2, 4, 6))
 
 *Changed in v0.13.0.* Now supports renaming any function object (``isinstance(f, (types.LambdaType, types.FunctionType))``), and will rename a lambda even if it has already been named.
 
+*Changed in v0.13.1.* Now the return value is a modified copy; the original function object is not mutated.
+
 For those situations where you return a lambda as a closure, call it much later, and it happens to crash - so you can tell from the stack trace *which* of the *N* lambdas in the codebase it is.
 
 For technical reasons, ``namelambda`` conforms to the parametric decorator API. Usage:
@@ -2440,7 +2442,7 @@ kaboom = namelambda("kaboom")(lambda: some_typoed_name)
 kaboom()  # --> stack trace, showing the function name "kaboom"
 ```
 
-The first call returns a *foo-renamer*, which takes a function object and renames it to have the name *foo*.
+The first call returns a *foo-renamer*, which takes a function object and returns a copy that has its name changed to *foo*.
 
 Technically, this updates ``__name__`` (the obvious place), ``__qualname__`` (used by ``repr()``), and ``__code__.co_name`` (used by stack traces).
 

macro_extras/README.md

@@ -524,8 +524,6 @@ In the second example, returning ``x`` separately is redundant, because the assi
 
 ### ``namedlambda``: auto-name your lambdas
 
-*Changed in v0.13.0.* Env-assignments are now processed lexically, just like regular assignments. Added support for let-bindings.
-
 Who said lambdas have to be anonymous?
 
 ```python
@@ -544,11 +542,11 @@ with namedlambda:
     foo = let[(f7, lambda x: x) in f7]       # let-binding: name as "f7"
 ```
 
-Lexically inside a ``with namedlambda`` block, any literal ``lambda`` that is assigned to a name using one of the supported assignment forms is named to have the name of the LHS of the assignment. The name is captured at macro expansion time. Naming modifies the original function object.
+Lexically inside a ``with namedlambda`` block, any literal ``lambda`` that is assigned to a name using one of the supported assignment forms is named to have the name of the LHS of the assignment. The name is captured at macro expansion time.
 
 Decorated lambdas are also supported, as is a ``curry`` (manual or auto) where the last argument is a lambda. The latter is a convenience feature, mainly for applying parametric decorators to lambdas. See [the unit tests](../unpythonic/syntax/test/test_lambdatools.py) for detailed examples.
 
-The naming is performed using the function ``unpythonic.misc.namelambda``, which will update ``__name__``, ``__qualname__`` and ``__code__.co_name``.
+The naming is performed using the function ``unpythonic.misc.namelambda``, which will return a renamed copy with its ``__name__``, ``__qualname__`` and ``__code__.co_name`` changed.
 
 Supported assignment forms:
 
@@ -560,6 +558,10 @@ Supported assignment forms:
 
 Support for other forms of assignment might or might not be added in a future version.
 
+*Changed in v0.13.0.* Env-assignments are now processed lexically, just like regular assignments. Added support for let-bindings.
+
+*Changed in v0.13.1.* Now the return value of ``namelambda``, which this uses internally, is a modified copy; the original function object is not mutated.
+
 
 ### ``quicklambda``: combo with ``macropy.quick_lambda``
 

unpythonic/misc.py

@@ -5,6 +5,7 @@
 
 from types import LambdaType, FunctionType, CodeType
 from time import time
+from copy import copy
 
 from .regutil import register_decorator
 from .lazyutil import mark_lazy, lazycall, force
@@ -246,9 +247,6 @@ def p(loop, item, acc):
 def namelambda(name):
     """Rename a function. Decorator.
 
-    The original function object is modified in-place; for convenience,
-    the object is returned.
-
     This can be used to give a lambda a meaningful name, which is especially
     useful for debugging in cases where a lambda is returned as a closure,
     and the actual call into it occurs much later (so that if the call crashes,
@@ -260,7 +258,7 @@ def namelambda(name):
         foo = namelambda("foo")(lambda ...: ...)
 
     The first call returns a *foo-renamer*, and supplying the lambda to that
-    actually modifies the lambda to have the name *foo*.
+    actually returns a lambda that has the name *foo*.
 
     This is used internally by some macros (``namedlambda``, ``let``, ``do``),
     but also provided as part of unpythonic's public API in case it's useful
@@ -283,6 +281,7 @@ def namelambda(name):
     def rename(f):
         if not isinstance(f, (LambdaType, FunctionType)):
             return f
+        f = copy(f)
         # __name__ for tools like pydoc; __qualname__ for repr(); __code__.co_name for stack traces
         #     https://stackoverflow.com/questions/40661758/name-of-a-python-function-in-a-stack-trace
         #     https://stackoverflow.com/questions/16064409/how-to-create-a-code-object-in-python