You said in a comment that you're looking for a usecase for this technique, so I'll provide one for something similar, perhaps we'll get ideas. I've been toyin

You said in a comment that you're looking for a usecase for this technique, so I'll provide one for something similar, perhaps we'll get ideas. I've been toying with something similar lately, as a caching framework for scientific computations. I will have something like: x = load_big_file(filename) # takes 2 minutes y = sqrt(1 / x ** 2) # takes 4 seconds ... Then, as my work proceed, I will change and tweak and re-run in the same process...clearly a lot of my time would have been saved by caching (though a different part each time depending on what I tweak). The way to go currently is use joblib, which provides a decorator to put on a function to do basic caching. However you have to take care to manually clear cache if a function you're dependent on changes, or sometimes it will clear cache itself because you changed something irrelevant to the computation. So the lazy alternative idea I had is a lazily evaluated tree similar to this, where the purpose is looking up a cache using the AST as key. What I have now looks more like this: @pure def load_big_file(filename): ... >>> x = load_big_file(lazy(fileref(filename))) # fileref is like a string but hashes by timestamp of file.. >>> y = sqrt(1 / x ** 2) >>> print y <lazy 23wfas input: v1: 32rwaa "/home/dagss/data/myfile.dat" @ 2015-03-03 08:43:23 program: e0: 43wafa v1**2 e1: 4rfafq 1 / e0 e2: sqrt(e1) > The point is every node in the syntax tree gives a hash (leafs having their value hashed, inner nodes having a hash based on the operation and the inputs). Then implementing a cache is simply NULL = object() y = cache.get(y, NULL) if y is NULL: y = cache[y] = compute(y) I'm leaning a bit towards explicit being better than implicit though (having to call compute(y) rather than it happening when you need it to be evaluated transparently..)