Alternatively, you can get rid ofself._all_weakrefable_instances:

diff --git a/Lib/functools.py b/Lib/functools.pyindex 2a8a69b3c5..5622eb6467 100644--- a/Lib/functools.py+++ b/Lib/functools.py@@ -935,7 +935,6 @@ def __init__(self, func):         self.dispatcher = singledispatch(func)         self.func = func         self._method_cache = weakref.WeakKeyDictionary()-        self._all_weakrefable_instances = True      def register(self, cls, method=None):         """generic_method.register(cls, func) -> func@@ -945,11 +944,11 @@ def register(self, cls, method=None):         return self.dispatcher.register(cls, func=method)      def __get__(self, obj, cls=None):-        if self._all_weakrefable_instances:+        if self._method_cache:             try:                 _method = self._method_cache[obj]             except TypeError:-                self._all_weakrefable_instances = False+                self._method_cache = None             except KeyError:                 pass             else:@@ -963,7 +962,7 @@ def _method(*args, **kwargs):         _method.register = self.register         update_wrapper(_method, self.func)-        if self._all_weakrefable_instances:+        if self._method_cache is not None:             self._method_cache[obj] = _method          return _method

It reduces memory even more, and in all cases.

Alternatively, you can get rid ofself._all_weakrefable_instances:

Very nice. And the performance seems to be the same. The first line of__get__ needs to be this, however (rather than justif self._method_cache), or tests start to fail:

def__get__(self,obj,cls=None):ifself._method_cacheisnotNone:

Or you need to catch TypeError when save in the cache:

ifself._method_cacheisnotNone:try:self._method_cache[obj]=_methodexceptTypeError:self._method_cache=None

Or you need to catch TypeError when save in the cache:

try/except is expensive; this would be much slower. With this PR currently:

bench singledispatchmethod: Mean +- std dev: 875 ns +- 32 nsbench singledispatchmethod slots: Mean +- std dev: 2.01 us +- 0.06 us

With this diff applied to my PR branch:

--- a/Lib/functools.py+++ b/Lib/functools.py@@ -945,7 +945,7 @@ def register(self, cls, method=None):         return self.dispatcher.register(cls, func=method)     def __get__(self, obj, cls=None):-        if self._method_cache is not None:+        if self._method_cache:             try:                 _method = self._method_cache[obj]             except TypeError:@@ -963,8 +963,10 @@ def _method(*args, **kwargs):         _method.register = self.register         update_wrapper(_method, self.func)-        if self._method_cache is not None:+        try:             self._method_cache[obj] = _method+        except TypeError:+            pass         return _method

bench singledispatchmethod: Mean +- std dev: 1.02 us +- 0.04 usbench singledispatchmethod slots: Mean +- std dev: 3.32 us +- 0.27 us

importpyperfsetup="""from functools import singledispatch, singledispatchmethodclass Test:    @singledispatchmethod    def go(self, item, arg):        pass    @go.register    def _(self, item: int, arg):        return item + argclass Slot:    __slots__ = ('a', 'b')    @singledispatchmethod    def go(self, item, arg):        pass    @go.register    def _(self, item: int, arg):        return item + argt = Test()s= Slot()"""runner=pyperf.Runner()runner.timeit(name="bench singledispatchmethod",stmt="""_ = t.go(1, 1)""",setup=setup )runner.timeit(name="bench singledispatchmethod slots",stmt="""_ = s.go(1, 1)""",setup=setup )

Simplerif self._method_cache: makes the first call faster (this is why I wrote this so at first place). Butif self._method_cache is not None: may make all following calls marginally faster, although I do not know how large the difference. So perhaps the latter variant is better in long run.

try/except is expensive; this would be much slower.

I mean that you keepif self._method_cache is not None: for setting, but addcatch TypeError. It will not add an overhead.

It will not add an overhead.

I still measure about a 14% overhead from this approach compared to my current PR. (Tested on a PGO-optimised non-debug build on Windows, with a quiet machine.) I'm inclined to stick with how it is currently -- it also feels like slightly cleaner code if we have only onetry/except in__get__

I still measure about a 14% overhead from this approach compared to my current PR.

With the test forNone preceding thetry block? I am surprised,try/except should not add an overhead if no exception was raised.

Anyway, your current code is better. I just explained why I intentionally did not useis None in the initial proposition.

I still measure about a 14% overhead from this approach compared to my current PR.

With the test forNone preceding thetry block? I am surprised,try/except should not add an overhead if no exception was raised.

Yep. I'm also surprised there was that difference.

Thanks for the review, Serhiy!