> Robert, that's not the point. I do have enough Python knowledge to
> understand this (totally trivial) code !-)
>
> What I don't understand is how this code is supposed to save you from
> having to actually write both complex-key-expr and
> expensive-calc-expression more than once. You need them both each time
> you access the cache - whether the result of expensive-calc-expression
> has already been cached or not.
>
> Now this seems so obvious that I guess I failed to understand some point
> in your original spec (emphasis is mine):
> """
> I want to use a computation cache scheme like
>
>
> o = CACHECOMPUTE complex-key-expr expensive-calc-expr
>
> frequently and elegantly *without writing complex-key-expr or
> expensive-calc-expr twice*.
> """
But it is written only once.? And I have the cache functionality.
"You need them both each time you access the cache" : What you mean with
"need"? I still suppose you think expensive-calc-expr is executed every time.
But it is not - only the first time.
In my first ugly solution ...
_=complex-key-expr; o=cache.get(_) or cache.setdefault(_,expensive-calc-expr)
. it is also only executed once - because the part after "or" is only
evaluated if cache.get(_) doesn't find it in the cache.
Just ..
o = memo( complex-key-expr, lambda: expensive-calc-expr )
.. is much more elegant.
Contrast to explain: Uncaching (stupid) would be for example:
o = cache.setdefault(complex-key-expr, expensive-calc-expr)
Because expensive-calc-expr is executed every time. (I remember once I had such
a speed blocker bug in sloppy written code and only found it with the profiler)
Javaish ugly without writing the expressions twice (thus using variables) would
be:
key=complex-key-expr
if key in cache:
o=cache[key]
else:
o=expensive-calc-expr
cache[key]=o
But who wants to write such code with python, when you have to convert many
lines in an optimization effort in your code like
store-var = expensive-calc-expr
...
store-var = expensive-calc-expr
store-var = expensive-calc-expr
store-var = expensive-calc-expr
store-var = expensive-calc-expr
...
Thus what is not solved or what would you do better than:
store-var = memo( complex-key-expr, lambda: expensive-calc-expr )
...
store-var = memo( complex-key-expr, lambda: expensive-calc-expr )
store-var = memo( complex-key-expr, lambda: expensive-calc-expr )
store-var = memo( complex-key-expr, lambda: expensive-calc-expr )
store-var = memo( complex-key-expr, lambda: expensive-calc-expr )
....
I think there is no principally better solution. Maybe format it for the art
museum with operators to clean ,-brakets ...
store-var = rmemo(complex-key-expr) << lambda: expensive-calc-expr
-robert
--
http://mail.python.org/mailman/listinfo/python-list
