ovld 0.4.6__tar.gz → 0.5.0__tar.gz

ovld-0.5.0/.github/workflows/publish.yml

@@ -0,0 +1,47 @@
+name: Publish
+on:
+  push:
+    tags:
+      - v**
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.x"
+    - name: Set up uv
+      uses: hynek/setup-cached-uv@v2
+      with:
+        cache-dependency-path: uv.lock
+    - name: Build
+      run: uvx hatch build
+    - name: Store the distribution packages
+      uses: actions/upload-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+  publish-to-pypi:
+    name: >-
+      Publish to PyPI
+    needs:
+    - build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: "https://pypi.org/p/${{ github.event.repository.name }}"
+    permissions:
+      id-token: write
+    steps:
+    - name: Download all the dists
+      uses: actions/download-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+    - name: Publish
+      uses: pypa/gh-action-pypi-publish@release/v1

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

@@ -83,6 +83,6 @@ jobs:
     - name: Pin Python version
       run: uv python pin ${{ matrix.settings.python }}
     - name: Sync dependencies
-      run: uv sync
+      run: uv sync --group benchmark
     - name: Run benchmarks
       run: uv run pytest benchmarks/

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: ovld
-Version: 0.4.6
+Version: 0.5.0
 Summary: Overloading Python functions
 Project-URL: Homepage, https://ovld.readthedocs.io/en/latest/
 Project-URL: Documentation, https://ovld.readthedocs.io/en/latest/
@@ -20,10 +20,11 @@ Fast multiple dispatch in Python, with many extra features.
 
 With ovld, you can write a version of the same function for every type signature using annotations instead of writing an awkward sequence of `isinstance` statements. Unlike Python's `singledispatch`, it works for multiple arguments.
 
-* ⚡️ **[Fast](https://ovld.readthedocs.io/en/latest/compare/#results):** `ovld` is the fastest multiple dispatch library around, by some margin.
-* 🚀 [**Variants**](https://ovld.readthedocs.io/en/latest/usage/#variants) and [**mixins**](https://ovld.readthedocs.io/en/latest/usage/#mixins) of functions and methods.
+* ⚡️ **[Fast](https://ovld.readthedocs.io/en/latest/compare/#results):** ovld is the fastest multiple dispatch library around, by some margin.
+* 🚀 [**Variants**](https://ovld.readthedocs.io/en/latest/usage/#variants), [**mixins**](https://ovld.readthedocs.io/en/latest/usage/#mixins) and [**medleys**](https://ovld.readthedocs.io/en/latest/medley) of functions and methods.
 * 🦄 **[Dependent types](https://ovld.readthedocs.io/en/latest/dependent/):** Overloaded functions can depend on more than argument types: they can depend on actual values.
-* 🔑 **Extensive:** Dispatch on functions, methods, positional arguments and even [keyword arguments](https://ovld.readthedocs.io/en/latest/usage/#keyword-arguments) (with some restrictions).
+* 🔑 **[Extensive](https://ovld.readthedocs.io/en/latest/usage/#keyword-arguments):** Dispatch on functions, methods, positional arguments and even keyword arguments (with some restrictions).
+* ⚙️ **[Codegen](https://ovld.readthedocs.io/en/latest/codegen/):** (Experimental) For advanced use cases, you can generate custom code for overloads.
 
 ## Example
 
@@ -62,7 +63,7 @@ A *variant* of an `ovld` is a copy of the `ovld`, with some methods added or cha
 
 ```python
 @add.variant
-def mul(self, x: object, y: object):
+def mul(x: object, y: object):
     return x * y
 
 assert mul([1, 2], [3, 4]) == [3, 8]
@@ -199,19 +200,64 @@ assert Two().f(1) == "an integer"
 assert Two().f("s") == "a string"
 ```
 
+## Medleys
+
+Inheriting from [`ovld.Medley`](https://ovld.readthedocs.io/en/latest/medley/) lets you combine functionality in a new way. Classes created that way are free-form medleys that you can (almost) arbitrarily combine together.
+
+All medleys are dataclasses and you must define their data fields as you would for a normal dataclass (using `dataclass.field` if needed).
+
+```python
+from ovld import Medley
+
+class Punctuator(Medley):
+    punctuation: str = "."
+
+    def __call__(self, x: str):
+        return f"{x}{self.punctuation}"
+
+class Multiplier(Medley):
+    factor: int = 3
+
+    def __call__(self, x: int):
+        return x * self.factor
+
+# You can add the classes together to merge their methods and fields using ovld
+PuMu = Punctuator + Multiplier
+f = PuMu(punctuation="!", factor=3)
+
+# You can also combine existing instances!
+f2 = Punctuator("!") + Multiplier(3)
+
+assert f("hello") == f2("hello") == "hello!"
+assert f(10) == f2(10) == 30
+
+# You can also meld medleys inplace, but only if all new fields have defaults
+class Total(Medley):
+    pass
+
+Total.extend(Punctuator, Multiplier)
+f3 = Total(punctuation="!", factor=3)
+```
+
+
+# Code generation
+
+(Experimental) For advanced use cases, you can generate custom code for type checkers or overloads. [See here](https://ovld.readthedocs.io/en/latest/codegen/).
+
+
 # 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 has 1.5x to 100x less overhead.
 
 Time relative to the fastest implementation (1.00) (lower is better).
 
-| 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.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|
+| 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) | [sd](https://docs.python.org/3/library/functools.html#functools.singledispatch) |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+|[trivial](https://github.com/breuleux/ovld/tree/master/benchmarks/test_trivial.py)|1.45|1.00|3.32|4.63|2.04|2.41|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|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|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|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|
+|[regexp](https://github.com/breuleux/ovld/tree/master/benchmarks/test_regexp.py)|1.00|1.87|19.18|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|
+|[tweaknum](https://github.com/breuleux/ovld/tree/master/benchmarks/test_tweaknum.py)|1.00|2.09|x|x|x|x|x|

{ovld-0.4.6 → ovld-0.5.0}/README.md

@@ -7,10 +7,11 @@ Fast multiple dispatch in Python, with many extra features.
 
 With ovld, you can write a version of the same function for every type signature using annotations instead of writing an awkward sequence of `isinstance` statements. Unlike Python's `singledispatch`, it works for multiple arguments.
 
-* ⚡️ **[Fast](https://ovld.readthedocs.io/en/latest/compare/#results):** `ovld` is the fastest multiple dispatch library around, by some margin.
-* 🚀 [**Variants**](https://ovld.readthedocs.io/en/latest/usage/#variants) and [**mixins**](https://ovld.readthedocs.io/en/latest/usage/#mixins) of functions and methods.
+* ⚡️ **[Fast](https://ovld.readthedocs.io/en/latest/compare/#results):** ovld is the fastest multiple dispatch library around, by some margin.
+* 🚀 [**Variants**](https://ovld.readthedocs.io/en/latest/usage/#variants), [**mixins**](https://ovld.readthedocs.io/en/latest/usage/#mixins) and [**medleys**](https://ovld.readthedocs.io/en/latest/medley) of functions and methods.
 * 🦄 **[Dependent types](https://ovld.readthedocs.io/en/latest/dependent/):** Overloaded functions can depend on more than argument types: they can depend on actual values.
-* 🔑 **Extensive:** Dispatch on functions, methods, positional arguments and even [keyword arguments](https://ovld.readthedocs.io/en/latest/usage/#keyword-arguments) (with some restrictions).
+* 🔑 **[Extensive](https://ovld.readthedocs.io/en/latest/usage/#keyword-arguments):** Dispatch on functions, methods, positional arguments and even keyword arguments (with some restrictions).
+* ⚙️ **[Codegen](https://ovld.readthedocs.io/en/latest/codegen/):** (Experimental) For advanced use cases, you can generate custom code for overloads.
 
 ## Example
 
@@ -49,7 +50,7 @@ A *variant* of an `ovld` is a copy of the `ovld`, with some methods added or cha
 
 ```python
 @add.variant
-def mul(self, x: object, y: object):
+def mul(x: object, y: object):
     return x * y
 
 assert mul([1, 2], [3, 4]) == [3, 8]
@@ -186,19 +187,64 @@ assert Two().f(1) == "an integer"
 assert Two().f("s") == "a string"
 ```
 
+## Medleys
+
+Inheriting from [`ovld.Medley`](https://ovld.readthedocs.io/en/latest/medley/) lets you combine functionality in a new way. Classes created that way are free-form medleys that you can (almost) arbitrarily combine together.
+
+All medleys are dataclasses and you must define their data fields as you would for a normal dataclass (using `dataclass.field` if needed).
+
+```python
+from ovld import Medley
+
+class Punctuator(Medley):
+    punctuation: str = "."
+
+    def __call__(self, x: str):
+        return f"{x}{self.punctuation}"
+
+class Multiplier(Medley):
+    factor: int = 3
+
+    def __call__(self, x: int):
+        return x * self.factor
+
+# You can add the classes together to merge their methods and fields using ovld
+PuMu = Punctuator + Multiplier
+f = PuMu(punctuation="!", factor=3)
+
+# You can also combine existing instances!
+f2 = Punctuator("!") + Multiplier(3)
+
+assert f("hello") == f2("hello") == "hello!"
+assert f(10) == f2(10) == 30
+
+# You can also meld medleys inplace, but only if all new fields have defaults
+class Total(Medley):
+    pass
+
+Total.extend(Punctuator, Multiplier)
+f3 = Total(punctuation="!", factor=3)
+```
+
+
+# Code generation
+
+(Experimental) For advanced use cases, you can generate custom code for type checkers or overloads. [See here](https://ovld.readthedocs.io/en/latest/codegen/).
+
+
 # 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 has 1.5x to 100x less overhead.
 
 Time relative to the fastest implementation (1.00) (lower is better).
 
-| 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.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|
+| 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) | [sd](https://docs.python.org/3/library/functools.html#functools.singledispatch) |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+|[trivial](https://github.com/breuleux/ovld/tree/master/benchmarks/test_trivial.py)|1.45|1.00|3.32|4.63|2.04|2.41|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|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|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|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|
+|[regexp](https://github.com/breuleux/ovld/tree/master/benchmarks/test_regexp.py)|1.00|1.87|19.18|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|
+|[tweaknum](https://github.com/breuleux/ovld/tree/master/benchmarks/test_tweaknum.py)|1.00|2.09|x|x|x|x|x|

{ovld-0.4.6 → ovld-0.5.0}/benchmarks/common.py

@@ -1,7 +1,7 @@
 import sys
 from functools import singledispatch
 
-from fastcore.dispatch import typedispatch as fastcore_dispatch
+import pytest
 from multimethod import multimethod as multimethod_dispatch
 from multipledispatch import dispatch as _md_dispatch
 from plum import dispatch as plum_dispatch
@@ -19,9 +19,7 @@ def _locate(fn):
 
 def _getanns(fn):
     anns = fn.__annotations__.values()
-    anns = [
-        tuple(ann.__args__) if hasattr(ann, "__args__") else ann for ann in anns
-    ]
+    anns = [tuple(ann.__args__) if hasattr(ann, "__args__") else ann for ann in anns]
     return anns
 
 
@@ -44,12 +42,41 @@ def singledispatch_dispatch(fn):
         return singledispatch(fn)
 
 
+def with_functions(**tests):
+    return pytest.mark.parametrize(
+        "fn",
+        argvalues=list(tests.values()),
+        ids=list(tests.keys()),
+    )
+
+
+def function_builder(defn):
+    def wrapper(dispatch):
+        try:
+            rval = defn(dispatch)
+        except Exception as exc:
+            e = exc
+
+            def reraise(*args, **kwargs):
+                raise e
+
+            rval = reraise
+        try:
+            rval._dispatch = dispatch
+        except AttributeError:
+            pass
+        return rval
+
+    return wrapper
+
+
 __all__ = [
     "multimethod_dispatch",
     "plum_dispatch",
     "runtype_dispatch",
     "ovld_dispatch",
     "multipledispatch_dispatch",
-    "fastcore_dispatch",
     "singledispatch_dispatch",
+    "function_builder",
+    "with_functions",
 ]

{ovld-0.4.6 → ovld-0.5.0}/benchmarks/test_add.py

@@ -1,12 +1,13 @@
 import pytest
 
 from .common import (
-    fastcore_dispatch,
+    function_builder,
     multimethod_dispatch,
     multipledispatch_dispatch,
     ovld_dispatch,
     plum_dispatch,
     runtype_dispatch,
+    with_functions,
 )
 
 ###############################
@@ -14,6 +15,7 @@ from .common import (
 ###############################
 
 
+@function_builder
 def make_add(dispatch):
     @dispatch
     def add(x: list, y: list):
@@ -76,21 +78,16 @@ B = {"xs": list(range(10, 60)), "ys": ("x", (7, 6))}
 C = {"xs": list(range(10, 110, 2)), "ys": ("ox", (13, 13))}
 
 
-def make_test(fn):
-    @pytest.mark.benchmark(group="add")
-    def test(benchmark):
-        result = benchmark(fn, A, B)
-        assert result == C
-
-    return test
-
-
-test_add_ovld = make_test(make_add(ovld_dispatch))
-test_add_plum = make_test(make_add(plum_dispatch))
-test_add_multimethod = make_test(make_add(multimethod_dispatch))
-test_add_multipledispatch = make_test(make_add(multipledispatch_dispatch))
-test_add_runtype = make_test(make_add(runtype_dispatch))
-test_add_fastcore = make_test(make_add(fastcore_dispatch))
-
-test_add_custom_isinstance = make_test(add_isinstance)
-test_add_custom_match = make_test(add_match)
+@pytest.mark.benchmark(group="add")
+@with_functions(
+    ovld=make_add(ovld_dispatch),
+    plum=make_add(plum_dispatch),
+    multimethod=make_add(multimethod_dispatch),
+    multipledispatch=make_add(multipledispatch_dispatch),
+    runtype=make_add(runtype_dispatch),
+    isinstance=add_isinstance,
+    match=add_match,
+)
+def test_add(fn, benchmark):
+    result = benchmark(fn, A, B)
+    assert result == C

{ovld-0.4.6 → ovld-0.5.0}/benchmarks/test_ast.py

@@ -6,13 +6,14 @@ from types import NoneType
 import pytest
 
 from .common import (
-    fastcore_dispatch,
+    function_builder,
     multimethod_dispatch,
     multipledispatch_dispatch,
     ovld_dispatch,
     plum_dispatch,
     runtype_dispatch,
     singledispatch_dispatch,
+    with_functions,
 )
 
 
@@ -33,6 +34,7 @@ def foobar():
     return ast.parse(inspect.getsource(foo)), ast.parse(inspect.getsource(bar))
 
 
+@function_builder
 def make_transform(dispatch):
     @dispatch
     def transform(node: list):
@@ -94,23 +96,21 @@ class NT(ast.NodeTransformer):
 ####################
 
 
-def make_test(fn):
-    @pytest.mark.benchmark(group="ast")
-    def test(benchmark, foobar):
-        result = benchmark(fn, foobar[0])
-        assert ast.dump(result, indent=2) == ast.dump(
-            foobar[1], indent=2
-        ).replace("bar", "foo")
-
-    return test
-
-
-test_ast_ovld = make_test(make_transform(ovld_dispatch))
-test_ast_plum = make_test(make_transform(plum_dispatch))
-test_ast_multimethod = make_test(make_transform(multimethod_dispatch))
-test_ast_multipledispatch = make_test(make_transform(multipledispatch_dispatch))
-test_ast_runtype = make_test(make_transform(runtype_dispatch))
-test_ast_fastcore = make_test(make_transform(fastcore_dispatch))
-if sys.version_info >= (3, 11):
-    test_ast_singledispatch = make_test(make_transform(singledispatch_dispatch))
-test_ast_custom = make_test(NT().visit)
+@pytest.mark.benchmark(group="ast")
+@with_functions(
+    ovld=make_transform(ovld_dispatch),
+    plum=make_transform(plum_dispatch),
+    multimethod=make_transform(multimethod_dispatch),
+    multipledispatch=make_transform(multipledispatch_dispatch),
+    runtype=make_transform(runtype_dispatch),
+    singledispatch=make_transform(singledispatch_dispatch),
+    custom=NT().visit,
+)
+def test_ast(fn, foobar, benchmark):
+    if (
+        sys.version_info < (3, 11)
+        and getattr(fn, "_dispatch", None) is singledispatch_dispatch
+    ):
+        pytest.skip()
+    result = benchmark(fn, foobar[0])
+    assert ast.dump(result, indent=2) == ast.dump(foobar[1], indent=2).replace("bar", "foo")

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

@@ -4,9 +4,11 @@ from typing import Literal
 import pytest
 
 from .common import (
+    function_builder,
     multimethod_dispatch,
     ovld_dispatch,
     plum_dispatch,
+    with_functions,
 )
 
 ###############################
@@ -14,6 +16,7 @@ from .common import (
 ###############################
 
 
+@function_builder
 def make_calc(dispatch):
     @dispatch
     def calc(num: Number):
@@ -127,18 +130,14 @@ expr = ("add", ("mul", ("sqrt", 4), 7), ("div", ("add", 6, 4), ("sub", 5, 3)))
 expected_result = 19
 
 
-def make_test(fn):
-    @pytest.mark.benchmark(group="calc")
-    def test(benchmark):
-        result = benchmark(fn, expr)
-        assert result == expected_result
-
-    return test
-
-
-test_calc_ovld = make_test(make_calc(ovld_dispatch))
-test_calc_plum = make_test(make_calc(plum_dispatch))
-test_calc_multimethod = make_test(make_calc(multimethod_dispatch))
-
-test_calc_custom_dict = make_test(calc_dict)
-test_calc_custom_match = make_test(calc_match)
+@pytest.mark.benchmark(group="calc")
+@with_functions(
+    ovld=make_calc(ovld_dispatch),
+    plum=make_calc(plum_dispatch),
+    multimethod=make_calc(multimethod_dispatch),
+    custom_dict=calc_dict,
+    custom_match=calc_match,
+)
+def test_calc(fn, benchmark):
+    result = benchmark(fn, expr)
+    assert result == expected_result

{ovld-0.4.6 → ovld-0.5.0}/benchmarks/test_fib.py

@@ -3,9 +3,11 @@ from typing import Literal
 import pytest
 
 from .common import (
+    function_builder,
     multimethod_dispatch,
     ovld_dispatch,
     plum_dispatch,
+    with_functions,
 )
 
 ###############################
@@ -13,6 +15,7 @@ from .common import (
 ###############################
 
 
+@function_builder
 def make_fib(dispatch):
     @dispatch
     def fib(n: Literal[0]):
@@ -46,17 +49,13 @@ def fib_normal(n):
 ####################
 
 
-def make_test(fn):
-    @pytest.mark.benchmark(group="fib")
-    def test(benchmark):
-        result = benchmark(fn, 8)
-        assert result == 21
-
-    return test
-
-
-test_fib_ovld = make_test(make_fib(ovld_dispatch))
-test_fib_plum = make_test(make_fib(plum_dispatch))
-test_fib_multimethod = make_test(make_fib(multimethod_dispatch))
-
-test_fib_custom = make_test(fib_normal)
+@pytest.mark.benchmark(group="fib")
+@with_functions(
+    ovld=make_fib(ovld_dispatch),
+    plum=make_fib(plum_dispatch),
+    multimethod=make_fib(multimethod_dispatch),
+    custom=fib_normal,
+)
+def test_fib(fn, benchmark):
+    result = benchmark(fn, 8)
+    assert result == 21

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

@@ -7,11 +7,12 @@ from ovld import recurse
 from ovld.core import OvldBase
 
 from .common import (
-    fastcore_dispatch,
+    function_builder,
     multimethod_dispatch,
     ovld_dispatch,
     plum_dispatch,
     runtype_dispatch,
+    with_functions,
 )
 
 
@@ -20,6 +21,7 @@ class BaseMulter:
         self.factor = factor
 
 
+@function_builder
 def make_multer(dispatch):
     class Multer(BaseMulter):
         @dispatch
@@ -138,22 +140,17 @@ A = {"xs": list(range(0, 50)), "ys": ("o", (6, 7))}
 C = {"xs": list(range(0, 150, 3)), "ys": ("ooo", (18, 21))}
 
 
-def make_test(cls):
-    @pytest.mark.benchmark(group="multer")
-    def test(benchmark):
-        result = benchmark(cls(3), A)
-        assert result == C
-
-    return test
-
-
-test_multer_ovld = make_test(make_multer(ovld_dispatch))
-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)
-test_multer_multipledispatch = make_test(MultipleDispatchMulter)
-test_multer_runtype = make_test(make_multer(runtype_dispatch))
-test_multer_fastcore = make_test(make_multer(fastcore_dispatch))
-
-test_multer_custom_isinstance = make_test(IsinstanceMulter)
+@pytest.mark.benchmark(group="multer")
+@with_functions(
+    ovld=make_multer(ovld_dispatch),
+    recurse=OvldRecurseMulter,
+    plum=make_multer(plum_dispatch),
+    multimethod=make_multer(multimethod_dispatch),
+    singledispatch=SingleDispatchMulter,
+    multipledispatch=MultipleDispatchMulter,
+    runtype=make_multer(runtype_dispatch),
+    isinstance=IsinstanceMulter,
+)
+def test_multer(fn, benchmark):
+    result = benchmark(fn(3), A)
+    assert result == C