ovld 0.4.4__py3-none-any.whl → 0.4.6__py3-none-any.whl

ovld/__init__.py

@@ -4,7 +4,6 @@ from . import abc  # noqa: F401
 from .core import (
     Ovld,
     OvldBase,
-    OvldCall,
     OvldMC,
     extend_super,
     is_ovld,
@@ -53,7 +52,6 @@ __all__ = [
     "MultiTypeMap",
     "Ovld",
     "OvldBase",
-    "OvldCall",
     "OvldMC",
     "TypeMap",
     "extend_super",

ovld/core.py

@@ -5,36 +5,24 @@ import itertools
 import sys
 import textwrap
 import typing
-from collections import defaultdict
+from collections import OrderedDict, defaultdict
 from dataclasses import dataclass, field, replace
 from functools import cached_property, partial
-from types import GenericAlias
+from types import FunctionType, GenericAlias
 
 from .recode import (
     Conformer,
     adapt_function,
     generate_dispatch,
-    rename_function,
+    rename_code,
 )
 from .typemap import MultiTypeMap
 from .types import clsstring, normalize_type
-from .utils import UsageError, keyword_decorator, subtler_type
+from .utils import MISSING, UsageError, keyword_decorator, subtler_type
 
 _current_id = itertools.count()
 
 
-def _fresh(t):
-    """Returns a new subclass of type t.
-
-    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)
-
-
 @keyword_decorator
 def _setattrs(fn, **kwargs):
     for k, v in kwargs.items():
@@ -42,23 +30,107 @@ def _setattrs(fn, **kwargs):
     return fn
 
 
-@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)
+class LazySignature(inspect.Signature):
+    def __init__(self, ovld):
+        super().__init__([])
+        self.ovld = ovld
 
-    first_entry._replace_by = fn
-    first_entry._rename = rename
-    return first_entry
+    def replace(
+        self, *, parameters=inspect._void, return_annotation=inspect._void
+    ):  # pragma: no cover
+        if parameters is inspect._void:
+            parameters = self.parameters.values()
 
+        if return_annotation is inspect._void:
+            return_annotation = self._return_annotation
 
-def arg0_is_self(fn):
-    sgn = inspect.signature(fn)
-    params = list(sgn.parameters.values())
-    return params and params[0].name == "self"
+        return inspect.Signature(
+            parameters, return_annotation=return_annotation
+        )
+
+    @property
+    def parameters(self):
+        anal = self.ovld.analyze_arguments()
+        parameters = []
+        if anal.is_method:
+            parameters.append(
+                inspect.Parameter(
+                    name="self",
+                    kind=inspect._POSITIONAL_ONLY,
+                )
+            )
+        parameters += [
+            inspect.Parameter(
+                name=p,
+                kind=inspect._POSITIONAL_ONLY,
+            )
+            for p in anal.strict_positional_required
+        ]
+        parameters += [
+            inspect.Parameter(
+                name=p,
+                kind=inspect._POSITIONAL_ONLY,
+                default=MISSING,
+            )
+            for p in anal.strict_positional_optional
+        ]
+        parameters += [
+            inspect.Parameter(
+                name=p,
+                kind=inspect._POSITIONAL_OR_KEYWORD,
+            )
+            for p in anal.positional_required
+        ]
+        parameters += [
+            inspect.Parameter(
+                name=p,
+                kind=inspect._POSITIONAL_OR_KEYWORD,
+                default=MISSING,
+            )
+            for p in anal.positional_optional
+        ]
+        parameters += [
+            inspect.Parameter(
+                name=p,
+                kind=inspect._KEYWORD_ONLY,
+            )
+            for p in anal.keyword_required
+        ]
+        parameters += [
+            inspect.Parameter(
+                name=p,
+                kind=inspect._KEYWORD_ONLY,
+                default=MISSING,
+            )
+            for p in anal.keyword_optional
+        ]
+        return OrderedDict({p.name: p for p in parameters})
+
+
+def bootstrap_dispatch(ov, name):
+    def first_entry(*args, **kwargs):
+        ov.compile()
+        return ov.dispatch(*args, **kwargs)
+
+    dispatch = FunctionType(
+        rename_code(first_entry.__code__, name),
+        {},
+        name,
+        (),
+        first_entry.__closure__,
+    )
+    dispatch.__signature__ = LazySignature(ov)
+    dispatch.__ovld__ = ov
+    dispatch.register = ov.register
+    dispatch.resolve = ov.resolve
+    dispatch.copy = ov.copy
+    dispatch.variant = ov.variant
+    dispatch.display_methods = ov.display_methods
+    dispatch.display_resolution = ov.display_resolution
+    dispatch.add_mixins = ov.add_mixins
+    dispatch.unregister = ov.unregister
+    dispatch.next = ov.next
+    return dispatch
 
 
 @dataclass(frozen=True)
@@ -171,8 +243,10 @@ class ArgumentAnalyzer:
         self.complex_transforms = set()
         self.total = 0
         self.is_method = None
+        self.done = False
 
     def add(self, fn):
+        self.done = False
         sig = Signature.extract(fn)
         self.complex_transforms.update(
             arg.canonical for arg in sig.arginfo if arg.is_complex
@@ -197,6 +271,8 @@ class ArgumentAnalyzer:
             )
 
     def compile(self):
+        if self.done:
+            return
         for name, pos in self.name_to_positions.items():
             if len(pos) != 1:
                 if all(isinstance(p, int) for p in pos):
@@ -223,23 +299,23 @@ class ArgumentAnalyzer:
 
         assert strict_positional + positional == p_to_n
 
-        strict_positional_required = [
+        self.strict_positional_required = [
             f"ARG{pos + 1}"
             for pos, _ in enumerate(strict_positional)
             if self.counts[pos][0] == self.total
         ]
-        strict_positional_optional = [
+        self.strict_positional_optional = [
             f"ARG{pos + 1}"
             for pos, _ in enumerate(strict_positional)
             if self.counts[pos][0] != self.total
         ]
 
-        positional_required = [
+        self.positional_required = [
             names[0]
             for pos, names in enumerate(positional)
             if self.counts[pos + len(strict_positional)][0] == self.total
         ]
-        positional_optional = [
+        self.positional_optional = [
             names[0]
             for pos, names in enumerate(positional)
             if self.counts[pos + len(strict_positional)][0] != self.total
@@ -250,27 +326,19 @@ class ArgumentAnalyzer:
             for _, (name,) in self.name_to_positions.items()
             if not isinstance(name, int)
         ]
-        keyword_required = [
+        self.keyword_required = [
             name for name in keywords if self.counts[name][0] == self.total
         ]
-        keyword_optional = [
+        self.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,
-        )
+        self.done = True
 
     def lookup_for(self, key):
         return subtler_type if key in self.complex_transforms else type
 
 
-class _Ovld:
+class Ovld:
     """Overloaded function.
 
     A function can be added with the `register` method. One of its parameters
@@ -293,7 +361,6 @@ class _Ovld:
         self,
         *,
         mixins=[],
-        bootstrap=None,
         name=None,
         linkback=False,
         allow_replacement=True,
@@ -304,15 +371,14 @@ class _Ovld:
         self.linkback = linkback
         self.children = []
         self.allow_replacement = allow_replacement
-        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.argument_analysis = ArgumentAnalyzer()
         self.add_mixins(*mixins)
-        self.ocls = _fresh(OvldCall)
 
     @property
     def defns(self):
@@ -322,11 +388,14 @@ class _Ovld:
         defns.update(self._defns)
         return defns
 
-    @property
-    def __doc__(self):
-        if not self._compiled:
-            self.compile()
+    def analyze_arguments(self):
+        self.argument_analysis = ArgumentAnalyzer()
+        for key, fn in list(self.defns.items()):
+            self.argument_analysis.add(fn)
+        self.argument_analysis.compile()
+        return self.argument_analysis
 
+    def mkdoc(self):
         docs = [fn.__doc__ for fn in self.defns.values() if fn.__doc__]
         if len(docs) == 1:
             maindoc = docs[0]
@@ -347,16 +416,13 @@ class _Ovld:
         return doc
 
     @property
-    def __signature__(self):
-        if not self._compiled:
-            self.compile()
+    def __doc__(self):
+        self.ensure_compiled()
+        return self.mkdoc()
 
-        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
+    @property
+    def __signature__(self):
+        return self.dispatch.__signature__
 
     def lock(self):
         self._locked = True
@@ -367,11 +433,10 @@ class _Ovld:
 
     def add_mixins(self, *mixins):
         self._attempt_modify()
+        mixins = [o for m in mixins if (o := to_ovld(m)) is not self]
         for mixin in mixins:
             if self.linkback:
                 mixin.children.append(self)
-            if mixin._defns and self.bootstrap is None:
-                self.bootstrap = mixin.bootstrap
         self.mixins += mixins
 
     def _key_error(self, key, possibilities=None):
@@ -391,28 +456,23 @@ class _Ovld:
                 "Note: you can use @ovld(priority=X) to give higher priority to an overload."
             )
 
-    def rename(self, name):
+    def rename(self, name, shortname=None):
         """Rename this Ovld."""
         self.name = name
-        self.__name__ = name
+        self.shortname = shortname or name
+        self.__name__ = shortname
+        self.dispatch = bootstrap_dispatch(self, name=self.shortname)
 
     def _set_attrs_from(self, fn):
         """Inherit relevant attributes from the function."""
-        if self.bootstrap is None:
-            self.bootstrap = arg0_is_self(fn)
-
         if self.name is None:
-            self.name = f"{fn.__module__}.{fn.__qualname__}"
-            self.shortname = fn.__name__
-            self.__name__ = fn.__name__
             self.__qualname__ = fn.__qualname__
             self.__module__ = fn.__module__
+            self.rename(f"{fn.__module__}.{fn.__qualname__}", fn.__name__)
 
-    def _maybe_rename(self, fn):
-        if hasattr(fn, "rename"):
-            return rename_function(fn, f"{self.__name__}.{fn.rename}")
-        else:
-            return fn
+    def ensure_compiled(self):
+        if not self._compiled:
+            self.compile()
 
     def compile(self):
         """Finalize this overload.
@@ -428,39 +488,32 @@ class _Ovld:
             if self not in mixin.children:
                 mixin.lock()
 
-        cls = type(self)
         if self.name is None:
             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:
-                repl = self._maybe_rename(repl)
-                setattr(cls, method, repl)
-
-        target = self.ocls if self.bootstrap else cls
-
-        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")
+        self.analyze_arguments()
+        dispatch = generate_dispatch(self, self.argument_analysis)
+        if not hasattr(self, "dispatch"):
+            self.dispatch = bootstrap_dispatch(self, name=self.shortname)
+        self.dispatch.__code__ = rename_code(dispatch.__code__, self.shortname)
+        self.dispatch.__kwdefaults__ = dispatch.__kwdefaults__
+        self.dispatch.__annotations__ = dispatch.__annotations__
+        self.dispatch.__defaults__ = dispatch.__defaults__
+        self.dispatch.__globals__.update(dispatch.__globals__)
+        self.dispatch.map = self.map
+        self.dispatch.__doc__ = self.mkdoc()
 
         for key, fn in list(self.defns.items()):
             self.register_signature(key, fn)
 
         self._compiled = True
 
-    @_compile_first
     def resolve(self, *args):
         """Find the correct method to call for the given arguments."""
+        self.ensure_compiled()
         return self.map[tuple(map(subtler_type, args))]
 
     def register_signature(self, sig, orig_fn):
@@ -516,6 +569,8 @@ class _Ovld:
             self.compile()
         for child in self.children:
             child._update()
+        if hasattr(self, "dispatch"):
+            self.dispatch.__doc__ = self.mkdoc()
 
     def copy(self, mixins=[], linkback=False):
         """Create a copy of this Ovld.
@@ -523,11 +578,7 @@ class _Ovld:
         New functions can be registered to the copy without affecting the
         original.
         """
-        return _fresh(_Ovld)(
-            bootstrap=self.bootstrap,
-            mixins=[self, *mixins],
-            linkback=linkback,
-        )
+        return Ovld(mixins=[self, *mixins], linkback=linkback)
 
     def variant(self, fn=None, priority=0, **kwargs):
         """Decorator to create a variant of this Ovld.
@@ -542,34 +593,21 @@ class _Ovld:
             ov.register(fn, priority=priority)
             return ov
 
-    @_compile_first
     def __get__(self, obj, cls):
-        if obj is None:
-            return self
-        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,)
-        return self.map[t]
-
-    @_compile_first
+        if not self._compiled:
+            self.compile()
+        return self.dispatch.__get__(obj, cls)
+
     @_setattrs(rename="dispatch")
-    def __call__(self, *args):  # pragma: no cover
+    def __call__(self, *args, **kwargs):  # pragma: no cover
         """Call the overloaded function.
 
         This should be replaced by an auto-generated function.
         """
-        key = tuple(map(subtler_type, args))
-        method = self.map[key]
-        return method(*args)
+        if not self._compiled:
+            self.compile()
+        return self.dispatch(*args, **kwargs)
 
-    @_compile_first
     @_setattrs(rename="next")
     def next(self, *args):
         """Call the next matching method after the caller, in terms of priority or specificity."""
@@ -581,65 +619,29 @@ class _Ovld:
     def __repr__(self):
         return f"<Ovld {self.name or hex(id(self))}>"
 
-    @_compile_first
     def display_methods(self):
+        self.ensure_compiled()
         self.map.display_methods()
 
-    @_compile_first
     def display_resolution(self, *args, **kwargs):
+        self.ensure_compiled()
         self.map.display_resolution(*args, **kwargs)
 
 
 def is_ovld(x):
     """Return whether the argument is an ovld function/method."""
-    return isinstance(x, _Ovld)
-
-
-class OvldCall:
-    """Context for an Ovld call."""
-
-    def __init__(self, ovld, bind_to):
-        """Initialize an OvldCall."""
-        self.ovld = ovld
-        self.map = ovld.map
-        self.obj = bind_to
-
-    @property
-    def __name__(self):
-        return self.ovld.__name__
-
-    @property
-    def __doc__(self):
-        return self.ovld.__doc__
-
-    @property
-    def __signature__(self):
-        return self.ovld.__signature__
-
-    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(subtler_type, args))
-        method = self.map[key]
-        return method(self.obj, *args)
-
-    def resolve(self, *args):
-        """Find the right method to call for the given arguments."""
-        return self.map[tuple(map(subtler_type, args))].__get__(self.obj)
-
-    def __call__(self, *args):  # pragma: no cover
-        """Call this overloaded function.
-
-        This should be replaced by an auto-generated function.
-        """
-        key = tuple(map(subtler_type, args))
-        method = self.map[key]
-        return method(self.obj, *args)
+    return isinstance(x, Ovld) or isinstance(
+        getattr(x, "__ovld__", False), Ovld
+    )
 
 
-def Ovld(*args, **kwargs):
-    """Returns an instance of a fresh Ovld class."""
-    return _fresh(_Ovld)(*args, **kwargs)
+def to_ovld(x):
+    """Return whether the argument is an ovld function/method."""
+    x = getattr(x, "__ovld__", x)
+    if inspect.isfunction(x):
+        return ovld(x, fresh=True)
+    else:
+        return x if isinstance(x, Ovld) else None
 
 
 def extend_super(fn):
@@ -666,33 +668,24 @@ class ovld_cls_dict(dict):
     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
+            prev = to_ovld(self[attr])
         elif is_ovld(value) and getattr(value, "_extend_super", False):
             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 mixin := to_ovld(candidate):
+                        mixins.append(mixin)
             if mixins:
                 prev, *others = mixins
-                if is_ovld(prev):
-                    prev = prev.copy()
-                else:
-                    prev = ovld(prev, fresh=True)
+                prev = prev.copy()
                 for other in others:
-                    if is_ovld(other):
-                        prev.add_mixins(other)
-                    else:
-                        prev.register(other)
+                    prev.add_mixins(other)
         else:
             prev = None
 
         if prev is not None:
             if is_ovld(value) and prev is not value:
+                value = getattr(value, "__ovld__", value)
                 if prev.name is None:
                     prev.rename(value.name)
                 prev.add_mixins(value)
@@ -701,7 +694,9 @@ class ovld_cls_dict(dict):
                 prev.register(value)
                 value = prev
 
-        super().__setitem__(attr, value)
+        super().__setitem__(
+            attr, value.dispatch if isinstance(value, Ovld) else value
+        )
 
 
 class OvldMC(type):
@@ -762,12 +757,12 @@ def _find_overload(fn, **kwargs):
     dispatch = fr.f_locals.get(fn.__name__, None)
 
     if dispatch is None:
-        dispatch = _fresh(_Ovld)(**kwargs)
+        dispatch = 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")
-    return dispatch
+    return getattr(dispatch, "__ovld__", dispatch)
 
 
 @keyword_decorator
@@ -796,16 +791,16 @@ def ovld(fn, priority=0, fresh=False, **kwargs):
             ovld so that updates can be propagated. (default: False)
     """
     if fresh:
-        dispatch = _fresh(_Ovld)(**kwargs)
+        dispatch = Ovld(**kwargs)
     else:
         dispatch = _find_overload(fn, **kwargs)
-    return dispatch.register(fn, priority=priority)
+    dispatch.register(fn, priority=priority)
+    return dispatch.dispatch
 
 
 __all__ = [
     "Ovld",
     "OvldBase",
-    "OvldCall",
     "OvldMC",
     "extend_super",
     "is_ovld",

ovld/dependent.py

@@ -2,7 +2,6 @@ import inspect
 import re
 from collections.abc import Callable as _Callable
 from collections.abc import Mapping, Sequence
-from dataclasses import dataclass
 from functools import partial
 from itertools import count
 from typing import (
@@ -16,6 +15,7 @@ from .types import (
     Intersection,
     Order,
     clsstring,
+    get_args,
     normalize_type,
     subclasscheck,
     typeorder,
@@ -28,13 +28,13 @@ def generate_checking_code(typ):
     if hasattr(typ, "codegen"):
         return typ.codegen()
     else:
-        return CodeGen("isinstance({arg}, {this})", {"this": typ})
+        return CodeGen("isinstance({arg}, {this})", this=typ)
 
 
-@dataclass
 class CodeGen:
-    template: str
-    substitutions: dict
+    def __init__(self, template, substitutions={}, **substitutions_kw):
+        self.template = template
+        self.substitutions = {**substitutions, **substitutions_kw}
 
     def mangle(self):
         renamings = {
@@ -46,10 +46,7 @@ class CodeGen:
             for k, newk in renamings.items()
             if k in self.substitutions
         }
-        return CodeGen(
-            template=self.template.format(**renamings),
-            substitutions=new_subs,
-        )
+        return CodeGen(self.template.format(**renamings), new_subs)
 
 
 def combine(master_template, args):
@@ -65,7 +62,7 @@ def combine(master_template, args):
 def is_dependent(t):
     if isinstance(t, DependentType):
         return True
-    elif any(is_dependent(subt) for subt in getattr(t, "__args__", ())):
+    elif any(is_dependent(subt) for subt in get_args(t)):
         return True
     return False
 
@@ -93,7 +90,7 @@ class DependentType(type):
         raise NotImplementedError()
 
     def codegen(self):
-        return CodeGen("{this}.check({arg})", {"this": self})
+        return CodeGen("{this}.check({arg})", this=self)
 
     def __type_order__(self, other):
         if isinstance(other, DependentType):
@@ -145,6 +142,11 @@ class ParametrizedDependentType(DependentType):
             self.default_bound(*parameters) if bound is None else bound
         )
         self.__args__ = self.parameters = parameters
+        self.__origin__ = None
+        self.__post_init__()
+
+    def __post_init__(self):
+        pass
 
     @property
     def parameter(self):
@@ -184,10 +186,7 @@ class ParametrizedDependentType(DependentType):
 
 class FuncDependentType(ParametrizedDependentType):
     def default_bound(self, *_):
-        fn = type(self).func
-        return normalize_type(
-            list(inspect.signature(fn).parameters.values())[0].annotation, fn
-        )
+        return self._default_bound
 
     def __lt__(self, other):
         if len(self.parameters) != len(other.parameters):
@@ -209,13 +208,40 @@ class FuncDependentType(ParametrizedDependentType):
 def dependent_check(fn=None, bound_is_name=False):
     if fn is None:
         return partial(dependent_check, bound_is_name=bound_is_name)
-    t = type(
-        fn.__name__,
-        (FuncDependentType,),
-        {"func": fn, "bound_is_name": bound_is_name},
-    )
-    if len(inspect.signature(fn).parameters) == 1:
-        t = t()
+
+    if isinstance(fn, type):
+        params = inspect.signature(fn.check).parameters
+        bound = normalize_type(
+            list(inspect.signature(fn.check).parameters.values())[1].annotation,
+            fn.check,
+        )
+        t = type(
+            fn.__name__,
+            (FuncDependentType,),
+            {
+                "bound_is_name": bound_is_name,
+                "_default_bound": bound,
+                **vars(fn),
+            },
+        )
+
+    else:
+        params = inspect.signature(fn).parameters
+        bound = normalize_type(
+            list(inspect.signature(fn).parameters.values())[0].annotation, fn
+        )
+        t = type(
+            fn.__name__,
+            (FuncDependentType,),
+            {
+                "func": fn,
+                "bound_is_name": bound_is_name,
+                "_default_bound": bound,
+            },
+        )
+        if len(params) == 1:
+            t = t()
+
     return t
 
 
@@ -237,9 +263,9 @@ class Equals(ParametrizedDependentType):
 
     def codegen(self):
         if len(self.parameters) == 1:
-            return CodeGen("({arg} == {p})", {"p": self.parameter})
+            return CodeGen("({arg} == {p})", p=self.parameter)
         else:
-            return CodeGen("({arg} in {ps})", {"ps": self.parameters})
+            return CodeGen("({arg} in {ps})", ps=self.parameters)
 
 
 class ProductType(ParametrizedDependentType):
@@ -327,8 +353,15 @@ def EndsWith(value: str, suffix):
 
 
 @dependent_check
-def Regexp(value: str, regexp):
-    return bool(re.search(pattern=regexp, string=value))
+class Regexp:
+    def __post_init__(self):
+        self.rx = re.compile(self.parameter)
+
+    def check(self, value: str):
+        return bool(self.rx.search(value))
+
+    def codegen(self):
+        return CodeGen("bool({rx}.search({arg}))", rx=self.rx)
 
 
 class Dependent:

ovld/mro.py

@@ -3,6 +3,8 @@ from enum import Enum
 from graphlib import TopologicalSorter
 from typing import get_args, get_origin
 
+from .utils import UnionTypes
+
 
 class Order(Enum):
     LESS = -1
@@ -121,6 +123,9 @@ def subclasscheck(t1, t2):
     ):
         return result
 
+    if t2 in UnionTypes:
+        return isinstance(t1, t2)
+
     o1 = get_origin(t1)
     o2 = get_origin(t2)
 

ovld/recode.py

@@ -1,14 +1,13 @@
 import ast
 import inspect
 import linecache
-import re
 import textwrap
 from ast import _splitlines_no_ff as splitlines
 from functools import reduce
 from itertools import count
 from types import CodeType, FunctionType
 
-from .utils import MISSING, Unusable, UsageError, subtler_type
+from .utils import MISSING, NameDatabase, Unusable, UsageError, subtler_type
 
 recurse = Unusable(
     "recurse() can only be used from inside an @ovld-registered function."
@@ -18,20 +17,8 @@ call_next = Unusable(
 )
 
 
-dispatch_template = """
-def __DISPATCH__(self, {args}):
-    {body}
-"""
-
-
-call_template = """
-method = self.map[({lookup})]
-return method({posargs})
-"""
-
-
 def instantiate_code(symbol, code, inject={}):
-    virtual_file = f"<ovld{hash(code)}>"
+    virtual_file = f"<ovld:{abs(hash(code)):x}>"
     linecache.cache[virtual_file] = (None, None, splitlines(code), virtual_file)
     code = compile(source=code, filename=virtual_file, mode="exec")
     glb = {**inject}
@@ -51,36 +38,22 @@ def instantiate_code(symbol, code, inject={}):
 #     return rval
 
 
-class NameDatabase:
-    def __init__(self, default_name):
-        self.default_name = default_name
-        self.count = count()
-        self.variables = {}
-        self.names = {}
-        self.registered = set()
-
-    def register(self, name):
-        self.registered.add(name)
-
-    def __getitem__(self, value):
-        if isinstance(value, (int, float, str)):
-            return repr(value)
-        if id(value) in self.names:
-            return self.names[id(value)]
-        name = orig_name = getattr(value, "__name__", self.default_name)
-        if not re.match(string=name, pattern=r"[a-zA-Z_][a-zA-Z0-9_]+"):
-            name = self.default_name
-        i = 1
-        while name in self.registered:
-            name = f"{orig_name}{i}"
-            i += 1
-        self.variables[name] = value
-        self.names[id(value)] = name
-        self.registered.add(name)
-        return name
-
-
-def generate_dispatch(arganal):
+dispatch_template = """
+def __WRAP_DISPATCH__(OVLD):
+    def __DISPATCH__({args}):
+        {body}
+
+    return __DISPATCH__
+"""
+
+
+call_template = """
+{mvar} = OVLD.map[({lookup})]
+return {mvar}({posargs})
+"""
+
+
+def generate_dispatch(ov, arganal):
     def join(li, sep=", ", trail=False):
         li = [x for x in li if x]
         rval = sep.join(li)
@@ -88,16 +61,23 @@ def generate_dispatch(arganal):
             rval += ","
         return rval
 
-    spr, spo, pr, po, kr, ko = arganal.compile()
+    arganal.compile()
+
+    spr = arganal.strict_positional_required
+    spo = arganal.strict_positional_optional
+    pr = arganal.positional_required
+    po = arganal.positional_optional
+    kr = arganal.keyword_required
+    ko = arganal.keyword_optional
 
     inits = set()
 
     kwargsstar = ""
     targsstar = ""
 
-    args = []
+    args = ["self" if arganal.is_method else ""]
     body = [""]
-    posargs = ["self.obj" if arganal.is_method else ""]
+    posargs = ["self" if arganal.is_method else ""]
     lookup = []
 
     i = 0
@@ -109,6 +89,8 @@ def generate_dispatch(arganal):
     for name in spr + spo + pr + po + kr:
         ndb.register(name)
 
+    mv = ndb.gensym(desired_name="method")
+
     for name in spr + spo:
         if name in spr:
             args.append(name)
@@ -118,7 +100,7 @@ def generate_dispatch(arganal):
         lookup.append(f"{lookup_for(i)}({name})")
         i += 1
 
-    if len(po) <= 1:
+    if len(po) <= 1 and (spr or spo):
         # If there are more than one non-strictly positional optional arguments,
         # then all positional arguments are strictly positional, because if e.g.
         # x and y are optional we want x==MISSING to imply that y==MISSING, but
@@ -161,6 +143,7 @@ def generate_dispatch(arganal):
     fullcall = call_template.format(
         lookup=join(lookup, trail=True),
         posargs=join(posargs),
+        mvar=mv,
     )
 
     calls = []
@@ -170,19 +153,21 @@ def generate_dispatch(arganal):
             call = call_template.format(
                 lookup=join(lookup[: req + i], trail=True),
                 posargs=join(posargs[: req + i + 1]),
+                mvar=mv,
             )
-            call = textwrap.indent(call, "    ")
+            call = textwrap.indent(call, "        ")
             calls.append(f"\nif {arg} is MISSING:{call}")
     calls.append(fullcall)
 
-    lines = [*inits, *body, textwrap.indent("".join(calls), "    ")]
+    lines = [*inits, *body, textwrap.indent("".join(calls), "        ")]
     code = dispatch_template.format(
         args=join(args),
-        body=join(lines, sep="\n    ").lstrip(),
+        body=join(lines, sep="\n        ").lstrip(),
     )
-    return instantiate_code(
-        "__DISPATCH__", code, inject={"MISSING": MISSING, **ndb.variables}
+    wr = instantiate_code(
+        "__WRAP_DISPATCH__", code, inject={"MISSING": MISSING, **ndb.variables}
     )
+    return wr(ov)
 
 
 def generate_dependent_dispatch(tup, handlers, next_call, slf, name, err, nerr):
@@ -252,6 +237,9 @@ def generate_dependent_dispatch(tup, handlers, next_call, slf, name, err, nerr):
             conj = "True"
         conjs.append(conj)
 
+    if len(handlers) == 1:
+        exclusive = True
+
     argspec = ", ".join(argname(x) for x in tup)
     argcall = ", ".join(argprovide(x) for x in tup)
 
@@ -380,12 +368,19 @@ def rename_function(fn, newname):
 
 class NameConverter(ast.NodeTransformer):
     def __init__(
-        self, anal, recurse_sym, call_next_sym, ovld_mangled, code_mangled
+        self,
+        anal,
+        recurse_sym,
+        call_next_sym,
+        ovld_mangled,
+        map_mangled,
+        code_mangled,
     ):
         self.analysis = anal
         self.recurse_sym = recurse_sym
         self.call_next_sym = call_next_sym
         self.ovld_mangled = ovld_mangled
+        self.map_mangled = map_mangled
         self.code_mangled = code_mangled
         self.count = count()
 
@@ -450,14 +445,7 @@ class NameConverter(ast.NodeTransformer):
         if cn:
             type_parts.insert(0, ast.Name(id=self.code_mangled, ctx=ast.Load()))
         method = ast.Subscript(
-            value=ast.NamedExpr(
-                target=ast.Name(id=f"{tmp}M", ctx=ast.Store()),
-                value=ast.Attribute(
-                    value=ast.Name(id=self.ovld_mangled, ctx=ast.Load()),
-                    attr="map",
-                    ctx=ast.Load(),
-                ),
-            ),
+            value=ast.Name(id=self.map_mangled, ctx=ast.Load()),
             slice=ast.Tuple(
                 elts=type_parts,
                 ctx=ast.Load(),
@@ -465,19 +453,14 @@ class NameConverter(ast.NodeTransformer):
             ctx=ast.Load(),
         )
         if self.analysis.is_method:
-            method = ast.Call(
-                func=ast.Attribute(
-                    value=method,
-                    attr="__get__",
-                    ctx=ast.Load(),
-                ),
-                args=[ast.Name(id="self", ctx=ast.Load())],
-                keywords=[],
-            )
+            selfarg = [ast.Name(id="self", ctx=ast.Load())]
+        else:
+            selfarg = []
 
         new_node = ast.Call(
             func=method,
-            args=[
+            args=selfarg
+            + [
                 ast.Name(id=f"{tmp}{i}", ctx=ast.Load())
                 for i, arg in enumerate(node.args)
             ],
@@ -510,7 +493,10 @@ def adapt_function(fn, ovld, newname):
     """Create a copy of the function with a different name."""
     rec_syms = list(
         _search_names(
-            fn.__code__, (recurse, ovld), fn.__globals__, fn.__closure__
+            fn.__code__,
+            (recurse, ovld, ovld.dispatch),
+            fn.__globals__,
+            fn.__closure__,
         )
     )
     cn_syms = list(
@@ -552,6 +538,7 @@ def closure_wrap(tree, fname, names):
 
 def recode(fn, ovld, recurse_sym, call_next_sym, newname):
     ovld_mangled = f"___OVLD{ovld.id}"
+    map_mangled = f"___MAP{ovld.id}"
     code_mangled = f"___CODE{next(_current)}"
     try:
         src = inspect.getsource(fn)
@@ -568,6 +555,7 @@ def recode(fn, ovld, recurse_sym, call_next_sym, newname):
         recurse_sym=recurse_sym,
         call_next_sym=call_next_sym,
         ovld_mangled=ovld_mangled,
+        map_mangled=map_mangled,
         code_mangled=code_mangled,
     ).visit(tree)
     new.body[0].decorator_list = []
@@ -592,6 +580,7 @@ def recode(fn, ovld, recurse_sym, call_next_sym, newname):
     new_fn.__annotations__ = fn.__annotations__
     new_fn = rename_function(new_fn, newname)
     new_fn.__globals__["__SUBTLER_TYPE"] = subtler_type
-    new_fn.__globals__[ovld_mangled] = ovld
+    new_fn.__globals__[ovld_mangled] = ovld.dispatch
+    new_fn.__globals__[map_mangled] = ovld.map
     new_fn.__globals__[code_mangled] = new_fn.__code__
     return new_fn

ovld/types.py

@@ -3,16 +3,18 @@ import sys
 import typing
 from dataclasses import dataclass
 from functools import partial
-from typing import Protocol, runtime_checkable
+from typing import Protocol, get_args, runtime_checkable
 
 from .mro import Order, TypeRelationship, subclasscheck, typeorder
 from .typemap import TypeMap
-from .utils import UsageError, clsstring
+from .utils import UnionType, UnionTypes, UsageError, clsstring
 
-try:
-    from types import UnionType
-except ImportError:  # pragma: no cover
-    UnionType = None
+
+def get_args(tp):
+    args = getattr(tp, "__args__", None)
+    if not isinstance(args, tuple):
+        args = ()
+    return args
 
 
 class TypeNormalizer:
@@ -37,6 +39,8 @@ class TypeNormalizer:
             t = object
         elif t is inspect._empty:
             t = object
+        elif t in UnionTypes:
+            return type[t]
         elif isinstance(t, typing._AnnotatedAlias):
             t = t.__origin__
 
@@ -82,7 +86,7 @@ class MetaMC(type):
         return super().__new__(T, name, (), {"_handler": handler})
 
     def __init__(cls, name, handler):
-        cls.__args__ = getattr(handler, "__args__", ())
+        cls.__args__ = get_args(handler)
 
     def codegen(cls):
         return cls._handler.codegen()

ovld/utils.py

@@ -1,7 +1,18 @@
 """Miscellaneous utilities."""
 
 import functools
+import re
 import typing
+from itertools import count
+
+try:
+    from types import UnionType
+
+    UnionTypes = (type(typing.Union[int, str]), UnionType)
+
+except ImportError:  # pragma: no cover
+    UnionType = None
+    UnionTypes = (type(typing.Union[int, str]),)
 
 
 class Named:
@@ -88,6 +99,8 @@ def clsstring(cls):
 def subtler_type(obj):
     if isinstance(obj, GenericAlias):
         return type[obj]
+    elif isinstance(obj, UnionTypes):
+        return type[obj]
     elif obj is typing.Any:
         return type[object]
     elif isinstance(obj, type):
@@ -96,6 +109,40 @@ def subtler_type(obj):
         return type(obj)
 
 
+class NameDatabase:
+    def __init__(self, default_name):
+        self.default_name = default_name
+        self.count = count()
+        self.variables = {}
+        self.names = {}
+        self.registered = set()
+
+    def register(self, name):
+        self.registered.add(name)
+
+    def gensym(self, desired_name):
+        i = 1
+        name = desired_name
+        while name in self.registered:
+            name = f"{desired_name}{i}"
+            i += 1
+        self.registered.add(name)
+        return name
+
+    def __getitem__(self, value):
+        if isinstance(value, (int, float, str)):
+            return repr(value)
+        if id(value) in self.names:
+            return self.names[id(value)]
+        name = getattr(value, "__name__", self.default_name)
+        if not re.match(string=name, pattern=r"[a-zA-Z_][a-zA-Z0-9_]+"):
+            name = self.default_name
+        name = self.gensym(name)
+        self.variables[name] = value
+        self.names[id(value)] = name
+        return name
+
+
 __all__ = [
     "BOOTSTRAP",
     "MISSING",

ovld/version.py

@@ -1 +1 @@
-version = "0.4.4"
+version = "0.4.6"

{ovld-0.4.4.dist-info → ovld-0.4.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ovld
-Version: 0.4.4
+Version: 0.4.6
 Summary: Overloading Python functions
 Project-URL: Homepage, https://ovld.readthedocs.io/en/latest/
 Project-URL: Documentation, https://ovld.readthedocs.io/en/latest/
@@ -201,16 +201,17 @@ assert Two().f("s") == "a string"
 
 # Benchmarks
 
-`ovld` is pretty fast: the overhead is comparable to `isinstance` or `match`, and only 2-3x slower when dispatching on `Literal` types. Compared to other multiple dispatch libraries, it is 1.5x to 100x faster.
+`ovld` is pretty fast: the overhead is comparable to `isinstance` or `match`, and only 2-3x slower when dispatching on `Literal` types. Compared to other multiple dispatch libraries, it has 1.5x to 100x less overhead.
 
 Time relative to the fastest implementation (1.00) (lower is better).
 
-| Bench | custom | [ovld](https://github.com/breuleux/ovld) | [plum](https://github.com/beartype/plum) | [multim](https://github.com/coady/multimethod) | [multid](https://github.com/mrocklin/multipledispatch/) | [runtype](https://github.com/erezsh/runtype) | [fastcore](https://github.com/fastai/fastcore) | [singled](https://docs.python.org/3/library/functools.html#functools.singledispatch) |
+| Benchmark | custom | [ovld](https://github.com/breuleux/ovld) | [plum](https://github.com/beartype/plum) | [multim](https://github.com/coady/multimethod) | [multid](https://github.com/mrocklin/multipledispatch/) | [runtype](https://github.com/erezsh/runtype) | [fastcore](https://github.com/fastai/fastcore) | [sd](https://docs.python.org/3/library/functools.html#functools.singledispatch) |
 | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
-|[trivial](https://github.com/breuleux/ovld/tree/master/benchmarks/test_trivial.py)|1.14|1.00|2.53|3.64|1.61|1.86|41.31|1.54|
-|[add](https://github.com/breuleux/ovld/tree/master/benchmarks/test_add.py)|1.01|1.00|3.46|4.83|2.21|2.66|56.08|x|
-|[multer](https://github.com/breuleux/ovld/tree/master/benchmarks/test_multer.py)|1.00|1.06|9.79|4.11|7.19|1.89|40.37|6.34|
-|[ast](https://github.com/breuleux/ovld/tree/master/benchmarks/test_ast.py)|1.00|1.06|23.07|3.04|1.68|1.87|29.11|1.63|
-|[calc](https://github.com/breuleux/ovld/tree/master/benchmarks/test_calc.py)|1.00|1.96|80.00|43.21|x|x|x|x|
-|[fib](https://github.com/breuleux/ovld/tree/master/benchmarks/test_fib.py)|1.00|3.58|438.97|123.58|x|x|x|x|
-|[tweak](https://github.com/breuleux/ovld/tree/master/benchmarks/test_tweaknum.py)|1.00|2.59|x|x|x|x|x|x|
+|[trivial](https://github.com/breuleux/ovld/tree/master/benchmarks/test_trivial.py)|1.45|1.00|3.32|4.63|2.04|2.41|51.93|1.91|
+|[multer](https://github.com/breuleux/ovld/tree/master/benchmarks/test_multer.py)|1.13|1.00|11.05|4.53|8.31|2.19|46.74|7.32|
+|[add](https://github.com/breuleux/ovld/tree/master/benchmarks/test_add.py)|1.08|1.00|3.73|5.21|2.37|2.79|59.31|x|
+|[ast](https://github.com/breuleux/ovld/tree/master/benchmarks/test_ast.py)|1.00|1.08|23.14|3.09|1.68|1.91|28.39|1.66|
+|[calc](https://github.com/breuleux/ovld/tree/master/benchmarks/test_calc.py)|1.00|1.23|54.61|29.32|x|x|x|x|
+|[regexp](https://github.com/breuleux/ovld/tree/master/benchmarks/test_regexp.py)|1.00|1.87|19.18|x|x|x|x|x|
+|[fib](https://github.com/breuleux/ovld/tree/master/benchmarks/test_fib.py)|1.00|3.30|444.31|125.77|x|x|x|x|
+|[tweaknum](https://github.com/breuleux/ovld/tree/master/benchmarks/test_tweaknum.py)|1.00|2.09|x|x|x|x|x|x|

ovld-0.4.6.dist-info/RECORD

@@ -0,0 +1,15 @@
+ovld/__init__.py,sha256=IVzs4_9skMa_UGZsGT7Ra_dIxj7KKNlV77XxlqcS6ow,1446
+ovld/abc.py,sha256=4qpZyYwI8dWgY1Oiv5FhdKg2uzNcyWxIpGmGJVcjXrs,1177
+ovld/core.py,sha256=MtRcJNhMwsix2Y7zP1fQS-taCy_t0bqkjHQdLF8WE8E,25719
+ovld/dependent.py,sha256=M85EJPRGNnEpmsr3tEX1U-1di1cxQb5-0oQtLgvfRoA,10183
+ovld/mro.py,sha256=D9KY3KEFnWL_SXZqHsVKNgRM1E0d8TPPILVZ3SxdUb4,4643
+ovld/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ovld/recode.py,sha256=bwsdM-TPpSQEmJhv8G30yDLrF8_I5wyTXpITMCC1W9k,17961
+ovld/typemap.py,sha256=PH5dy8ddVCcqj2TkQbgsM7fmCdHsJT9WGXFPn4JZsCA,13131
+ovld/types.py,sha256=lvOl1fldIqCJM-TvvdM2nMvAYDgcA45awfpkUB6kKpo,12984
+ovld/utils.py,sha256=k-cVMbJigtdeuD5_JEYtq1a6fXhmUGqLfBu8YxYd5VY,3395
+ovld/version.py,sha256=DWNNbWBv-hyqVy76bKbnHWaDUbqL0BOtdkPSV_88dx0,18
+ovld-0.4.6.dist-info/METADATA,sha256=mXEwvqopBdpksDEKETVZkp-airCb48yt4AWZIQ2r2wU,7833
+ovld-0.4.6.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+ovld-0.4.6.dist-info/licenses/LICENSE,sha256=cSwNTIzd1cbI89xt3PeZZYJP2y3j8Zus4bXgo4svpX8,1066
+ovld-0.4.6.dist-info/RECORD,,

ovld-0.4.4.dist-info/RECORD

@@ -1,14 +0,0 @@
-ovld/__init__.py,sha256=GEhOdG64GPUY5Y5BMnaik7UMgcq12mWVhxN9quIonYw,1476
-ovld/abc.py,sha256=4qpZyYwI8dWgY1Oiv5FhdKg2uzNcyWxIpGmGJVcjXrs,1177
-ovld/core.py,sha256=vzrYgUdagsQH6gbw32kzYzd-MvnCE3O9LjUyc-vVk1M,25366
-ovld/dependent.py,sha256=vvWjjOHNtw8PegZVDj1fRKpyp6SCg1WdOWoXNxZSVrk,9288
-ovld/mro.py,sha256=0cJK_v-POCiuwjluwf8fWeQ3G-2chEUv3KYe57GC61Q,4552
-ovld/recode.py,sha256=NWAM0qyOQqXgVCZxtmhtnkygWe-NV5FRwdXGtqikGTg,18494
-ovld/typemap.py,sha256=PH5dy8ddVCcqj2TkQbgsM7fmCdHsJT9WGXFPn4JZsCA,13131
-ovld/types.py,sha256=EZNv8pThbo47KBULYM3R0R3sM2C5LC4DWraXZImkiNs,12877
-ovld/utils.py,sha256=BsE7MmW5sfnO4Ym8hcEL8JNZZ1JIX_pgVRAAidh_8_w,2085
-ovld/version.py,sha256=Qk6wsgzl7cSMWWZ902odoQ-wBV5Fda2ShX82NN7uHzM,18
-ovld-0.4.4.dist-info/METADATA,sha256=wUsEDZyoQPooCN7P7q4MyObKAeSjg7DqpR-vRne5BW8,7713
-ovld-0.4.4.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-ovld-0.4.4.dist-info/licenses/LICENSE,sha256=cSwNTIzd1cbI89xt3PeZZYJP2y3j8Zus4bXgo4svpX8,1066
-ovld-0.4.4.dist-info/RECORD,,