ovld 0.4.4__tar.gz → 0.4.6__tar.gz

{ovld-0.4.4 → ovld-0.4.6}/.github/workflows/python-package.yml

@@ -40,6 +40,8 @@ jobs:
         - python: '3.11'
           coverage: false
         - python: '3.12'
+          coverage: false
+        - python: '3.13'
           coverage: true
     steps:
     - name: Check out the code
@@ -70,6 +72,7 @@ jobs:
         - python: '3.10'
         - python: '3.11'
         - python: '3.12'
+        - python: '3.13'
     steps:
     - name: Check out the code
       uses: actions/checkout@v3

ovld-0.4.6/.python-version

@@ -0,0 +1 @@
+3.13

{ovld-0.4.4 → ovld-0.4.6}/PKG-INFO

@@ -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.4 → ovld-0.4.6}/README.md

@@ -188,16 +188,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/beary.py

@@ -0,0 +1,120 @@
+import timeit
+from dataclasses import dataclass
+
+from beartype import (
+    BeartypeConf,  # <-- this isn't your fault
+    beartype,
+)
+from beartype.claw import (
+    beartype_all,
+)  # <-- you didn't sign up for this
+from strongtyping.strong_typing import match_typing
+from typeguard import typechecked
+
+# from enforce import runtime_validation
+from ovld import ovld
+
+# from ovld.check import typecheck
+
+beartype_all(conf=BeartypeConf())
+# beartype_this_package()                                        # <-- raise exceptions in your code
+# beartype_all(conf=BeartypeConf(violation_type=UserWarning))
+
+
+@beartype
+def f_bear(x: int, y: int):
+    return x + y
+
+
+@ovld
+def f_ovld(x: int, y: int):
+    return x + y
+
+
+@ovld
+def f_ovld_D(x: int, y: int):
+    # breakpoint()
+    return x + y
+
+
+@match_typing
+def f_strong(x: int, y: int):
+    return x + y
+
+
+@typechecked
+def f_guard(x: int, y: int):
+    return x + y
+
+
+# @runtime_validation
+# def f_enforce(x: int, y: int):
+#     return x + y
+
+
+def f_custom(x: int, y: int):
+    assert isinstance(x, int) and isinstance(y, int)
+    return x + y
+
+
+class digdug(dict):
+    pass
+
+
+def adder(x, y):
+    return x + y
+
+
+didi = digdug({int: adder})
+didi2 = digdug({(int, int): adder})
+
+
+@dataclass
+class Poop:
+    didi: dict
+
+
+poo2 = Poop(didi2)
+
+
+def f_custom_2(x: int, y: int):
+    assert didi2[type(x), type(y)]
+    return x + y
+
+
+# def f_custom_2(x: int, y: int):
+#     func = didi[type(x)] and didi[type(y)]
+#     return func(x, y)
+
+
+class Gusto:
+    def __init__(self, didi):
+        self.didi = didi
+        self.__name__ = "gusto"
+
+    def __call__(self, x: int, y: int):
+        func = self.didi[type(x), type(y)]
+        return func(x, y)
+
+
+# f_bear(7, 8)
+# f_ovld("a", 3)
+# assert f_ovld(3, 4) == 7
+
+
+for fn in (
+    f_bear,
+    f_strong,
+    f_guard,
+    f_ovld_D,
+    f_ovld,
+    f_custom,
+    f_custom_2,
+    Gusto(didi2),
+    Gusto(didi2).__call__,
+):
+    timing = timeit.timeit(stmt=lambda: fn(3, 4), number=300000)
+    print(f"{fn.__name__:10}{1000 * timing:>10.3f}ms")
+
+breakpoint()
+f_ovld(4, 5)

{ovld-0.4.4 → ovld-0.4.6}/bench.py

@@ -4,6 +4,7 @@ from multimethod import multimethod
 from multipledispatch import dispatch
 from plum import dispatch as plum
 
+# from strongtyping_pyoverload import overload
 from ovld import ovld, recurse
 
 # OVLD
@@ -157,6 +158,35 @@ def smap_pl(x: object, y: object):
     return x + y
 
 
+# # strongtyping
+
+
+# @overload
+# def smap_wh(x: list, y: list):
+#     """Three."""
+#     return [smap_wh(a, b) for a, b in zip(x, y)]
+
+
+# @overload
+# def smap_wh(x: tuple, y: tuple):
+#     return tuple(smap_wh(a, b) for a, b in zip(x, y))
+
+
+# @overload
+# def smap_wh(x: dict, y: dict):
+#     return {k: smap_wh(v, y[k]) for k, v in x.items()}
+
+
+# @overload
+# def smap_wh(x: object, y: object):
+#     return x + y
+
+
+# @overload
+# def smap_wh(x: str, y: str):
+#     return x + y
+
+
 ###
 
 
@@ -171,6 +201,7 @@ results = {
     "smap_ii": smap_ii(A, B),
     "smap_mh": smap_mh(A, B),
     "smap_c": smap_c(A, B),
+    # "smap_wh": smap_wh(A, B),
 }
 
 expected = results["smap"]
@@ -186,5 +217,6 @@ print("smap_md\t", 10 * timeit.timeit(lambda: smap_md(A, B), number=10000))
 print("smap_pl\t", 10 * timeit.timeit(lambda: smap_pl(A, B), number=10000))
 print("smap_ov\t", 10 * timeit.timeit(lambda: smap(A, B), number=10000))
 print("smap_c\t", 10 * timeit.timeit(lambda: smap_c(A, B), number=10000))
+# print("smap_wh\t", 10 * timeit.timeit(lambda: smap_wh(A, B), number=10000))
 print("smap_ii\t", 10 * timeit.timeit(lambda: smap_ii(A, B), number=10000))
 print("smap_mh\t", 10 * timeit.timeit(lambda: smap_mh(A, B), number=10000))

{ovld-0.4.4 → ovld-0.4.6}/benchmarks/test_calc.py

@@ -115,7 +115,7 @@ ops = {
 def calc_dict(expr):
     if isinstance(expr, tuple):
         return ops[expr[0]](*expr[1:])
-    elif isinstance(expr, (int, float)):
+    elif isinstance(expr, Number):
         return expr
 
 

{ovld-0.4.4 → ovld-0.4.6}/benchmarks/test_multer.py

@@ -148,7 +148,7 @@ def make_test(cls):
 
 
 test_multer_ovld = make_test(make_multer(ovld_dispatch))
-test_multer_ovld_recurse = make_test(OvldRecurseMulter)
+test_multer_recurse = make_test(OvldRecurseMulter)
 test_multer_plum = make_test(make_multer(plum_dispatch))
 test_multer_multimethod = make_test(make_multer(multimethod_dispatch))
 test_multer_singledispatch = make_test(SingleDispatchMulter)

ovld-0.4.6/benchmarks/test_regexp.py

@@ -0,0 +1,96 @@
+import re
+
+import pytest
+
+from ovld.dependent import Regexp
+
+from .common import ovld_dispatch, plum_dispatch
+
+###############################
+# multiple dispatch libraries #
+###############################
+
+
+def make_regexp(dispatch):
+    @dispatch
+    def regexp(x: Regexp[r"^a"]):
+        return "one"
+
+    @dispatch
+    def regexp(x: Regexp[r"^[bcd]"]):
+        return "two"
+
+    @dispatch
+    def regexp(x: Regexp[r"end$"]):
+        return "three"
+
+    return regexp
+
+
+##############
+# isinstance #
+##############
+
+
+def regexp_search(x):
+    if re.search(string=x, pattern=r"^a"):
+        return "one"
+    if re.search(string=x, pattern=r"^[bcd]"):
+        return "two"
+    if re.search(string=x, pattern=r"end$"):
+        return "three"
+
+
+re1 = re.compile(r"^a")
+re2 = re.compile(r"^[bcd]")
+re3 = re.compile(r"end$")
+
+
+def regexp_compiled(x):
+    if re1.search(x):
+        return "one"
+    if re2.search(x):
+        return "two"
+    if re3.search(x):
+        return "three"
+
+
+def regexp_compiled_nonexclusive(x):
+    r1 = bool(re1.search(x))
+    r2 = bool(re2.search(x))
+    r3 = bool(re3.search(x))
+    if r1:
+        return "one"
+    if r2:
+        return "two"
+    if r3:
+        return "three"
+
+
+####################
+# Test definitions #
+####################
+
+
+def make_test(fn):
+    @pytest.mark.benchmark(group="regexp")
+    def test(benchmark):
+        def run():
+            return [
+                fn("allo"),
+                fn("canada"),
+                fn("the end"),
+            ]
+
+        result = benchmark(run)
+        assert result == ["one", "two", "three"]
+
+    return test
+
+
+test_regexp_ovld = make_test(make_regexp(ovld_dispatch))
+test_regexp_plum = make_test(make_regexp(plum_dispatch))
+
+test_regexp_custom_search = make_test(regexp_search)
+test_regexp_custom_compiled = make_test(regexp_compiled)
+# test_regexp_custom_compiled_nx = make_test(regexp_compiled_nonexclusive)

{ovld-0.4.4 → ovld-0.4.6}/benchmarks/test_tuple.py

@@ -62,6 +62,9 @@ def tup_match(expr):
 
 
 def make_test(fn):
+    fn(())
+    fn = fn.__call__
+
     def run():
         return [fn(()), fn((1,)), fn(("x",)), fn((2, "y"))]
 

ovld-0.4.6/benchmarks/test_typechecking.py

@@ -0,0 +1,160 @@
+# from collections.abc import Collection
+# from dataclasses import dataclass
+# from itertools import product
+# from numbers import Number
+# from typing import Literal
+
+# import pytest
+# from beartype import beartype
+
+# try:
+#     from strongtyping.strong_typing import match_typing
+# except ImportError:
+#     match_typing = None
+# from typeguard import typechecked
+
+# from ovld import Ovld, ovld
+# from ovld.dependent import Dependent, Regexp
+# from ovld.types import Dataclass
+
+
+# @dataclass
+# class Point:
+#     x: int
+#     y: int
+
+
+# def ovld(fn):
+#     o = Ovld()
+#     o.register(fn)
+#     return o.dispatch
+
+
+# def typecheck_test(cases, checkers):
+#     def deco(fn):
+#         def make_test(chk_name, case_name, typecheck, params):
+#             group = f"{fn.__name__}_{case_name}"
+
+#             @pytest.mark.benchmark(group=group)
+#             def test(benchmark):
+#                 *args, out = params
+#                 tfn = typecheck(fn)
+#                 result = benchmark(tfn, *args)
+#                 assert result == out
+
+#             test.__name__ = f"test_{group}[{chk_name}]"
+#             globals()[test.__name__] = test
+
+#         for (case_name, case), (chk_name, chk) in product(
+#             cases.items(), checkers.items()
+#         ):
+#             if chk is not None:
+#                 make_test(chk_name, case_name, chk, case)
+
+#     return deco
+
+
+# @typecheck_test(
+#     cases=dict(normal=(10, 20, 200)),
+#     checkers=dict(
+#         ovld=ovld,
+#         beartype=beartype,
+#         typeguard=typechecked,
+#         strongtyping=match_typing,
+#     ),
+# )
+# def mul(x: int, y: int):
+#     return x * y
+
+
+# @typecheck_test(
+#     cases=dict(
+#         ints=(10, 20, 30),
+#         lists=([1], [2], [1, 2]),
+#     ),
+#     checkers=dict(
+#         ovld=ovld,
+#         beartype=beartype,
+#         typeguard=typechecked,
+#         strongtyping=match_typing,
+#     ),
+# )
+# def add(x: int | str | float | list, y: int | str | float | list):
+#     return x + y
+
+
+# @typecheck_test(
+#     cases=dict(
+#         normal=("http://google.com", "google.com"),
+#     ),
+#     checkers=dict(
+#         ovld=ovld,
+#         beartype=beartype,
+#         # typeguard=typechecked,
+#         # strongtyping=match_typing,
+#     ),
+# )
+# def urlregexp(url: Regexp[r"^http://.*"]):
+#     return url.split("://")[1]
+
+
+# @typecheck_test(
+#     cases=dict(
+#         normal=([1, 2, 3], 1),
+#     ),
+#     checkers=dict(
+#         ovld=ovld,
+#         beartype=beartype,
+#         typeguard=typechecked,
+#         strongtyping=match_typing,
+#     ),
+# )
+# def firstelem(elements: list[int]):
+#     return elements[0]
+
+
+# @typecheck_test(
+#     cases=dict(
+#         normal=(123, Point(1, 2), "low", "whatever"),
+#     ),
+#     checkers=dict(
+#         ovld=ovld,
+#         beartype=beartype,
+#         typeguard=typechecked,
+#         strongtyping=match_typing,
+#     ),
+# )
+# def misc(
+#     numero: Number, dc: Dataclass, method: Literal["low"] | Literal["high"]
+# ):
+#     return "whatever"
+
+
+# @typecheck_test(
+#     cases=dict(
+#         normal=(10, 11),
+#     ),
+#     checkers=dict(
+#         ovld=ovld,
+#         beartype=beartype,
+#         # typeguard=typechecked,
+#         # strongtyping=match_typing,
+#     ),
+# )
+# def positive(x: Dependent[int, lambda x: x > 0]):
+#     return x + 1
+
+
+# @typecheck_test(
+#     cases=dict(
+#         normal=((1, Point(2, 3), "blah"), ("blah", Point(2, 3), 1)),
+#     ),
+#     checkers=dict(
+#         ovld=ovld,
+#         beartype=beartype,
+#         typeguard=typechecked,
+#         strongtyping=match_typing,
+#     ),
+# )
+# def triple(xyz: tuple[Number, Dataclass, Collection]):
+#     return tuple(reversed(xyz))

{ovld-0.4.4 → ovld-0.4.6}/docs/compare.md

@@ -3,7 +3,7 @@
 
 ## Unique features
 
-Current as of September 2024: I have investigated and benchmarked six other multiple/single dispatch libraries. Performance-wise, `ovld` is faster than all of them, ranging from 1.5x faster to 100x faster. Feature-wise, `ovld` is among the most featureful. Some features I could not find elsewhere:
+Current as of October 2024: I have investigated and benchmarked six other multiple/single dispatch libraries. Performance-wise, `ovld` is faster than all of them, ranging from 1.5x to 100x less overhead. Feature-wise, `ovld` is among the most featureful. Some features I could not find elsewhere:
 
 * Support for [keyword arguments](usage.md#keyword-arguments).
 * [Variants](usage.md#variants), especially working with recursion.
@@ -27,10 +27,11 @@ Current as of September 2024: I have investigated and benchmarked six other mult
 Applicable libraries were tested on the following problems:
 
 * [trivial](https://github.com/breuleux/ovld/tree/master/benchmarks/test_trivial.py): Basic single dispatch test with a bunch of types.
-* [add](https://github.com/breuleux/ovld/tree/master/benchmarks/test_add.py): Recursively add lists and dictionaries element-wise.
 * [multer](https://github.com/breuleux/ovld/tree/master/benchmarks/test_multer.py): Recursively multiply lists and dictionaries element-wise by a number, but using a class. This tests dispatch on methods.
+* [add](https://github.com/breuleux/ovld/tree/master/benchmarks/test_add.py): Recursively add lists and dictionaries element-wise.
 * [ast](https://github.com/breuleux/ovld/tree/master/benchmarks/test_ast.py): Simple transform on a Python AST.
 * [calc](https://github.com/breuleux/ovld/tree/master/benchmarks/test_calc.py): Calculator implementation. Dispatches using `op: Literal[<opname>]`.
+* [regexp](https://github.com/breuleux/ovld/tree/master/benchmarks/test_regexp.py): Dispatch based on a regular expression (`ovld.dependent.Regexp[<regex>]`).
 * [fib](https://github.com/breuleux/ovld/tree/master/benchmarks/test_fib.py): Fibonacci numbers. The base cases are implemented by dispatching on `n: Literal[0]` and `n: Literal[1]`.
 * [tweaknum](https://github.com/breuleux/ovld/tree/master/benchmarks/test_tweaknum.py): Dispatching on keyword arguments.
 
@@ -39,21 +40,21 @@ Applicable libraries were tested on the following problems:
 
 Time relative to the fastest implementation (1.00) (lower is better). Python version: 3.12.4
 
-The **custom** column represents custom implementations using isinstance, match, a dispatch dict, etc. They are usually the fastest, but that should not be surprising. ovld's performance ranges from 1.1x faster to 3.7x slower.
+The **custom** column represents custom implementations using isinstance, match, a dispatch dict, etc. They are usually the fastest, but that should not be surprising. ovld's performance ranges from 1.5x faster to 3.3x slower.
 
-| 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|
 
 ## Comments
 
 A big part of ovld's advantage comes from generating custom dispatch methods depending on the set of signatures that were registered. If you can avoid looping over `*args`, you're basically halving your overhead. Regarding dispatch on `Literal`, ovld also generates custom dispatch methods that unroll a series of specific if/else statements, which is the only way you'll ever get spitting distance from a normal implementation.
 
-I haven't benchmarked the overhead of registering and compiling the methods, nor cache miss resolves, but... yeah... I expect ovld will do pretty badly in that regard. That'll be the next big push, probably.
+I haven't benchmarked the overhead of registering and compiling the methods, nor cache miss resolves, but I expect ovld will do pretty badly in that regard. That'll be the next big push, probably.

{ovld-0.4.4 → ovld-0.4.6}/gen_comparison_table.py

@@ -2,7 +2,7 @@ import json
 from collections import defaultdict
 from pathlib import Path
 
-file = Path(".benchmarks/Darwin-CPython-3.12-64bit/0011_report.json")
+file = Path(".benchmarks/Darwin-CPython-3.12-64bit/0019_report.json")
 data = json.loads(file.read_text())
 
 
@@ -35,7 +35,16 @@ columns = [
         "https://docs.python.org/3/library/functools.html#functools.singledispatch",
     ],
 ]
-bench_names = ["trivial", "add", "multer", "ast", "calc", "fib", "tweaknum"]
+bench_names = [
+    "trivial",
+    "multer",
+    "add",
+    "ast",
+    "calc",
+    "regexp",
+    "fib",
+    "tweaknum",
+]
 
 
 template = "https://github.com/breuleux/ovld/tree/master/benchmarks/test_{}.py"
@@ -52,6 +61,7 @@ for name in bench_names:
         min(bench["stats"]["median"] for bench in benches)
         for cat, benches in group.items()
         # if cat != "custom"
+        if cat != "recurse"
     )
     loc = template.format(name)
     line = [f"[{name}]({loc})"]