Make _coconut_partial a proper class with __get__ for method binding

Replace the old function-based _coconut_partial (which just wrapped
functools.partial and set __name__) with a class-based implementation
that subclasses functools.partial. The new class adds:

- __get__ descriptor support so partials work correctly as methods
  when assigned as class attributes (resolves #891)
- __repr__ that delegates to functools.partial's repr for consistency
- Proper __name__ propagation via __new__

The class is defined in root.py (for both Python 2 and 3 headers) and
is now also used internally by the compiler modules (compiler.py,
grammar.py, header.py, util.py) instead of functools.partial.

Also updates remaining uses of _coconut.functools.partial in the
runtime header template to use _coconut_partial, and adds tests for
partial-as-method with both positional and keyword argument binding.

Co-Authored-By: Claude (fennec-v8-fast) <noreply@anthropic.com>

Author: evhub

coconut/compiler/compiler.py

@@ -34,7 +34,7 @@
 import os
 import re
 from contextlib import contextmanager
-from functools import partial, update_wrapper
+from functools import update_wrapper
 from collections import defaultdict
 from threading import Lock
 from copy import copy
@@ -54,6 +54,7 @@
     __version__ as pyparsing_version,
 )
 
+from coconut.root import _coconut_partial as partial
 from coconut.constants import (
     PY35,
     specific_targets,

coconut/compiler/grammar.py

@@ -29,8 +29,7 @@
 
 from collections import defaultdict
 from contextlib import contextmanager
-from functools import partial
-
+from coconut.root import _coconut_partial as partial
 from coconut._pyparsing import (
     USE_LINE_BY_LINE,
     Forward,

coconut/compiler/header.py

@@ -20,9 +20,12 @@
 from coconut.root import *  # NOQA
 
 import os.path
-from functools import partial
 
-from coconut.root import _indent, _get_root_header
+from coconut.root import (
+    _coconut_partial as partial,
+    _indent,
+    _get_root_header,
+)
 from coconut.exceptions import CoconutInternalException
 from coconut.terminal import internal_assert
 from coconut.constants import (

coconut/compiler/templates/header.py_template

@@ -66,11 +66,6 @@ class _coconut{object}:{COMMENT.EVERYTHING_HERE_MUST_BE_COPIED_TO_STUB_FILE}
     fmappables = list, tuple, dict, set, frozenset, bytes, bytearray
     abc.Sequence.register(collections.deque)
     Ellipsis, NotImplemented, NotImplementedError, Exception, AttributeError, ImportError, IndexError, KeyError, NameError, TypeError, ValueError, StopIteration, RuntimeError, all, any, bool, bytes, callable, chr, classmethod, complex, dict, enumerate, filter, float, frozenset, getattr, hasattr, hash, id, int, isinstance, issubclass, iter, len, list, locals, globals, map, min, max, next, object, ord, property, range, reversed, set, setattr, slice, str, sum, super, tuple, type, vars, zip, repr, print{comma_bytearray} = Ellipsis, NotImplemented, NotImplementedError, Exception, AttributeError, ImportError, IndexError, KeyError, NameError, TypeError, ValueError, StopIteration, RuntimeError, all, any, bool, bytes, callable, chr, classmethod, complex, dict, enumerate, filter, float, frozenset, getattr, hasattr, hash, id, int, isinstance, issubclass, iter, len, list, locals, globals, map, {lstatic}min{rstatic}, {lstatic}max{rstatic}, next, object, ord, property, range, reversed, set, setattr, slice, str, sum, {lstatic}super{rstatic}, tuple, type, vars, zip, {lstatic}repr{rstatic}, {lstatic}print{rstatic}{comma_bytearray}
-@_coconut_wraps(_coconut.functools.partial)
-def _coconut_partial(_coconut_func, *args, **kwargs):
-    partial_func = _coconut.functools.partial(_coconut_func, *args, **kwargs)
-    partial_func.__name__ = _coconut.getattr(_coconut_func, "__name__", None)
-    return partial_func
 def _coconut_handle_cls_kwargs(**kwargs):
     """Some code taken from six under the terms of its MIT license."""
     metaclass = kwargs.pop("metaclass", None)
@@ -699,7 +694,7 @@ class flatten(_coconut_has_iter):{COMMENT.cant_implement_len_else_list_calls_bec
             for i in _coconut.reversed(_coconut.range(0 if self.levels is None else self.levels + 1)):
                 mapper = {_coconut_}reiterable
                 for _ in _coconut.range(i):
-                    mapper = _coconut.functools.partial({_coconut_}map, mapper)
+                    mapper = _coconut_partial({_coconut_}map, mapper)
                 self.iter = mapper(self.iter)
             self._made_reit = True
         return self.iter
@@ -725,7 +720,7 @@ class flatten(_coconut_has_iter):{COMMENT.cant_implement_len_else_list_calls_bec
         for i in _coconut.reversed(_coconut.range(self.levels + 1)):
             reverser = {_coconut_}reversed
             for _ in _coconut.range(i):
-                reverser = _coconut.functools.partial({_coconut_}map, reverser)
+                reverser = _coconut_partial({_coconut_}map, reverser)
             reversed_iter = reverser(reversed_iter)
         return self.__class__(reversed_iter, self.levels)
     def __repr__(self):
@@ -2028,7 +2023,7 @@ def mapreduce(key_value_func, iterable, **kwargs):
 def _coconut_parallel_mapreduce(mapreduce_func, map_cls, *args, **kwargs):
     if "map_using" in kwargs:
         raise _coconut.TypeError("redundant map_using argument to process/thread mapreduce/collectby")
-    kwargs["map_using"] = _coconut.functools.partial(map_cls, stream=True, ordered=kwargs.pop("ordered", False), chunksize=kwargs.pop("chunksize", 1))
+    kwargs["map_using"] = _coconut_partial(map_cls, stream=True, ordered=kwargs.pop("ordered", False), chunksize=kwargs.pop("chunksize", 1))
     with map_cls.multiple_sequential_calls(max_workers=kwargs.pop("max_workers", None)):
         return mapreduce_func(*args, **kwargs)
 mapreduce.using_processes = _coconut_partial(_coconut_parallel_mapreduce, mapreduce, process_map)

coconut/compiler/util.py

@@ -36,7 +36,7 @@
 import itertools
 import weakref
 import datetime as dt
-from functools import partial, reduce
+from functools import reduce
 from collections import defaultdict
 from contextlib import contextmanager
 from pprint import pformat, pprint
@@ -75,6 +75,7 @@
     all_parse_elements,
 )
 
+from coconut.root import _coconut_partial as partial
 from coconut.integrations import embed
 from coconut.util import (
     pickle,

coconut/root.py

@@ -26,7 +26,7 @@
 VERSION = "3.2.0"
 VERSION_NAME = None
 # False for release, int >= 1 for develop
-DEVELOP = 7
+DEVELOP = 8
 ALPHA = False  # for pre releases rather than post releases
 
 assert DEVELOP is False or DEVELOP >= 1, "DEVELOP must be False or an int >= 1"
@@ -77,6 +77,25 @@ def wrap(new_func):
 py_bytes, py_chr, py_dict, py_hex, py_input, py_int, py_map, py_object, py_oct, py_open, py_print, py_range, py_str, py_super, py_zip, py_filter, py_reversed, py_enumerate, py_repr, py_min, py_max = bytes, chr, dict, hex, input, int, map, object, oct, open, print, range, str, super, zip, filter, reversed, enumerate, repr, min, max
 _coconut_py_str, _coconut_py_super, _coconut_py_dict, _coconut_py_min, _coconut_py_max = str, super, dict, min, max
 exec("_coconut_exec = exec")
+class _coconut_partial(_coconut_functools.partial):
+    __slots__ = ()
+    def __new__(cls, func, *args, **kwargs):
+        self = _coconut_functools.partial.__new__(cls, func, *args, **kwargs)
+        self.__name__ = _coconut.getattr(func, "__name__", None)
+        return self
+    def __get__(self, obj, objtype=None):
+        if obj is None:
+            return self
+        return _coconut.types.MethodType(self, obj)
+    def __repr__(self):
+        cls = type(self)
+        old_qualname, cls.__qualname__ = cls.__qualname__, _coconut_functools.partial.__qualname__
+        old_module, cls.__module__ = cls.__module__, _coconut_functools.partial.__module__
+        try:
+            return _coconut_functools.partial.__repr__(self)
+        finally:
+            cls.__qualname__ = old_qualname
+            cls.__module__ = old_module
 '''
 
 # if a new assignment is added below, a new builtins import should be added alongside it
@@ -87,6 +106,25 @@ def wrap(new_func):
 from future_builtins import *
 chr, str = unichr, unicode
 from io import open
+class _coconut_partial(_coconut_functools.partial):
+    __slots__ = ()
+    def __new__(cls, func, *args, **kwargs):
+        self = _coconut_functools.partial.__new__(cls, func, *args, **kwargs)
+        self.__name__ = _coconut.getattr(func, "__name__", None)
+        return self
+    def __get__(self, obj, objtype=None):
+        if obj is None:
+            return self
+        return _coconut.types.MethodType(self, obj, objtype)
+    def __repr__(self):
+        cls = type(self)
+        old_name, cls.__name__ = cls.__name__, _coconut_functools.partial.__name__
+        old_module, cls.__module__ = cls.__module__, _coconut_functools.partial.__module__
+        try:
+            return _coconut_functools.partial.__repr__(self)
+        finally:
+            cls.__name__ = old_name
+            cls.__module__ = old_module
 class object(object):
     __slots__ = ()
     def __ne__(self, other):
@@ -487,4 +525,7 @@ def _get_root_header(version="universal"):
 import os as _os
 _coconut.os = _os
 
+import types as _types
+_coconut.types = _types
+
 exec(_get_root_header())

coconut/tests/src/cocotest/agnostic/primary_2.coco

@@ -367,8 +367,11 @@ def primary_test_2() -> bool:
     class HasPartial:
         def f(self, x) = (self, x)
         g = f$(?, 1)
+        def h(self, x, y) = (self, x, y)
+        i = h$(y=42)
     has_partial = HasPartial()
     assert has_partial.g() == (has_partial, 1)
+    assert has_partial.i(10) == (has_partial, 10, 42)
     xs = zip([1, 2], [3, 4])
     py_xs = py_zip([1, 2], [3, 4])
     assert list(xs) == [(1, 3), (2, 4)] == list(xs)