memoization

Often I'm in the need of adding fields to an ADT that only memoize some redundant information. But I haven't figured out completely how to do it nicely and efficiently. The best way to show the problem is to make an example. Suppose we're working with untyped lambda terms: type VSym = String data Lambda = Var VSym | App Lambda Lambda | Abs VSym Lambda And from time to time we need to compute the set of free variables of a term: fv :: Lambda -> Set VSym fv (Var v) = Set.singleton v fv (App s t) = (fv s) `Set.union` (fv t) fv (Abs v t) = v `Set.delete` (fv t) Soon we realize that repeated

What I want is a memoization decorator that: can memoize instance methods with both arguments and keyword arguments has a cache that can be cleared (globally) with one call (vs. this one that uses a per-function cache: python resettable instance method memoization decorator ) is reasonably efficient I've tweaked an example I saw and came up with the following: import functools class Memoized(object): """Decorator that caches a function's return value each time it is called. If called later with the same arguments, the cached value is returned, and not re-evaluated. """ __cache = {} def __init_

I have been searching a bit for a python module that offers a memoize decorator with the following capabilities: Stores cache on disk to be reused among subsequent program runs. Works for any pickle-able arguments, most importantly numpy arrays. (Bonus) checks whether arguments are mutated in function calls. I found a few small code snippets for this task and could probably implement one myself, but I would prefer having an established package for this task. I also found incpy , but that does not seem to work with the standard python interpreter. Ideally, I would like to have something like

I have lengthy computations which I repeat many times. Therefore, I would like to use memoization (packages such as jug and joblib ), in concert with Pandas . The problem is whether the package would memoize well Pandas DataFrames as method arguments. Has anyone tried it? Is there any other recommended package/way to do this? Author of jug here: jug works fine. I just tried the following and it works: from jug import TaskGenerator import pandas as pd import numpy as np @TaskGenerator def gendata(): return pd.DataFrame(np.arange(343440).reshape((10,-1))) @TaskGenerator def compute(x): return x

I have an expensive function that takes and returns a small amount of data (a few integers and floats). I have already memoized this function, but I would like to make the memo persistent. There are already a couple of threads relating to this, but I'm unsure about potential issues with some of the suggested approaches, and I have some fairly specific requirements: I will definitely use the function from multiple threads and processes simultaneously (both using multiprocessing and from separate python scripts) I will not need read or write access to the memo from outside this python function I

I have a function that takes a parameter and produces a result. Unfortunately, it takes quite long for the function to produce the result. The function is being called quite often with the same input, that's why it would be convenient if I could cache the results. Something like let cachedFunction = createCache slowFunction in (cachedFunction 3.1) + (cachedFunction 4.2) + (cachedFunction 3.1) I was looking into Data.Array and although the array is lazy, I need to initialize it with a list of pairs (using listArray) - which is impractical . If the 'key' is e.g. the 'Double' type, I cannot