I haven't seen an established way to memoize a function that takes key-word arguments, i.e. something of type
def f(*args, **kwargs)
since typically a memoizer has a dict to cache results for a given set of input parameters, and kwargs is a dict and hence unhashable. I have tried, following discussions here, using
(args, frozenset(kwargs.items()))
as key to the cache dict, but this only works if the values in kwargs are hashable. Furthermore, as pointed out in answers below is that frozenset is not an ordered data structure. Therefore this solution might be safer:
(args, tuple(sorted(kwargs.items())))
But it still cannot cope with un-hashable elements. Another approach I have seen is to use a string representation of the kwargs in the cache key:
(args, str(sorted(kwargs.items())))
The only drawback I see with this is the overhead of hashing a potentially very long string. As far as I can see the results should be correct. Can anyone spot any problems with the latter approach? One of the answers below points out that this assumes certain behaviour of the __str__ or __repr__ functions for the values of the key-word arguments. This seems like a show-stopper.
Is there another, more established way of achieving memoization that can cope with **kwargs and un-hashable argument values?