ovld 0.4.3__py3-none-any.whl → 0.4.5__py3-none-any.whl

ovld/types.py

@@ -2,11 +2,12 @@ import inspect
 import sys
 import typing
 from dataclasses import dataclass
+from functools import partial
 from typing import Protocol, runtime_checkable
 
-from ovld.utils import UsageError
-
 from .mro import Order, TypeRelationship, subclasscheck, typeorder
+from .typemap import TypeMap
+from .utils import UsageError, clsstring
 
 try:
     from types import UnionType
@@ -14,62 +15,129 @@ except ImportError:  # pragma: no cover
     UnionType = None
 
 
-def normalize_type(t, fn):
-    from .dependent import DependentType, Equals
-
-    if isinstance(t, str):
-        t = eval(t, getattr(fn, "__globals__", {}))
-
-    if t is type:
-        t = type[object]
-    elif t is typing.Any:
-        t = object
-    elif t is inspect._empty:
-        t = object
-    elif isinstance(t, typing._AnnotatedAlias):
-        t = t.__origin__
-
-    origin = getattr(t, "__origin__", None)
-    if UnionType and isinstance(t, UnionType):
-        return normalize_type(t.__args__, fn)
-    elif origin is type:
-        return t
-    elif origin is typing.Union:
-        return normalize_type(t.__args__, fn)
-    elif origin is typing.Literal:
-        return Equals(*t.__args__)
-    elif origin and not getattr(t, "__args__", None):
-        return t
-    elif origin is not None:
-        raise TypeError(
-            f"ovld does not accept generic types except type, Union, Optional, Literal, but not: {t}"
-        )
-    elif isinstance(t, tuple):
-        return typing.Union[tuple(normalize_type(t2, fn) for t2 in t)]
-    elif isinstance(t, DependentType) and not t.bound:
-        raise UsageError(
-            f"Dependent type {t} has not been given a type bound. Please use Dependent[<bound>, {t}] instead."
-        )
-    else:
-        return t
+class TypeNormalizer:
+    def __init__(self, generic_handlers=None):
+        self.generic_handlers = generic_handlers or TypeMap()
+
+    def register_generic(self, generic, handler=None):
+        if handler is None:
+            return partial(self.register_generic, generic)
+        else:
+            self.generic_handlers.register(generic, handler)
+
+    def __call__(self, t, fn):
+        from .dependent import DependentType
+
+        if isinstance(t, str):
+            t = eval(t, getattr(fn, "__globals__", {}))
+
+        if t is type:
+            t = type[object]
+        elif t is typing.Any:
+            t = object
+        elif t is inspect._empty:
+            t = object
+        elif isinstance(t, typing._AnnotatedAlias):
+            t = t.__origin__
+
+        origin = getattr(t, "__origin__", None)
+        if UnionType and isinstance(t, UnionType):
+            return self(t.__args__, fn)
+        elif origin is type:
+            return t
+        elif origin and getattr(t, "__args__", None) is None:
+            return t
+        elif origin is not None:
+            try:
+                results = self.generic_handlers[origin]
+                results = list(results.items())
+                results.sort(key=lambda x: x[1], reverse=True)
+                assert results
+                rval = results[0][0](self, t, fn)
+                if isinstance(origin, type) and hasattr(rval, "with_bound"):
+                    rval = rval.with_bound(origin)
+                return rval
+            except KeyError:  # pragma: no cover
+                raise TypeError(f"ovld does not understand generic type {t}")
+        elif isinstance(t, tuple):
+            return Union[tuple(self(t2, fn) for t2 in t)]
+        elif isinstance(t, DependentType) and not t.bound:
+            raise UsageError(
+                f"Dependent type {t} has not been given a type bound. Please use Dependent[<bound>, {t}] instead."
+            )
+        else:
+            return t
+
+
+normalize_type = TypeNormalizer()
+
+
+@normalize_type.register_generic(typing.Union)
+def _(self, t, fn):
+    return self(t.__args__, fn)
 
 
 class MetaMC(type):
-    def __new__(T, name, order):
-        return super().__new__(T, name, (), {"order": order})
+    def __new__(T, name, handler):
+        return super().__new__(T, name, (), {"_handler": handler})
+
+    def __init__(cls, name, handler):
+        cls.__args__ = getattr(handler, "__args__", ())
 
-    def __init__(cls, name, order):
-        pass
+    def codegen(cls):
+        return cls._handler.codegen()
 
     def __type_order__(cls, other):
-        results = cls.order(other)
+        return cls._handler.__type_order__(other)
+
+    def __is_supertype__(cls, other):
+        return cls._handler.__is_supertype__(other)
+
+    def __is_subtype__(cls, other):  # pragma: no cover
+        return cls._handler.__is_subtype__(other)
+
+    def __subclasscheck__(cls, sub):
+        return cls._handler.__subclasscheck__(sub)
+
+    def __instancecheck__(cls, obj):
+        return cls._handler.__instancecheck__(obj)
+
+    def __eq__(cls, other):
+        return (
+            type(cls) is type(other)
+            and type(cls._handler) is type(other._handler)
+            and cls._handler == other._handler
+        )
+
+    def __hash__(cls):
+        return hash(cls._handler)
+
+    def __and__(cls, other):
+        return Intersection[cls, other]
+
+    def __rand__(cls, other):
+        return Intersection[other, cls]
+
+    def __str__(self):
+        return str(self._handler)
+
+    __repr__ = __str__
+
+
+class SingleFunctionHandler:
+    def __init__(self, handler, args):
+        self.handler = handler
+        self.args = self.__args__ = args
+
+    def __type_order__(self, other):
+        results = self.handler(other, *self.args)
         if isinstance(results, TypeRelationship):
             return results.order
         else:
             return NotImplemented
 
-    def __is_supertype__(cls, other):
-        results = cls.order(other)
+    def __is_supertype__(self, other):
+        results = self.handler(other, *self.args)
         if isinstance(results, bool):
             return results
         elif isinstance(results, TypeRelationship):
@@ -77,15 +145,22 @@ class MetaMC(type):
         else:  # pragma: no cover
             return NotImplemented
 
-    def __is_subtype__(cls, other):
-        results = cls.order(other)
+    def __is_subtype__(self, other):  # pragma: no cover
+        results = self.handler(other, *self.args)
         if isinstance(results, TypeRelationship):
             return results.subtype
-        else:  # pragma: no cover
+        else:
             return NotImplemented
 
-    def __subclasscheck__(cls, sub):
-        return cls.__is_supertype__(sub)
+    def __subclasscheck__(self, sub):
+        return self.__is_supertype__(sub)
+
+    def __instancecheck__(self, obj):
+        return issubclass(type(obj), self)
+
+    def __str__(self):
+        args = ", ".join(map(clsstring, self.__args__))
+        return f"{self.handler.__name__}[{args}]"
 
 
 def class_check(condition):
@@ -99,7 +174,7 @@ def class_check(condition):
         condition: A function that takes a class as an argument and returns
             True or False depending on whether it matches some condition.
     """
-    return MetaMC(condition.__name__, condition)
+    return MetaMC(condition.__name__, SingleFunctionHandler(condition, ()))
 
 
 def parametrized_class_check(fn):
@@ -118,14 +193,10 @@ def parametrized_class_check(fn):
             if not isinstance(arg, tuple):
                 arg = (arg,)
 
-            def arg_to_str(x):
-                if isinstance(x, type):
-                    return x.__name__
-                else:
-                    return repr(x)
-
-            name = f"{fn.__name__}[{', '.join(map(arg_to_str, arg))}]"
-            return MetaMC(name, lambda sub: fn(sub, *arg))
+            if isinstance(fn, type):
+                return MetaMC(fn.__name__, fn(*arg))
+            else:
+                return MetaMC(fn.__name__, SingleFunctionHandler(fn, arg))
 
     _C.__name__ = fn.__name__
     _C.__qualname__ = fn.__qualname__
@@ -140,6 +211,56 @@ def _getcls(ref):
     return curr
 
 
+class AllMC(type):
+    def __type_order__(self, other):
+        return Order.MORE
+
+    def __is_subtype__(self, other):
+        return True
+
+    def __is_supertype__(self, other):
+        return False
+
+    def __subclasscheck__(self, other):  # pragma: no cover
+        return False
+
+    def __isinstance__(self, other):  # pragma: no cover
+        return False
+
+
+class All(metaclass=AllMC):
+    """All is the empty/void/bottom type -- it acts as a subtype of all types.
+
+    It is basically the opposite of Any: nothing is an instance of All. The main
+    place you want to use All is as a wildcard in contravariant settings, e.g.
+    all 2-argument functions are instances of Callable[[All, All], Any] because
+    the arguments are contravariant.
+    """
+
+
+class WhateverMC(AllMC):
+    def __is_supertype__(self, other):
+        return True
+
+    def __subclasscheck__(self, other):  # pragma: no cover
+        return True
+
+    def __isinstance__(self, other):  # pragma: no cover
+        return True
+
+
+class Whatever(metaclass=WhateverMC):
+    """This type is a superclass and a subclass of everything.
+
+    It's not a coherent type, more like a convenience.
+
+    It'll match anything anywhere, so you can write e.g.
+    Callable[[Whatever, Whatever], Whatever] to match any function of
+    two arguments. Any only works in covariant settings, and All only
+    works in contravariant settings.
+    """
+
+
 class Deferred:
     """Represent a class from an external module without importing it.
 
@@ -168,7 +289,7 @@ class Deferred:
             else:
                 return False
 
-        return MetaMC(f"Deferred[{ref}]", check)
+        return MetaMC(f"Deferred[{ref}]", SingleFunctionHandler(check, ()))
 
 
 @parametrized_class_check
@@ -191,16 +312,105 @@ def StrictSubclass(cls, base_cls):
 
 
 @parametrized_class_check
-def Intersection(cls, *classes):
-    """Match all classes."""
-    matches = all(subclasscheck(cls, t) for t in classes)
-    compare = [x for t in classes if (x := typeorder(t, cls)) is not Order.NONE]
-    if not compare:
-        return TypeRelationship(Order.NONE, supertype=matches)
-    elif any(x is Order.LESS or x is Order.SAME for x in compare):
-        return TypeRelationship(Order.LESS, supertype=matches)
-    else:
-        return TypeRelationship(Order.MORE, supertype=matches)
+class Union:
+    def __init__(self, *types):
+        self.__args__ = self.types = types
+
+    def codegen(self):
+        from .dependent import combine, generate_checking_code
+
+        template = " or ".join("{}" for t in self.types)
+        return combine(
+            template, [generate_checking_code(t) for t in self.types]
+        )
+
+    def __type_order__(self, other):
+        if other is Union:
+            return Order.LESS
+        classes = self.types
+        compare = [
+            x for t in classes if (x := typeorder(t, other)) is not Order.NONE
+        ]
+        if not compare:
+            return Order.NONE
+        elif any(x is Order.MORE or x is Order.SAME for x in compare):
+            return Order.MORE
+        else:
+            return Order.LESS
+
+    def __is_supertype__(self, other):
+        return any(subclasscheck(other, t) for t in self.types)
+
+    def __is_subtype__(self, other):
+        if other is Union:
+            return True
+        return NotImplemented  # pragma: no cover
+
+    def __subclasscheck__(self, sub):
+        return self.__is_supertype__(sub)
+
+    def __instancecheck__(self, obj):
+        return any(isinstance(obj, t) for t in self.types)
+
+    def __eq__(self, other):
+        return self.__args__ == other.__args__
+
+    def __hash__(self):
+        return hash(self.__args__)
+
+    def __str__(self):
+        return " | ".join(map(clsstring, self.__args__))
+
+
+@parametrized_class_check
+class Intersection:
+    def __init__(self, *types):
+        self.__args__ = self.types = types
+
+    def codegen(self):
+        from .dependent import combine, generate_checking_code
+
+        template = " and ".join("{}" for t in self.types)
+        return combine(
+            template, [generate_checking_code(t) for t in self.types]
+        )
+
+    def __type_order__(self, other):
+        if other is Intersection:
+            return Order.LESS
+        classes = self.types
+        compare = [
+            x for t in classes if (x := typeorder(t, other)) is not Order.NONE
+        ]
+        if not compare:
+            return Order.NONE
+        elif any(x is Order.LESS or x is Order.SAME for x in compare):
+            return Order.LESS
+        else:
+            return Order.MORE
+
+    def __is_supertype__(self, other):
+        return all(subclasscheck(other, t) for t in self.types)
+
+    def __is_subtype__(self, other):  # pragma: no cover
+        if other is Intersection:
+            return True
+        return NotImplemented
+
+    def __subclasscheck__(self, sub):
+        return self.__is_supertype__(sub)
+
+    def __instancecheck__(self, obj):
+        return all(isinstance(obj, t) for t in self.types)
+
+    def __eq__(self, other):
+        return self.__args__ == other.__args__
+
+    def __hash__(self):
+        return hash(self.__args__)
+
+    def __str__(self):
+        return " & ".join(map(clsstring, self.__args__))
 
 
 @parametrized_class_check

ovld/utils.py

@@ -1,6 +1,9 @@
 """Miscellaneous utilities."""
 
 import functools
+import re
+import typing
+from itertools import count
 
 
 class Named:
@@ -60,6 +63,75 @@ class Unusable:
         raise UsageError(self.__message)
 
 
+class GenericAliasMC(type):
+    def __instancecheck__(cls, obj):
+        return hasattr(obj, "__origin__")
+
+
+class GenericAlias(metaclass=GenericAliasMC):
+    pass
+
+
+def clsstring(cls):
+    if cls is object:
+        return "*"
+    elif args := typing.get_args(cls):
+        origin = typing.get_origin(cls) or cls
+        args = ", ".join(map(clsstring, args))
+        return f"{origin.__name__}[{args}]"
+    else:
+        r = repr(cls)
+        if r.startswith("<class "):
+            return cls.__name__
+        else:
+            return r
+
+
+def subtler_type(obj):
+    if isinstance(obj, GenericAlias):
+        return type[obj]
+    elif obj is typing.Any:
+        return type[object]
+    elif isinstance(obj, type):
+        return type[obj]
+    else:
+        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.3"
+version = "0.4.5"

{ovld-0.4.3.dist-info → ovld-0.4.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ovld
-Version: 0.4.3
+Version: 0.4.5
 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.5.dist-info/RECORD

@@ -0,0 +1,14 @@
+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=nyrkkmgxGjcHnZjKqbk7_g4_D91SYfYTPIE32LOvC9o,10184
+ovld/mro.py,sha256=0cJK_v-POCiuwjluwf8fWeQ3G-2chEUv3KYe57GC61Q,4552
+ovld/recode.py,sha256=bwsdM-TPpSQEmJhv8G30yDLrF8_I5wyTXpITMCC1W9k,17961
+ovld/typemap.py,sha256=PH5dy8ddVCcqj2TkQbgsM7fmCdHsJT9WGXFPn4JZsCA,13131
+ovld/types.py,sha256=EZNv8pThbo47KBULYM3R0R3sM2C5LC4DWraXZImkiNs,12877
+ovld/utils.py,sha256=jrrG_BqjI3W7x285nLuYiy5ui9LbNltblFVTlOWHYiU,3123
+ovld/version.py,sha256=GzDw9yI90LiIOYlw5gZBih8gPe3URgiM0vAFi2-I3ro,18
+ovld-0.4.5.dist-info/METADATA,sha256=AM7DiTgyU53Z0A7s8MIJJ3t1rgk1pxf3uqPU20kVO6o,7833
+ovld-0.4.5.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+ovld-0.4.5.dist-info/licenses/LICENSE,sha256=cSwNTIzd1cbI89xt3PeZZYJP2y3j8Zus4bXgo4svpX8,1066
+ovld-0.4.5.dist-info/RECORD,,

ovld-0.4.3.dist-info/RECORD

@@ -1,13 +0,0 @@
-ovld/__init__.py,sha256=_MJizMQ-Ise8c53GCsC7f-MOhp-qcUd0bpvu8LUFp8M,1444
-ovld/core.py,sha256=glexOiRU0ajoxFAQN6d69ToL6_cPvyv05Z7LEHqrJj8,25701
-ovld/dependent.py,sha256=HZbn2uU1uby9D-5qmDSjwdUpIJPdBXYrCW82lpTrBS4,7289
-ovld/mro.py,sha256=eNU8rMG3hVOA1h7cd2lo4mmXQQbAGI5ISERllOO8_Js,5598
-ovld/recode.py,sha256=zxhyotuc73qzuN4NEN_rKxaqoA0SOH7KFtE2l_CRBFs,17963
-ovld/typemap.py,sha256=gw8XvB-N_15Dr0-am0v17x1seNjYK5AxvUT9L36mWic,13630
-ovld/types.py,sha256=zR5_W3iFZb5LfktjrGfCMa1-eAwlF-AyBeTwAX3JayU,6795
-ovld/utils.py,sha256=V6Y8oZ6ojq8JaODL1rMZbU5L9QG0YSqHNYmpIFiwy3M,1294
-ovld/version.py,sha256=qGkDKQTrLXZ0o-aafthub4OFvdwOI_7GN29zXzZj8zg,18
-ovld-0.4.3.dist-info/METADATA,sha256=JxkPMmizv16TxE_gBQKClp29o8d_10FgFYsPVQ2Tvf0,7713
-ovld-0.4.3.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-ovld-0.4.3.dist-info/licenses/LICENSE,sha256=cSwNTIzd1cbI89xt3PeZZYJP2y3j8Zus4bXgo4svpX8,1066
-ovld-0.4.3.dist-info/RECORD,,