ovld 0.3.8__py3-none-any.whl → 0.3.9__py3-none-any.whl

ovld/core.py

@@ -3,9 +3,15 @@
 import inspect
 import itertools
 import math
+import sys
 import textwrap
 import typing
-from types import FunctionType
+from functools import partial
+from types import CodeType
+
+from .mro import compose_mro
+from .recode import Conformer, rename_function
+from .utils import BOOTSTRAP, MISSING, keyword_decorator
 
 try:
     from types import UnionType
@@ -13,20 +19,13 @@ except ImportError:  # pragma: no cover
     UnionType = None
 
 
-try:
-    from types import GenericAlias
-except ImportError:  # pragma: no cover
+class GenericAliasMC(type):
+    def __instancecheck__(cls, obj):
+        return hasattr(obj, "__origin__")
 
-    class GenericAliasMC(type):
-        def __instancecheck__(cls, obj):
-            return hasattr(obj, "__origin__")
 
-    class GenericAlias(metaclass=GenericAliasMC):
-        pass
-
-
-from .mro import compose_mro
-from .utils import BOOTSTRAP, MISSING, keyword_decorator
+class GenericAlias(metaclass=GenericAliasMC):
+    pass
 
 
 def is_type_of_type(t):
@@ -70,13 +69,23 @@ class TypeMap(dict):
         the next time getitem is called.
         """
         results = {}
+        abscollect = set()
         if is_type_of_type(obj_t):
-            mro = [type[t] for t in compose_mro(obj_t.__args__[0], self.types)]
+            mro = [
+                type[t]
+                for t in compose_mro(obj_t.__args__[0], self.types, abscollect)
+            ]
             mro.append(type)
             mro.append(object)
         else:
-            mro = compose_mro(obj_t, self.types)
-        for lvl, cls in enumerate(reversed(mro)):
+            mro = compose_mro(obj_t, self.types, abscollect)
+
+        lvl = -1
+        prev_is_abstract = False
+        for cls in reversed(mro):
+            if cls not in abscollect or not prev_is_abstract:
+                lvl += 1
+            prev_is_abstract = cls in abscollect
             handlers = self.entries.get(cls, None)
             if handlers:
                 results.update({h: lvl for h in handlers})
@@ -109,12 +118,16 @@ class MultiTypeMap(dict):
 
     def __init__(self, key_error=KeyError):
         self.maps = {}
+        self.priorities = {}
         self.empty = MISSING
         self.key_error = key_error
+        self.transform = type
+        self.all = {}
+        self.errors = {}
 
-    def transform(self, obj):
+    def _transform(self, obj):
         if isinstance(obj, GenericAlias):
-            return type[obj.__origin__]
+            return type[obj]
         elif obj is typing.Any:
             return type[object]
         elif isinstance(obj, type):
@@ -137,30 +150,31 @@ class MultiTypeMap(dict):
         """
         self.clear()
 
-        amin, amax, vararg = nargs
+        if any(isinstance(x, GenericAlias) for x in obj_t_tup):
+            self.transform = self._transform
+
+        amin, amax, vararg, priority = nargs
 
         entry = (handler, amin, amax, vararg)
         if not obj_t_tup:
             self.empty = entry
 
+        self.priorities[handler] = priority
+
         for i, cls in enumerate(obj_t_tup):
-            tm = self.maps.setdefault(i, TypeMap())
-            tm.register(cls, entry)
+            if i not in self.maps:
+                self.maps[i] = TypeMap()
+            self.maps[i].register(cls, entry)
         if vararg:
-            tm = self.maps.setdefault(-1, TypeMap())
-            tm.register(object, entry)
+            if -1 not in self.maps:
+                self.maps[-1] = TypeMap()
+            self.maps[-1].register(object, entry)
 
-    def __missing__(self, obj_t_tup):
+    def resolve(self, obj_t_tup):
         specificities = {}
         candidates = None
         nargs = len(obj_t_tup)
 
-        if not obj_t_tup:
-            if self.empty is MISSING:
-                raise self.key_error(obj_t_tup, ())
-            else:
-                return self.empty[0]
-
         for i, cls in enumerate(obj_t_tup):
             try:
                 results = self.maps[i][cls]
@@ -196,36 +210,85 @@ class MultiTypeMap(dict):
         if not candidates:
             raise self.key_error(obj_t_tup, ())
 
-        candidates = [(c, tuple(specificities[c])) for c in candidates]
+        candidates = [
+            (c, self.priorities.get(c, 0), tuple(specificities[c]))
+            for c in candidates
+        ]
 
         # The sort ensures that if candidate A dominates candidate B, A will
         # appear before B in the list. That's because it must dominate all
         # other possibilities on all arguments, so the sum of all specificities
         # has to be greater.
-        candidates.sort(key=lambda cspc: sum(cspc[1]), reverse=True)
-
-        results = [candidates[0]]
-        for c2, spc2 in candidates[1:]:
-            # Evaluate candidate 2
-            for c1, spc1 in results:
-                if spc1 != spc2 and all(s1 >= s2 for s1, s2 in zip(spc1, spc2)):
-                    # Candidate 1 dominates candidate 2, therefore we can
-                    # reject candidate 2.
+        # Note: priority is always more important than specificity
+        candidates.sort(key=lambda cspc: (cspc[1], sum(cspc[2])), reverse=True)
+
+        self.all[obj_t_tup] = {
+            getattr(c[0], "__code__", None) for c in candidates
+        }
+
+        def _pull(candidates):
+            if not candidates:
+                return
+            rval = [candidates[0]]
+            c1, p1, spc1 = candidates[0]
+            for c2, p2, spc2 in candidates[1:]:
+                if p1 > p2 or (
+                    spc1 != spc2 and all(s1 >= s2 for s1, s2 in zip(spc1, spc2))
+                ):
+                    # Candidate 1 dominates candidate 2
+                    continue
+                else:
+                    # Candidate 1 does not dominate candidate 2, so we add it
+                    # to the list.
+                    rval.append((c2, p2, spc2))
+            yield rval
+            if len(rval) == 1:
+                # Only groups of length 1 are correct and reachable, so we don't
+                # care about the rest.
+                yield from _pull(candidates[1:])
+
+        results = list(_pull(candidates))
+        parent = None
+        for group in results:
+            tup = obj_t_tup if parent is None else (parent, *obj_t_tup)
+            if len(group) != 1:
+                self.errors[tup] = self.key_error(obj_t_tup, group)
+                break
+            else:
+                ((fn, _, _),) = group
+                self[tup] = fn
+                if hasattr(fn, "__code__"):
+                    parent = fn.__code__
+                else:
                     break
+
+        return True
+
+    def __missing__(self, obj_t_tup):
+        if obj_t_tup and isinstance(obj_t_tup[0], CodeType):
+            real_tup = obj_t_tup[1:]
+            self[real_tup]
+            if obj_t_tup[0] not in self.all[real_tup]:
+                return self[real_tup]
+            elif obj_t_tup in self.errors:
+                raise self.errors[obj_t_tup]
+            elif obj_t_tup in self:  # pragma: no cover
+                # PROBABLY not reachable
+                return self[obj_t_tup]
             else:
-                # Candidate 2 cannot be dominated, so we move it to the results
-                # list
-                results.append((c2, spc2))
-
-        if len(results) != 1:
-            # No candidate dominates all the others => key_error
-            # As second argument, we provide the minimal set of candidates
-            # that no other candidate can dominate
-            raise self.key_error(obj_t_tup, [result for result, _ in results])
+                raise self.key_error(real_tup, ())
+
+        if not obj_t_tup:
+            if self.empty is MISSING:
+                raise self.key_error(obj_t_tup, ())
+            else:
+                return self.empty[0]
+
+        self.resolve(obj_t_tup)
+        if obj_t_tup in self.errors:
+            raise self.errors[obj_t_tup]
         else:
-            ((result, _),) = results
-            self[obj_t_tup] = result
-            return result
+            return self[obj_t_tup]
 
 
 def _fresh(t):
@@ -273,8 +336,6 @@ class _Ovld:
     Arguments:
         dispatch: A function to use as the entry point. It must find the
             function to dispatch to and call it.
-        initial_state: A function returning the initial state, or None if
-            there is no state.
         postprocess: A function to call on the return value. It is not called
             after recursive calls.
         mixins: A list of Ovld instances that contribute functions to this
@@ -296,7 +357,6 @@ class _Ovld:
         self,
         *,
         dispatch=None,
-        initial_state=None,
         postprocess=None,
         type_error=TypeError,
         mixins=[],
@@ -314,11 +374,10 @@ class _Ovld:
         self.linkback = linkback
         self.children = []
         self.type_error = type_error
-        self.initial_state = initial_state
         self.postprocess = postprocess
         self.allow_replacement = allow_replacement
         self.bootstrap_class = OvldCall
-        if self.initial_state or self.postprocess:
+        if self.postprocess:
             assert bootstrap is not False
             self.bootstrap = True
         elif isinstance(bootstrap, type):
@@ -381,17 +440,18 @@ class _Ovld:
     def _key_error(self, key, possibilities=None):
         typenames = self._sig_string(key)
         if not possibilities:
-            raise self.type_error(
+            return self.type_error(
                 f"No method in {self} for argument types [{typenames}]"
             )
         else:
             hlp = ""
-            for p in possibilities:
-                hlp += f"* {p.__name__}\n"
-            raise self.type_error(
+            for p, prio, spc in possibilities:
+                hlp += f"* {p.__name__}  (priority: {prio}, specificity: {list(spc)})\n"
+            return self.type_error(
                 f"Ambiguous resolution in {self} for"
                 f" argument types [{typenames}]\n"
-                "Candidates are:\n" + hlp
+                f"Candidates are:\n{hlp}"
+                "Note: you can use @ovld(priority=X) to give higher priority to an overload."
             )
 
     def rename(self, name):
@@ -492,15 +552,12 @@ class _Ovld:
                 repl = self._maybe_rename(repl)
                 setattr(cls, method, repl)
 
+        target = self.ocls if self.bootstrap else cls
         if self._dispatch:
-            if self.bootstrap:
-                self.ocls.__call__ = self._dispatch
-            else:
-                cls.__call__ = self._dispatch
+            target.__call__ = self._dispatch
 
         # Rename the dispatch
-        if self._dispatch:
-            self._dispatch = rename_function(self._dispatch, f"{name}.dispatch")
+        target.__call__ = rename_function(target.__call__, f"{name}.dispatch")
 
         for key, fn in list(self.defns.items()):
             self.register_signature(key, fn)
@@ -519,17 +576,23 @@ class _Ovld:
 
     def register_signature(self, key, orig_fn):
         """Register a function for the given signature."""
-        sig, min, max, vararg = key
+        sig, min, max, vararg, priority = key
         fn = rename_function(
             orig_fn, f"{self.__name__}[{self._sig_string(sig)}]"
         )
         # We just need to keep the Conformer pointer alive for jurigged
         # to find it, if jurigged is used with ovld
         fn._conformer = Conformer(self, orig_fn, fn)
-        self.map.register(sig, (min, max, vararg), fn)
+        self.map.register(sig, (min, max, vararg, priority), fn)
         return self
 
-    def register(self, fn):
+    def register(self, fn=None, priority=0):
+        """Register a function."""
+        if fn is None:
+            return partial(self._register, priority=priority)
+        return self._register(fn, priority)
+
+    def _register(self, fn, priority):
         """Register a function."""
 
         def _normalize_type(t, force_tuple=False):
@@ -542,7 +605,7 @@ class _Ovld:
                 return _normalize_type(t.__args__)
             elif origin is not None:
                 raise TypeError(
-                    "ovld does not accept generic types except type, Union or Optional"
+                    f"ovld does not accept generic types except type, Union or Optional, not {t}"
                 )
             elif isinstance(t, tuple):
                 return tuple(_normalize_type(t2) for t2 in t)
@@ -580,7 +643,7 @@ class _Ovld:
             _normalize_type(t, force_tuple=True) for t in typelist
         )
         for tl in itertools.product(*typelist_tups):
-            sig = (tuple(tl), req_pos, max_pos, bool(argspec.varargs))
+            sig = (tuple(tl), req_pos, max_pos, bool(argspec.varargs), priority)
             if not self.allow_replacement and sig in self._defns:
                 raise TypeError(f"There is already a method for {tl}")
             self._defns[(*sig,)] = fn
@@ -604,7 +667,6 @@ class _Ovld:
     def copy(
         self,
         dispatch=MISSING,
-        initial_state=None,
         postprocess=None,
         mixins=[],
         linkback=False,
@@ -618,7 +680,6 @@ class _Ovld:
             bootstrap=self.bootstrap,
             dispatch=self._dispatch if dispatch is MISSING else dispatch,
             mixins=[self, *mixins],
-            initial_state=initial_state or self.initial_state,
             postprocess=postprocess or self.postprocess,
             linkback=linkback,
         )
@@ -640,21 +701,12 @@ class _Ovld:
     def get_map(self):
         return self.map
 
-    @_compile_first
-    def instantiate(self, **state):
-        return self.ocls(map=self.map, state=state, bind_to=BOOTSTRAP)
-
     @_compile_first
     def __get__(self, obj, cls):
         if obj is None:
             return self
-        if self.initial_state is None or isinstance(self.initial_state, dict):
-            state = self.initial_state
-        else:
-            state = self.initial_state()
         return self.ocls(
             map=self.map,
-            state=state,
             bind_to=obj,
             super=self.mixins[0] if len(self.mixins) == 1 else None,
         )
@@ -680,14 +732,22 @@ class _Ovld:
         method = self.map[key]
         return method(*args, **kwargs)
 
+    @_compile_first
+    @_setattrs(rename="next")
+    def next(self, *args, **kwargs):
+        """Call the next matching method after the caller, in terms of priority or specificity."""
+        fr = sys._getframe(1)
+        key = (fr.f_code, *map(self.map.transform, args))
+        method = self.map[key]
+        return method(*args, **kwargs)
+
     @__call__.setalt
     @_setattrs(rename="entry")
     def __ovldcall__(self, *args, **kwargs):
         """Call the overloaded function.
 
-        This version of __call__ is used when bootstrap is True. It creates an
-        OvldCall instance to contain the state. This function is only called
-        once at the entry point: recursive calls will will be to
+        This version of __call__ is used when bootstrap is True. This function is
+        only called once at the entry point: recursive calls will will be to
         OvldCall.__call__.
         """
         ovc = self.__get__(BOOTSTRAP, None)
@@ -708,12 +768,10 @@ def is_ovld(x):
 class OvldCall:
     """Context for an Ovld call."""
 
-    def __init__(self, map, state, bind_to, super=None):
+    def __init__(self, map, bind_to, super=None):
         """Initialize an OvldCall."""
         self.map = map
         self._parent = super
-        if state is not None:
-            self.__dict__.update(state)
         self.obj = self if bind_to is BOOTSTRAP else bind_to
 
     def __getitem__(self, t):
@@ -722,6 +780,13 @@ class OvldCall:
             t = (t,)
         return self.map[t].__get__(self.obj)
 
+    def next(self, *args, **kwargs):
+        """Call the next matching method after the caller, in terms of priority or specificity."""
+        fr = sys._getframe(1)
+        key = (fr.f_code, *map(self.map.transform, args))
+        method = self.map[key]
+        return method(self.obj, *args, **kwargs)
+
     def super(self, *args, **kwargs):
         """Use the parent ovld's method for this call."""
         pmap = self._parent.get_map()
@@ -736,10 +801,6 @@ class OvldCall:
         """Call the right method for the given arguments."""
         return self[tuple(map(self.map.transform, args))](*args)
 
-    def with_state(self, **state):
-        """Return a new OvldCall using the given state."""
-        return type(self)(self.map, state, BOOTSTRAP)
-
     def __call__(self, *args, **kwargs):
         """Call this overloaded function.
 
@@ -856,7 +917,7 @@ def _find_overload(fn, **kwargs):
 
 
 @keyword_decorator
-def ovld(fn, **kwargs):
+def ovld(fn, priority=0, **kwargs):
     """Overload a function.
 
     Overloading is based on the function name.
@@ -872,8 +933,6 @@ def ovld(fn, **kwargs):
         fn: The function to register.
         dispatch: A function to use as the entry point. It must find the
             function to dispatch to and call it.
-        initial_state: A function returning the initial state, or None if
-            there is no state.
         postprocess: A function to call on the return value. It is not called
             after recursive calls.
         mixins: A list of Ovld instances that contribute functions to this
@@ -889,7 +948,7 @@ def ovld(fn, **kwargs):
             ovld so that updates can be propagated. (default: False)
     """
     dispatch = _find_overload(fn, **kwargs)
-    return dispatch.register(fn)
+    return dispatch.register(fn, priority=priority)
 
 
 @keyword_decorator
@@ -907,8 +966,6 @@ def ovld_dispatch(dispatch, **kwargs):
     Arguments:
         dispatch: The function to use as the entry point. It must find the
             function to dispatch to and call it.
-        initial_state: A function returning the initial state, or None if
-            there is no state.
         postprocess: A function to call on the return value. It is not called
             after recursive calls.
         mixins: A list of Ovld instances that contribute functions to this
@@ -930,82 +987,6 @@ def ovld_dispatch(dispatch, **kwargs):
 ovld.dispatch = ovld_dispatch
 
 
-class Conformer:
-    __slots__ = ("code", "orig_fn", "renamed_fn", "ovld", "code2")
-
-    def __init__(self, ovld, orig_fn, renamed_fn):
-        self.ovld = ovld
-        self.orig_fn = orig_fn
-        self.renamed_fn = renamed_fn
-        self.code = orig_fn.__code__
-
-    def __conform__(self, new):
-        if isinstance(new, FunctionType):
-            new_fn = new
-            new_code = new.__code__
-        else:
-            new_fn = None
-            new_code = new
-
-        if new_code is None:
-            self.ovld.unregister(self.orig_fn)
-
-        elif new_fn is None:  # pragma: no cover
-            # Not entirely sure if this ever happens
-            self.renamed_fn.__code__ = new_code
-
-        elif inspect.signature(self.orig_fn) != inspect.signature(new_fn):
-            self.ovld.unregister(self.orig_fn)
-            self.ovld.register(new_fn)
-
-        else:
-            self.renamed_fn.__code__ = rename_code(
-                new_code, self.renamed_fn.__code__.co_name
-            )
-
-        from codefind import code_registry
-
-        code_registry.update_cache_entry(self, self.code, new_code)
-
-        self.code = new_code
-
-
-def rename_code(co, newname):  # pragma: no cover
-    if hasattr(co, "replace"):
-        if hasattr(co, "co_qualname"):
-            return co.replace(co_name=newname, co_qualname=newname)
-        else:
-            return co.replace(co_name=newname)
-    else:
-        return type(co)(
-            co.co_argcount,
-            co.co_kwonlyargcount,
-            co.co_nlocals,
-            co.co_stacksize,
-            co.co_flags,
-            co.co_code,
-            co.co_consts,
-            co.co_names,
-            co.co_varnames,
-            co.co_filename,
-            newname,
-            co.co_firstlineno,
-            co.co_lnotab,
-            co.co_freevars,
-            co.co_cellvars,
-        )
-
-
-def rename_function(fn, newname):
-    """Create a copy of the function with a different name."""
-    newcode = rename_code(fn.__code__, newname)
-    new_fn = FunctionType(
-        newcode, fn.__globals__, newname, fn.__defaults__, fn.__closure__
-    )
-    new_fn.__annotations__ = fn.__annotations__
-    return new_fn
-
-
 __all__ = [
     "MultiTypeMap",
     "Ovld",

ovld/mro.py

@@ -6,6 +6,41 @@
 # assume they have already been properly tested.
 
 
+def _issubclass(c1, c2):
+    c1 = getattr(c1, "__proxy_for__", c1)
+    c2 = getattr(c2, "__proxy_for__", c2)
+    if hasattr(c1, "__origin__") or hasattr(c2, "__origin__"):
+        o1 = getattr(c1, "__origin__", c1)
+        o2 = getattr(c2, "__origin__", c2)
+        if issubclass(o1, o2):
+            if o2 is c2:  # pragma: no cover
+                return True
+            else:
+                args1 = getattr(c1, "__args__", ())
+                args2 = getattr(c2, "__args__", ())
+                if len(args1) != len(args2):
+                    return False
+                return all(_issubclass(a1, a2) for a1, a2 in zip(args1, args2))
+        else:
+            return False
+    else:
+        return issubclass(c1, c2)
+
+
+def _mro(cls):
+    if hasattr(cls, "__mro__"):
+        return set(cls.__mro__)
+    elif hasattr(cls, "__origin__"):
+        return set(cls.__origin__.__mro__)
+    else:  # pragma: no cover
+        return {cls}
+
+
+def _subclasses(cls):
+    scf = getattr(cls, "__subclasses__", ())
+    return scf and scf()
+
+
 def _c3_merge(sequences):  # pragma: no cover
     """Merges MROs in *sequences* to a single MRO using the C3 algorithm.
     Adapted from http://www.python.org/download/releases/2.3/mro/.
@@ -32,7 +67,7 @@ def _c3_merge(sequences):  # pragma: no cover
                 del seq[0]
 
 
-def _c3_mro(cls, abcs=None):  # pragma: no cover
+def _c3_mro(cls, abcs=None, abscollect=None):  # pragma: no cover
     """Computes the method resolution order using extended C3 linearization.
     If no *abcs* are given, the algorithm works exactly like the built-in C3
     linearization used for method resolution.
@@ -46,28 +81,40 @@ def _c3_mro(cls, abcs=None):  # pragma: no cover
     MRO of said class. If two implicit ABCs end up next to each other in the
     resulting MRO, their ordering depends on the order of types in *abcs*.
     """
-    for i, base in enumerate(reversed(cls.__bases__)):
+    bases = getattr(cls, "__bases__", ())
+    if hasattr(cls, "__origin__"):
+        bases = [cls.__origin__, *bases]
+    for i, base in enumerate(reversed(bases)):
         if hasattr(base, "__abstractmethods__"):
-            boundary = len(cls.__bases__) - i
+            boundary = len(bases) - i
             break  # Bases up to the last explicit ABC are considered first.
     else:
         boundary = 0
     abcs = list(abcs) if abcs else []
-    explicit_bases = list(cls.__bases__[:boundary])
+    explicit_bases = list(bases[:boundary])
     abstract_bases = []
-    other_bases = list(cls.__bases__[boundary:])
+    other_bases = list(bases[boundary:])
     for base in abcs:
-        if issubclass(cls, base) and not any(
-            issubclass(b, base) for b in cls.__bases__
+        if _issubclass(cls, base) and not any(
+            _issubclass(b, base) for b in bases
         ):
             # If *cls* is the class that introduces behaviour described by
             # an ABC *base*, insert said ABC to its MRO.
             abstract_bases.append(base)
     for base in abstract_bases:
         abcs.remove(base)
-    explicit_c3_mros = [_c3_mro(base, abcs=abcs) for base in explicit_bases]
-    abstract_c3_mros = [_c3_mro(base, abcs=abcs) for base in abstract_bases]
-    other_c3_mros = [_c3_mro(base, abcs=abcs) for base in other_bases]
+    abscollect.update(abstract_bases)
+    explicit_c3_mros = [
+        _c3_mro(base, abcs=abcs, abscollect=abscollect)
+        for base in explicit_bases
+    ]
+    abstract_c3_mros = [
+        _c3_mro(base, abcs=abcs, abscollect=abscollect)
+        for base in abstract_bases
+    ]
+    other_c3_mros = [
+        _c3_mro(base, abcs=abcs, abscollect=abscollect) for base in other_bases
+    ]
     return _c3_merge(
         [[cls]]
         + explicit_c3_mros
@@ -79,20 +126,16 @@ def _c3_mro(cls, abcs=None):  # pragma: no cover
     )
 
 
-def compose_mro(cls, types):  # pragma: no cover
+def compose_mro(cls, types, abscollect):  # pragma: no cover
     """Calculates the method resolution order for a given class *cls*.
     Includes relevant abstract base classes (with their respective bases) from
     the *types* iterable. Uses a modified C3 linearization algorithm.
     """
-    bases = set(cls.__mro__)
+    bases = _mro(cls)
 
     # Remove entries which are already present in the __mro__ or unrelated.
     def is_related(typ):
-        return (
-            typ not in bases
-            and hasattr(typ, "__mro__")
-            and issubclass(cls, typ)
-        )
+        return typ not in bases and _issubclass(cls, typ)
 
     types = [n for n in types if is_related(n)]
 
@@ -100,7 +143,7 @@ def compose_mro(cls, types):  # pragma: no cover
     # in the MRO anyway.
     def is_strict_base(typ):
         for other in types:
-            if typ != other and typ in other.__mro__:
+            if typ != other and typ in _mro(other):
                 return True
         return False
 
@@ -110,9 +153,11 @@ def compose_mro(cls, types):  # pragma: no cover
     type_set = set(types)
     mro = []
     for typ in types:
+        if typ is object:
+            continue
         found = []
-        for sub in typ.__subclasses__():
-            if sub not in bases and issubclass(cls, sub):
+        for sub in _subclasses(typ):
+            if sub not in bases and _issubclass(cls, sub):
                 found.append([s for s in sub.__mro__ if s in type_set])
         if not found:
             mro.append(typ)
@@ -123,4 +168,4 @@ def compose_mro(cls, types):  # pragma: no cover
             for subcls in sub:
                 if subcls not in mro:
                     mro.append(subcls)
-    return _c3_mro(cls, abcs=mro)
+    return _c3_mro(cls, abcs=mro, abscollect=abscollect)

ovld/recode.py

@@ -0,0 +1,80 @@
+import inspect
+from types import FunctionType
+
+recurse = object()
+
+
+class Conformer:
+    __slots__ = ("code", "orig_fn", "renamed_fn", "ovld", "code2")
+
+    def __init__(self, ovld, orig_fn, renamed_fn):
+        self.ovld = ovld
+        self.orig_fn = orig_fn
+        self.renamed_fn = renamed_fn
+        self.code = orig_fn.__code__
+
+    def __conform__(self, new):
+        if isinstance(new, FunctionType):
+            new_fn = new
+            new_code = new.__code__
+        else:
+            new_fn = None
+            new_code = new
+
+        if new_code is None:
+            self.ovld.unregister(self.orig_fn)
+
+        elif new_fn is None:  # pragma: no cover
+            # Not entirely sure if this ever happens
+            self.renamed_fn.__code__ = new_code
+
+        elif inspect.signature(self.orig_fn) != inspect.signature(new_fn):
+            self.ovld.unregister(self.orig_fn)
+            self.ovld.register(new_fn)
+
+        else:
+            self.renamed_fn.__code__ = rename_code(
+                new_code, self.renamed_fn.__code__.co_name
+            )
+
+        from codefind import code_registry
+
+        code_registry.update_cache_entry(self, self.code, new_code)
+
+        self.code = new_code
+
+
+def rename_code(co, newname):  # pragma: no cover
+    if hasattr(co, "replace"):
+        if hasattr(co, "co_qualname"):
+            return co.replace(co_name=newname, co_qualname=newname)
+        else:
+            return co.replace(co_name=newname)
+    else:
+        return type(co)(
+            co.co_argcount,
+            co.co_kwonlyargcount,
+            co.co_nlocals,
+            co.co_stacksize,
+            co.co_flags,
+            co.co_code,
+            co.co_consts,
+            co.co_names,
+            co.co_varnames,
+            co.co_filename,
+            newname,
+            co.co_firstlineno,
+            co.co_lnotab,
+            co.co_freevars,
+            co.co_cellvars,
+        )
+
+
+def rename_function(fn, newname):
+    """Create a copy of the function with a different name."""
+    newcode = rename_code(fn.__code__, newname)
+    new_fn = FunctionType(
+        newcode, fn.__globals__, newname, fn.__defaults__, fn.__closure__
+    )
+    new_fn.__annotations__ = fn.__annotations__
+    return new_fn

ovld/version.py

@@ -1 +1 @@
-version = "0.3.8"
+version = "0.3.9"

{ovld-0.3.8.dist-info → ovld-0.3.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ovld
-Version: 0.3.8
+Version: 0.3.9
 Summary: Overloading Python functions
 Author-email: Olivier Breuleux <breuleux@gmail.com>
 License-Expression: MIT
@@ -19,7 +19,7 @@ Other features of `ovld`:
 
 * Multiple dispatch for methods (with `metaclass=ovld.OvldMC`)
 * Create variants of functions
-* Built-in support for extensible, stateful recursion
+* Built-in support for extensible recursion
 * Function wrappers
 * Function postprocessors
 * Nice stack traces
@@ -84,22 +84,6 @@ assert mul([1, 2], [3, 4]) == [3, 8]
 
 A `variant` of a function is a copy which inherits all of the original's implementations but may define new ones. And because `self` is bound to the function that's called at the top level, the implementations for `list`, `tuple` and `dict` will bind `self` to `add` or `mul` depending on which one was called. You may also call `self.super(*args)` to invoke the parent implementation for that type.
 
-## State
-
-You can pass `initial_state` to `@ovld` or `variant`. The initial state must be a function that takes no arguments. Its return value will be available in `self.state`. The state is initialized at the top level call, but recursive calls to `self` will preserve it.
-
-In other words, you can do something like this:
-
-```python
-@add.variant(initial_state=lambda: 0)
-def count(self, x, y):
-    self.state += 1
-    return (f"#{self.state}", x + y)
-
-assert count([1, 2, 3], [4, 5, 6]) == [("#1", 5), ("#2", 7), ("#3", 9)]
-```
-
-The initial_state function can return any object and you can use the state to any purpose (e.g. cache or memoization).
 
 ## Custom dispatch
 
@@ -134,7 +118,7 @@ assert add_default([1, 2, "alouette"]) == [2, 4, "alouettealouette"]
 
 There are other uses for this feature, e.g. memoization.
 
-The normal functions may also have a `self`, which works the same as bootstrapping, and you can give an `initial_state` to `@ovld.dispatch` as well.
+The normal functions may also have a `self`, which works the same as bootstrapping.
 
 ## Postprocess
 

ovld-0.3.9.dist-info/RECORD

@@ -0,0 +1,10 @@
+ovld/__init__.py,sha256=jqq7r0RhfvkqmQa8Wc7wqX3Qh5NbwL_6Nfr1sp88Kh0,734
+ovld/core.py,sha256=3JmnfLF6puVtWkc01Hnxuss4gVdWzX9mrLVMfysQqJY,32895
+ovld/mro.py,sha256=W6T5IPec6YQIvv8oSwg-xGHTzZP1zOuTZuaRCegbl-I,6296
+ovld/recode.py,sha256=45VmTUmk2GmWRfTLANMHhyzVcgBit2RvwULzyWpOMhI,2234
+ovld/utils.py,sha256=8kINtHrWdC0bNVccxYIkHBaGFk_YFpjtnjAa9GyXNmA,3861
+ovld/version.py,sha256=8WhSz7JLKtk-44zKbF-sqJmexEzvpM-d0cPHqr6cE5k,18
+ovld-0.3.9.dist-info/METADATA,sha256=wbN2H6NflCIkt-OZJvzrVXWNIz8bH0FTow83Ir0C8NM,8282
+ovld-0.3.9.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+ovld-0.3.9.dist-info/licenses/LICENSE,sha256=cSwNTIzd1cbI89xt3PeZZYJP2y3j8Zus4bXgo4svpX8,1066
+ovld-0.3.9.dist-info/RECORD,,

ovld-0.3.8.dist-info/RECORD

@@ -1,9 +0,0 @@
-ovld/__init__.py,sha256=jqq7r0RhfvkqmQa8Wc7wqX3Qh5NbwL_6Nfr1sp88Kh0,734
-ovld/core.py,sha256=B5j-k5SRPFd1l_zM6XkIK-jWN9FCtQVhtj4URI4oepQ,33210
-ovld/mro.py,sha256=Dof3wj-BLcV-T-Jm9tK6zqptp_JGo5lxgyRq99AvY1k,5006
-ovld/utils.py,sha256=8kINtHrWdC0bNVccxYIkHBaGFk_YFpjtnjAa9GyXNmA,3861
-ovld/version.py,sha256=C1bt0pFrmukDC9wIVB6iyGiXY-vasUa0lCdJBB8wwjk,18
-ovld-0.3.8.dist-info/METADATA,sha256=zdZJPKFRdMBgfHuUDzquDhsVDQyadJT3PuXhMokjIHk,9006
-ovld-0.3.8.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-ovld-0.3.8.dist-info/licenses/LICENSE,sha256=cSwNTIzd1cbI89xt3PeZZYJP2y3j8Zus4bXgo4svpX8,1066
-ovld-0.3.8.dist-info/RECORD,,