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

ovld/core.py

@@ -2,10 +2,23 @@
 
 import inspect
 import itertools
-import math
+import sys
 import textwrap
 import typing
-from types import FunctionType
+from collections import defaultdict
+from dataclasses import dataclass, field, replace
+from functools import cached_property, partial
+from types import GenericAlias
+
+from .recode import (
+    Conformer,
+    adapt_function,
+    generate_dispatch,
+    rename_function,
+)
+from .typemap import MultiTypeMap, is_type_of_type
+from .types import normalize_type
+from .utils import UsageError, keyword_decorator
 
 try:
     from types import UnionType
@@ -13,254 +26,265 @@ 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 GenericAlias(metaclass=GenericAliasMC):
-        pass
-
-
-from .mro import compose_mro
-from .utils import BOOTSTRAP, MISSING, keyword_decorator
-
+_current_id = itertools.count()
 
-def is_type_of_type(t):
-    return getattr(t, "__origin__", None) is type
 
+def _fresh(t):
+    """Returns a new subclass of type t.
 
-class TypeMap(dict):
-    """Represents a mapping from types to handlers.
-
-    The mro of a type is considered when getting the handler, so setting the
-    [object] key creates a default for all objects.
-
-    typemap[some_type] returns a tuple of a handler and a "level" that
-    represents the distance from the handler to the type `object`. Essentially,
-    the level is the index of the type for which the handler was registered
-    in the mro of `some_type`. So for example, `object` has level 0, a class
-    that inherits directly from `object` has level 1, and so on.
+    Each Ovld corresponds to its own class, which allows for specialization of
+    methods.
     """
+    methods = {}
+    if not isinstance(getattr(t, "__doc__", None), str):
+        methods["__doc__"] = t.__doc__
+    return type(t.__name__, (t,), methods)
 
-    def __init__(self):
-        self.entries = {}
-        self.types = set()
 
-    def register(self, obj_t, handler):
-        """Register a handler for the given object type."""
-        if isinstance(obj_t, str):
-            obj_t = eval(obj_t, getattr(handler[0], "__globals__", {}))
+@keyword_decorator
+def _setattrs(fn, **kwargs):
+    for k, v in kwargs.items():
+        setattr(fn, k, v)
+    return fn
 
-        self.clear()
-        if is_type_of_type(obj_t):
-            self.types.add(obj_t.__args__[0])
-        else:
-            self.types.add(obj_t)
-        s = self.entries.setdefault(obj_t, set())
-        s.add(handler)
 
-    def __missing__(self, obj_t):
-        """Get the handler for the given type.
+@keyword_decorator
+def _compile_first(fn, rename=None):
+    def first_entry(self, *args, **kwargs):
+        self.compile()
+        method = getattr(self, fn.__name__)
+        assert method is not first_entry
+        return method(*args, **kwargs)
 
-        The result is cached so that the normal dict getitem will find it
-        the next time getitem is called.
-        """
-        results = {}
-        if is_type_of_type(obj_t):
-            mro = [type[t] for t in compose_mro(obj_t.__args__[0], self.types)]
-            mro.append(type)
-            mro.append(object)
-        else:
-            mro = compose_mro(obj_t, self.types)
-        for lvl, cls in enumerate(reversed(mro)):
-            handlers = self.entries.get(cls, None)
-            if handlers:
-                results.update({h: lvl for h in handlers})
-
-        if results:
-            self[obj_t] = results
-            return results
-        else:
-            raise KeyError(obj_t)
+    first_entry._replace_by = fn
+    first_entry._rename = rename
+    return first_entry
 
 
-class MultiTypeMap(dict):
-    """Represents a mapping from tuples of types to handlers.
+def arg0_is_self(fn):
+    sgn = inspect.signature(fn)
+    params = list(sgn.parameters.values())
+    return params and params[0].name == "self"
 
-    The mro is taken into account to find a match. If multiple registered
-    handlers match the tuple of types that's given, if one of the handlers is
-    more specific than every other handler, that handler is returned.
-    Otherwise, the resolution is considered ambiguous and an error is raised.
 
-    Handler A, registered for types (A1, A2, ..., An), is more specific than
-    handler B, registered for types (B1, B2, ..., Bn), if there exists n such
-    that An is more specific than Bn, and for all n, either An == Bn or An is
-    more specific than Bn. An is more specific than Bn if An is a direct or
-    indirect subclass of Bn.
+@dataclass(frozen=True)
+class Arginfo:
+    position: typing.Optional[int]
+    name: typing.Optional[str]
+    required: bool
+    ann: type
 
-    In other words, [int, object] is more specific than [object, object] and
-    less specific than [int, int], but it is neither less specific nor more
-    specific than [object, int] (which means there is an ambiguity).
-    """
+    @cached_property
+    def is_complex(self):
+        return isinstance(self.ann, GenericAlias)
 
-    def __init__(self, key_error=KeyError):
-        self.maps = {}
-        self.empty = MISSING
-        self.key_error = key_error
-
-    def transform(self, obj):
-        if isinstance(obj, GenericAlias):
-            return type[obj.__origin__]
-        elif obj is typing.Any:
-            return type[object]
-        elif isinstance(obj, type):
-            return type[obj]
-        else:
-            return type(obj)
-
-    def register(self, obj_t_tup, nargs, handler):
-        """Register a handler for a tuple of argument types.
-
-        Arguments:
-            obj_t_tup: A tuple of argument types.
-            nargs: A (amin, amax, varargs) tuple where amin is the minimum
-                number of arguments needed to match this tuple (if there are
-                default arguments, it is possible that amin < len(obj_t_tup)),
-                amax is the maximum number of arguments, and varargs is a
-                boolean indicating whether there can be an arbitrary number
-                of arguments.
-            handler: A function to handle the tuple.
-        """
-        self.clear()
+    @cached_property
+    def canonical(self):
+        return self.name if self.position is None else self.position
 
-        amin, amax, vararg = nargs
 
-        entry = (handler, amin, amax, vararg)
-        if not obj_t_tup:
-            self.empty = entry
+@dataclass(frozen=True)
+class Signature:
+    types: tuple
+    req_pos: int
+    max_pos: int
+    req_names: frozenset
+    vararg: bool
+    priority: float
+    is_method: bool = False
+    arginfo: list[Arginfo] = field(
+        default_factory=list, hash=False, compare=False
+    )
 
-        for i, cls in enumerate(obj_t_tup):
-            tm = self.maps.setdefault(i, TypeMap())
-            tm.register(cls, entry)
-        if vararg:
-            tm = self.maps.setdefault(-1, TypeMap())
-            tm.register(object, entry)
+    @classmethod
+    def extract(cls, fn):
+        typelist = []
+        sig = inspect.signature(fn)
+        max_pos = 0
+        req_pos = 0
+        req_names = set()
+        is_method = False
+
+        arginfo = []
+        for i, (name, param) in enumerate(sig.parameters.items()):
+            if name == "self":
+                assert i == 0
+                is_method = True
+                continue
+            pos = nm = None
+            ann = normalize_type(param.annotation, fn)
+            if param.kind is inspect._POSITIONAL_ONLY:
+                pos = i - is_method
+                typelist.append(ann)
+                req_pos += param.default is inspect._empty
+                max_pos += 1
+            elif param.kind is inspect._POSITIONAL_OR_KEYWORD:
+                pos = i - is_method
+                nm = param.name
+                typelist.append(ann)
+                req_pos += param.default is inspect._empty
+                max_pos += 1
+            elif param.kind is inspect._KEYWORD_ONLY:
+                nm = param.name
+                typelist.append((param.name, ann))
+                if param.default is inspect._empty:
+                    req_names.add(param.name)
+            elif param.kind is inspect._VAR_POSITIONAL:
+                raise TypeError("ovld does not support *args")
+            elif param.kind is inspect._VAR_KEYWORD:
+                raise TypeError("ovld does not support **kwargs")
+            arginfo.append(
+                Arginfo(
+                    position=pos,
+                    name=nm,
+                    required=param.default is inspect._empty,
+                    ann=normalize_type(param.annotation, fn),
+                )
+            )
 
-    def __missing__(self, obj_t_tup):
-        specificities = {}
-        candidates = None
-        nargs = len(obj_t_tup)
+        return cls(
+            types=tuple(typelist),
+            req_pos=req_pos,
+            max_pos=max_pos,
+            req_names=frozenset(req_names),
+            vararg=False,
+            is_method=is_method,
+            priority=None,
+            arginfo=arginfo,
+        )
 
-        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]
-            except KeyError:
-                results = {}
-
-            results = {
-                handler: spc
-                for (handler, min, max, va), spc in results.items()
-                if min <= nargs <= (math.inf if va else max)
-            }
-
-            try:
-                vararg_results = self.maps[-1][cls]
-            except KeyError:
-                vararg_results = {}
-
-            vararg_results = {
-                handler: spc
-                for (handler, min, max, va), spc in vararg_results.items()
-                if min <= nargs and i >= max
-            }
-
-            results.update(vararg_results)
-
-            if candidates is None:
-                candidates = set(results.keys())
-            else:
-                candidates &= results.keys()
-            for c in candidates:
-                specificities.setdefault(c, []).append(results[c])
-
-        if not candidates:
-            raise self.key_error(obj_t_tup, ())
-
-        candidates = [(c, 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.
-                    break
-            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])
+
+def clsstring(cls):
+    if cls is object:
+        return "*"
+    elif isinstance(cls, tuple):
+        key, typ = cls
+        return f"{key}: {clsstring(typ)}"
+    elif is_type_of_type(cls):
+        arg = clsstring(cls.__args__[0])
+        return f"type[{arg}]"
+    elif hasattr(cls, "__origin__"):
+        if cls.__origin__ is typing.Union:
+            return "|".join(map(clsstring, cls.__args__))
         else:
-            ((result, _),) = results
-            self[obj_t_tup] = result
-            return result
+            return repr(cls)
+    elif hasattr(cls, "__name__"):
+        return cls.__name__
+    else:
+        return repr(cls)
 
 
-def _fresh(t):
-    """Returns a new subclass of type t.
-
-    Each Ovld corresponds to its own class, which allows for specialization of
-    methods.
-    """
-    return type(t.__name__, (t,), {})
+def sigstring(types):
+    return ", ".join(map(clsstring, types))
 
 
-@keyword_decorator
-def _setattrs(fn, **kwargs):
-    for k, v in kwargs.items():
-        setattr(fn, k, v)
-    return fn
-
-
-@keyword_decorator
-def _compile_first(fn, rename=None):
-    def deco(self, *args, **kwargs):
-        self.compile()
-        method = getattr(self, fn.__name__)
-        assert method is not deco
-        return method(*args, **kwargs)
+class ArgumentAnalyzer:
+    def __init__(self):
+        self.name_to_positions = defaultdict(set)
+        self.position_to_names = defaultdict(set)
+        self.counts = defaultdict(lambda: [0, 0])
+        self.complex_transforms = set()
+        self.total = 0
+        self.is_method = None
+
+    def add(self, fn):
+        sig = Signature.extract(fn)
+        self.complex_transforms.update(
+            arg.canonical for arg in sig.arginfo if arg.is_complex
+        )
+        for arg in sig.arginfo:
+            if arg.position is not None:
+                self.position_to_names[arg.position].add(arg.name)
+            if arg.name is not None:
+                self.name_to_positions[arg.name].add(arg.canonical)
+
+            cnt = self.counts[arg.canonical]
+            cnt[0] += arg.required
+            cnt[1] += 1
+
+        self.total += 1
+
+        if self.is_method is None:
+            self.is_method = sig.is_method
+        elif self.is_method != sig.is_method:  # pragma: no cover
+            raise TypeError(
+                "Some, but not all registered methods define `self`. It should be all or none."
+            )
 
-    def setalt(alt):
-        deco._alt = alt
-        return None
+    def compile(self):
+        for name, pos in self.name_to_positions.items():
+            if len(pos) != 1:
+                if all(isinstance(p, int) for p in pos):
+                    raise TypeError(
+                        f"Argument '{name}' is declared in different positions by different methods. The same argument name should always be in the same position unless it is strictly positional."
+                    )
+                else:
+                    raise TypeError(
+                        f"Argument '{name}' is declared in a positional and keyword setting by different methods. It should be either."
+                    )
+
+        p_to_n = [
+            list(names) for _, names in sorted(self.position_to_names.items())
+        ]
+
+        positional = list(
+            itertools.takewhile(
+                lambda names: len(names) == 1 and isinstance(names[0], str),
+                reversed(p_to_n),
+            )
+        )
+        positional.reverse()
+        strict_positional = p_to_n[: len(p_to_n) - len(positional)]
+
+        assert strict_positional + positional == p_to_n
+
+        strict_positional_required = [
+            f"ARG{pos + 1}"
+            for pos, _ in enumerate(strict_positional)
+            if self.counts[pos][0] == self.total
+        ]
+        strict_positional_optional = [
+            f"ARG{pos + 1}"
+            for pos, _ in enumerate(strict_positional)
+            if self.counts[pos][0] != self.total
+        ]
+
+        positional_required = [
+            names[0]
+            for pos, names in enumerate(positional)
+            if self.counts[pos + len(strict_positional)][0] == self.total
+        ]
+        positional_optional = [
+            names[0]
+            for pos, names in enumerate(positional)
+            if self.counts[pos + len(strict_positional)][0] != self.total
+        ]
+
+        keywords = [
+            name
+            for _, (name,) in self.name_to_positions.items()
+            if not isinstance(name, int)
+        ]
+        keyword_required = [
+            name for name in keywords if self.counts[name][0] == self.total
+        ]
+        keyword_optional = [
+            name for name in keywords if self.counts[name][0] != self.total
+        ]
+
+        return (
+            strict_positional_required,
+            strict_positional_optional,
+            positional_required,
+            positional_optional,
+            keyword_required,
+            keyword_optional,
+        )
 
-    deco.setalt = setalt
-    deco._replace_by = fn
-    deco._alt = None
-    deco._rename = rename
-    return deco
+    def lookup_for(self, key):
+        return (
+            "self.map.transform" if key in self.complex_transforms else "type"
+        )
 
 
 class _Ovld:
@@ -271,21 +295,11 @@ class _Ovld:
     function should annotate the same parameter.
 
     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
             Ovld.
-        type_error: The error type to raise when no function can be found to
-            dispatch to (default: TypeError).
         name: Optional name for the Ovld. If not provided, it will be
             gotten automatically from the first registered function or
             dispatch.
-        mapper: Class implementing a mapping interface from a tuple of
-            types to a handler (default: MultiTypeMap).
         linkback: Whether to keep a pointer in the parent mixins to this
             ovld so that updates can be propagated. (default: False)
         allow_replacement: Allow replacing a method by another with the
@@ -295,45 +309,27 @@ class _Ovld:
     def __init__(
         self,
         *,
-        dispatch=None,
-        initial_state=None,
-        postprocess=None,
-        type_error=TypeError,
         mixins=[],
         bootstrap=None,
         name=None,
-        mapper=MultiTypeMap,
         linkback=False,
         allow_replacement=True,
     ):
         """Initialize an Ovld."""
+        self.id = next(_current_id)
         self._compiled = False
-        self._dispatch = dispatch
-        self.maindoc = None
-        self.mapper = mapper
         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:
-            assert bootstrap is not False
-            self.bootstrap = True
-        elif isinstance(bootstrap, type):
-            self.bootstrap_class = bootstrap
-            self.bootstrap = True
-        else:
-            self.bootstrap = bootstrap
+        self.bootstrap = bootstrap
         self.name = name
+        self.shortname = name or f"__OVLD{self.id}"
         self.__name__ = name
         self._defns = {}
         self._locked = False
         self.mixins = []
         self.add_mixins(*mixins)
-        self.ocls = _fresh(self.bootstrap_class)
-        self._make_signature()
+        self.ocls = _fresh(OvldCall)
 
     @property
     def defns(self):
@@ -343,6 +339,42 @@ class _Ovld:
         defns.update(self._defns)
         return defns
 
+    @property
+    def __doc__(self):
+        if not self._compiled:
+            self.compile()
+
+        docs = [fn.__doc__ for fn in self.defns.values() if fn.__doc__]
+        if len(docs) == 1:
+            maindoc = docs[0]
+        else:
+            maindoc = f"Ovld with {len(self.defns)} methods."
+
+        doc = f"{maindoc}\n\n"
+        for fn in self.defns.values():
+            fndef = inspect.signature(fn)
+            fdoc = fn.__doc__
+            if not fdoc or fdoc == maindoc:
+                doc += f"{self.__name__}{fndef}\n\n"
+            else:
+                if not fdoc.strip(" ").endswith("\n"):
+                    fdoc += "\n"
+                fdoc = textwrap.indent(fdoc, " " * 4)
+                doc += f"{self.__name__}{fndef}\n{fdoc}\n"
+        return doc
+
+    @property
+    def __signature__(self):
+        if not self._compiled:
+            self.compile()
+
+        sig = inspect.signature(self._dispatch)
+        if not self.argument_analysis.is_method:
+            sig = inspect.Signature(
+                [v for k, v in sig.parameters.items() if k != "self"]
+            )
+        return sig
+
     def lock(self):
         self._locked = True
 
@@ -355,101 +387,40 @@ class _Ovld:
         for mixin in mixins:
             if self.linkback:
                 mixin.children.append(self)
-            if mixin._defns:
-                assert mixin.bootstrap is not None
-                if self.bootstrap is None:
-                    self.bootstrap = mixin.bootstrap
-                assert mixin.bootstrap is self.bootstrap
-            if mixin._dispatch:
-                self._dispatch = mixin._dispatch
+            if mixin._defns and self.bootstrap is None:
+                self.bootstrap = mixin.bootstrap
         self.mixins += mixins
 
-    def _sig_string(self, type_tuple):
-        def clsname(cls):
-            if cls is object:
-                return "*"
-            elif is_type_of_type(cls):
-                arg = clsname(cls.__args__[0])
-                return f"type[{arg}]"
-            elif hasattr(cls, "__name__"):
-                return cls.__name__
-            else:
-                return repr(cls)
-
-        return ", ".join(map(clsname, type_tuple))
-
     def _key_error(self, key, possibilities=None):
-        typenames = self._sig_string(key)
+        typenames = sigstring(key)
         if not possibilities:
-            raise self.type_error(
+            return TypeError(
                 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 TypeError(
                 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):
         """Rename this Ovld."""
         self.name = name
         self.__name__ = name
-        self._make_signature()
-
-    def _make_signature(self):
-        """Make the __doc__ and __signature__."""
 
-        def modelA(*args, **kwargs):  # pragma: no cover
-            pass
-
-        def modelB(self, *args, **kwargs):  # pragma: no cover
-            pass
-
-        seen = set()
-        doc = (
-            f"{self.maindoc}\n"
-            if self.maindoc
-            else f"Ovld with {len(self.defns)} methods.\n\n"
-        )
-        for key, fn in self.defns.items():
-            if fn in seen:
-                continue
-            seen.add(fn)
-            fndef = inspect.signature(fn)
-            fdoc = fn.__doc__
-            if not fdoc or fdoc == self.maindoc:
-                doc += f"    ``{self.__name__}{fndef}``\n\n"
-            else:
-                if not fdoc.strip(" ").endswith("\n"):
-                    fdoc += "\n"
-                fdoc = textwrap.indent(fdoc, " " * 8)
-                doc += f"    ``{self.__name__}{fndef}``\n{fdoc}\n"
-        self.__doc__ = doc
-        if self.bootstrap:
-            self.__signature__ = inspect.signature(modelB)
-        else:
-            self.__signature__ = inspect.signature(modelA)
-
-    def _set_attrs_from(self, fn, dispatch=False):
+    def _set_attrs_from(self, fn):
         """Inherit relevant attributes from the function."""
         if self.bootstrap is None:
-            sign = inspect.signature(fn)
-            params = list(sign.parameters.values())
-            if not dispatch:
-                if params and params[0].name == "self":
-                    self.bootstrap = True
-                else:
-                    self.bootstrap = False
+            self.bootstrap = arg0_is_self(fn)
 
         if self.name is None:
             self.name = f"{fn.__module__}.{fn.__qualname__}"
-            self.maindoc = fn.__doc__
-            if self.maindoc and not self.maindoc.strip(" ").endswith("\n"):
-                self.maindoc += "\n"
+            self.shortname = fn.__name__
             self.__name__ = fn.__name__
             self.__qualname__ = fn.__qualname__
             self.__module__ = fn.__module__
@@ -473,119 +444,73 @@ class _Ovld:
         for mixin in self.mixins:
             if self not in mixin.children:
                 mixin.lock()
-        self._compiled = True
-        self.map = self.mapper(key_error=self._key_error)
 
         cls = type(self)
         if self.name is None:
-            self.name = self.__name__ = f"ovld{id(self)}"
+            self.name = self.__name__ = f"ovld{self.id}"
 
         name = self.__name__
+        self.map = MultiTypeMap(name=name, key_error=self._key_error)
 
         # Replace the appropriate functions by their final behavior
         for method in dir(cls):
             value = getattr(cls, method)
             repl = getattr(value, "_replace_by", None)
             if repl:
-                if self.bootstrap and value._alt:
-                    repl = value._alt
                 repl = self._maybe_rename(repl)
                 setattr(cls, method, repl)
 
-        if self._dispatch:
-            if self.bootstrap:
-                self.ocls.__call__ = self._dispatch
-            else:
-                cls.__call__ = self._dispatch
+        target = self.ocls if self.bootstrap else cls
 
-        # Rename the dispatch
-        if self._dispatch:
-            self._dispatch = rename_function(self._dispatch, f"{name}.dispatch")
+        anal = ArgumentAnalyzer()
+        for key, fn in list(self.defns.items()):
+            anal.add(fn)
+        self.argument_analysis = anal
+        dispatch = generate_dispatch(anal)
+        self._dispatch = dispatch
+        target.__call__ = rename_function(dispatch, f"{name}.dispatch")
 
         for key, fn in list(self.defns.items()):
             self.register_signature(key, fn)
 
-    def dispatch(self, dispatch):
-        """Set a dispatch function."""
-        if self._dispatch is not None:
-            raise TypeError(f"dispatch for {self} is already set")
-        self._dispatch = dispatch
-        self._set_attrs_from(dispatch, dispatch=True)
-        return self
+        self._compiled = True
 
+    @_compile_first
     def resolve(self, *args):
         """Find the correct method to call for the given arguments."""
         return self.map[tuple(map(self.map.transform, args))]
 
-    def register_signature(self, key, orig_fn):
+    def register_signature(self, sig, orig_fn):
         """Register a function for the given signature."""
-        sig, min, max, vararg = key
-        fn = rename_function(
-            orig_fn, f"{self.__name__}[{self._sig_string(sig)}]"
+        fn = adapt_function(
+            orig_fn, self, f"{self.__name__}[{sigstring(sig.types)}]"
         )
         # 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, 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 _normalize_type(t, force_tuple=False):
-            origin = getattr(t, "__origin__", None)
-            if UnionType and isinstance(t, UnionType):
-                return _normalize_type(t.__args__)
-            elif origin is type:
-                return (t,) if force_tuple else t
-            elif origin is typing.Union:
-                return _normalize_type(t.__args__)
-            elif origin is not None:
-                raise TypeError(
-                    "ovld does not accept generic types except type, Union or Optional"
-                )
-            elif isinstance(t, tuple):
-                return tuple(_normalize_type(t2) for t2 in t)
-            elif force_tuple:
-                return (t,)
-            else:
-                return t
+    def _register(self, fn, priority):
+        """Register a function."""
 
         self._attempt_modify()
 
         self._set_attrs_from(fn)
 
-        ann = fn.__annotations__
-        argspec = inspect.getfullargspec(fn)
-        argnames = argspec.args
-        if self.bootstrap:
-            if argnames[0] != "self":
-                raise TypeError(
-                    "The first argument of the function must be named `self`"
-                )
-            argnames = argnames[1:]
-
-        typelist = []
-        for i, name in enumerate(argnames):
-            t = ann.get(name, None)
-            if t is None:
-                typelist.append(object)
-            else:
-                typelist.append(t)
-
-        max_pos = len(argnames)
-        req_pos = max_pos - len(argspec.defaults or ())
-
-        typelist_tups = tuple(
-            _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))
-            if not self.allow_replacement and sig in self._defns:
-                raise TypeError(f"There is already a method for {tl}")
-            self._defns[(*sig,)] = fn
+        sig = replace(Signature.extract(fn), priority=priority)
+        if not self.allow_replacement and sig in self._defns:
+            raise TypeError(
+                f"There is already a method for {sigstring(sig.types)}"
+            )
+        self._defns[sig] = fn
 
-        self._make_signature()
         self._update()
         return self
 
@@ -601,14 +526,7 @@ class _Ovld:
         for child in self.children:
             child._update()
 
-    def copy(
-        self,
-        dispatch=MISSING,
-        initial_state=None,
-        postprocess=None,
-        mixins=[],
-        linkback=False,
-    ):
+    def copy(self, mixins=[], linkback=False):
         """Create a copy of this Ovld.
 
         New functions can be registered to the copy without affecting the
@@ -616,14 +534,11 @@ class _Ovld:
         """
         return _fresh(_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,
         )
 
-    def variant(self, fn=None, **kwargs):
+    def variant(self, fn=None, priority=0, **kwargs):
         """Decorator to create a variant of this Ovld.
 
         New functions can be registered to the variant without affecting the
@@ -631,74 +546,58 @@ class _Ovld:
         """
         ov = self.copy(**kwargs)
         if fn is None:
-            return ov.register
+            return partial(ov.register, priority=priority)
         else:
-            ov.register(fn)
+            ov.register(fn, priority=priority)
             return ov
 
-    @_compile_first
-    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,
-        )
+        key = self.shortname
+        rval = obj.__dict__.get(key, None)
+        if rval is None:
+            obj.__dict__[key] = rval = self.ocls(self, obj)
+        return rval
 
     @_compile_first
     def __getitem__(self, t):
         if not isinstance(t, tuple):
             t = (t,)
-        assert not self.bootstrap
         return self.map[t]
 
     @_compile_first
     @_setattrs(rename="dispatch")
-    def __call__(self, *args, **kwargs):
+    def __call__(self, *args):  # pragma: no cover
         """Call the overloaded function.
 
-        This version of __call__ is used when bootstrap is False.
-
-        If bootstrap is False and a dispatch function is provided, it
-        replaces this function.
+        This should be replaced by an auto-generated function.
         """
         key = tuple(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.
+        return method(*args)
 
-        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
-        OvldCall.__call__.
-        """
-        ovc = self.__get__(BOOTSTRAP, None)
-        res = ovc(*args, **kwargs)
-        if self.postprocess:
-            res = self.postprocess(self, res)
-        return res
+    @_compile_first
+    @_setattrs(rename="next")
+    def next(self, *args):
+        """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)
 
     def __repr__(self):
         return f"<Ovld {self.name or hex(id(self))}>"
 
+    @_compile_first
+    def display_methods(self):
+        self.map.display_methods()
+
+    @_compile_first
+    def display_resolution(self, *args, **kwargs):
+        self.map.display_resolution(*args, **kwargs)
+
 
 def is_ovld(x):
     """Return whether the argument is an ovld function/method."""
@@ -708,46 +607,43 @@ def is_ovld(x):
 class OvldCall:
     """Context for an Ovld call."""
 
-    def __init__(self, map, state, bind_to, super=None):
+    def __init__(self, ovld, bind_to):
         """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
+        self.ovld = ovld
+        self.map = ovld.map
+        self.obj = bind_to
 
-    def __getitem__(self, t):
-        """Find the right method to call given a tuple of types."""
-        if not isinstance(t, tuple):
-            t = (t,)
-        return self.map[t].__get__(self.obj)
+    @property
+    def __name__(self):
+        return self.ovld.__name__
 
-    def super(self, *args, **kwargs):
-        """Use the parent ovld's method for this call."""
-        pmap = self._parent.get_map()
-        method = pmap[tuple(map(pmap.transform, args))]
-        return method.__get__(self.obj)(*args, **kwargs)
+    @property
+    def __doc__(self):
+        return self.ovld.__doc__
 
-    def resolve(self, *args):
-        """Find the right method to call for the given arguments."""
-        return self[tuple(map(self.map.transform, args))]
+    @property
+    def __signature__(self):
+        return self.ovld.__signature__
 
-    def call(self, *args):
-        """Call the right method for the given arguments."""
-        return self[tuple(map(self.map.transform, args))](*args)
+    def next(self, *args):
+        """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)
 
-    def with_state(self, **state):
-        """Return a new OvldCall using the given state."""
-        return type(self)(self.map, state, BOOTSTRAP)
+    def resolve(self, *args):
+        """Find the right method to call for the given arguments."""
+        return self.map[tuple(map(self.map.transform, args))].__get__(self.obj)
 
-    def __call__(self, *args, **kwargs):
+    def __call__(self, *args):  # pragma: no cover
         """Call this overloaded function.
 
-        If a dispatch function is provided, it replaces this function.
+        This should be replaced by an auto-generated function.
         """
         key = tuple(map(self.map.transform, args))
         method = self.map[key]
-        return method(self.obj, *args, **kwargs)
+        return method(self.obj, *args)
 
 
 def Ovld(*args, **kwargs):
@@ -762,7 +658,7 @@ def extend_super(fn):
     plus this definition and others with the same name.
     """
     if not is_ovld(fn):
-        fn = ovld(fn)
+        fn = ovld(fn, fresh=True)
     fn._extend_super = True
     return fn
 
@@ -774,29 +670,45 @@ class ovld_cls_dict(dict):
     """
 
     def __init__(self, bases):
-        self._mock = type("MockSuper", bases, {})
+        self._bases = bases
 
     def __setitem__(self, attr, value):
+        prev = None
         if attr in self:
             prev = self[attr]
+            if inspect.isfunction(prev):
+                prev = ovld(prev, fresh=True)
+            elif not is_ovld(prev):  # pragma: no cover
+                prev = None
         elif is_ovld(value) and getattr(value, "_extend_super", False):
-            prev = getattr(self._mock, attr, None)
-            if is_ovld(prev):
-                prev = prev.copy()
+            mixins = []
+            for base in self._bases:
+                if (candidate := getattr(base, attr, None)) is not None:
+                    if is_ovld(candidate) or inspect.isfunction(candidate):
+                        mixins.append(candidate)
+            if mixins:
+                prev, *others = mixins
+                if is_ovld(prev):
+                    prev = prev.copy()
+                else:
+                    prev = ovld(prev, fresh=True)
+                for other in others:
+                    if is_ovld(other):
+                        prev.add_mixins(other)
+                    else:
+                        prev.register(other)
         else:
             prev = None
 
         if prev is not None:
-            if inspect.isfunction(prev):
-                prev = ovld(prev)
-
-            if is_ovld(prev):
-                if is_ovld(value):
-                    prev.add_mixins(value)
-                    value = prev
-                elif inspect.isfunction(value):
-                    prev.register(value)
-                    value = prev
+            if is_ovld(value) and prev is not value:
+                if prev.name is None:
+                    prev.rename(value.name)
+                prev.add_mixins(value)
+                value = prev
+            elif inspect.isfunction(value):
+                prev.register(value)
+                value = prev
 
         super().__setitem__(attr, value)
 
@@ -844,19 +756,31 @@ class OvldBase(metaclass=OvldMC):
 
 
 def _find_overload(fn, **kwargs):
-    mod = __import__(fn.__module__, fromlist="_")
-    dispatch = getattr(mod, fn.__qualname__, None)
+    fr = sys._getframe(1)  # We typically expect to get to frame 3.
+    while fr and fn.__code__ not in fr.f_code.co_consts:
+        # We are basically searching for the function's code object in the stack.
+        # When a class/function A is nested in a class/function B, the former's
+        # code object is in the latter's co_consts. If ovld is used as a decorator,
+        # on A, then necessarily we are inside the execution of B, so B should be
+        # on the stack and we should be able to find A's code object in there.
+        fr = fr.f_back
+
+    if not fr:
+        raise UsageError("@ovld only works as a decorator.")
+
+    dispatch = fr.f_locals.get(fn.__name__, None)
+
     if dispatch is None:
         dispatch = _fresh(_Ovld)(**kwargs)
+    elif not is_ovld(dispatch):  # pragma: no cover
+        raise TypeError("@ovld requires Ovld instance")
     elif kwargs:  # pragma: no cover
         raise TypeError("Cannot configure an overload that already exists")
-    if not is_ovld(dispatch):  # pragma: no cover
-        raise TypeError("@ovld requires Ovld instance")
     return dispatch
 
 
 @keyword_decorator
-def ovld(fn, **kwargs):
+def ovld(fn, priority=0, fresh=False, **kwargs):
     """Overload a function.
 
     Overloading is based on the function name.
@@ -870,151 +794,29 @@ def ovld(fn, **kwargs):
 
     Arguments:
         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
-            Ovld.
-        type_error: The error type to raise when no function can be found to
-            dispatch to (default: TypeError).
-        name: Optional name for the Ovld. If not provided, it will be
-            gotten automatically from the first registered function or
-            dispatch.
-        mapper: Class implementing a mapping interface from a tuple of
-            types to a handler (default: MultiTypeMap).
-        linkback: Whether to keep a pointer in the parent mixins to this
-            ovld so that updates can be propagated. (default: False)
-    """
-    dispatch = _find_overload(fn, **kwargs)
-    return dispatch.register(fn)
-
-
-@keyword_decorator
-def ovld_dispatch(dispatch, **kwargs):
-    """Overload a function using the decorated function as a dispatcher.
-
-    The dispatch is the entry point for the function and receives a `self`
-    which is an Ovld or OvldCall instance, and the rest of the arguments.
-    It may call `self.resolve(arg1, arg2, ...)` to get the right method to
-    call.
-
-    The decorator optionally takes keyword arguments, *only* on the first
-    use.
-
-    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.
+        priority: The priority of the function in the resolution order.
+        fresh: Whether to create a new ovld or try to reuse an existing one.
         mixins: A list of Ovld instances that contribute functions to this
             Ovld.
-        type_error: The error type to raise when no function can be found to
-            dispatch to (default: TypeError).
         name: Optional name for the Ovld. If not provided, it will be
             gotten automatically from the first registered function or
             dispatch.
-        mapper: Class implementing a mapping interface from a tuple of
-            types to a handler (default: MultiTypeMap).
         linkback: Whether to keep a pointer in the parent mixins to this
             ovld so that updates can be propagated. (default: False)
     """
-    ov = _find_overload(dispatch, **kwargs)
-    return ov.dispatch(dispatch)
-
-
-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)
+    if fresh:
+        dispatch = _fresh(_Ovld)(**kwargs)
     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
+        dispatch = _find_overload(fn, **kwargs)
+    return dispatch.register(fn, priority=priority)
 
 
 __all__ = [
-    "MultiTypeMap",
     "Ovld",
     "OvldBase",
     "OvldCall",
     "OvldMC",
-    "TypeMap",
     "extend_super",
     "is_ovld",
     "ovld",
-    "ovld_dispatch",
 ]