Questions about remembering and caching function arguments

A

Anand Patil

Hi all,

I have two questions about a class, which we'll call MyWrapperClass,
in a package to which I'm contributing.


1) MyWrapperClass wraps functions. Each instance has an attribute
called 'value' and a method called 'eval', which calls the wrapped
function. An instance D that depends on instances A, B and C can be
created as follows:

@mywrapperclass
def D(A, B, C):
return foo(A.value, B.value, C.value)

Now that D exists, the call D.eval() will work without any arguments
(D remembers that the arguments are A, B and C and passes their values
to foo). What is the standard terminology for such classes, and does
anyone know of a package that implements them in a nice way? (It's
easy enough to roll our own, but reading about other implementations
might give us good ideas).


2) D.eval() will frequently be called multiple times in succession
before A.value, B.value or C.value has had the chance to change. It
would be _extremely_ helpful to have D detect this situation and skip
recomputation. I'm looking for the fastest safe way to do this.
There's no restriction on what kind of object A.value, etc. are, so
unfortunately they might be mutable.

Our current solution is to have D compare A.value, B.value and C.value
to an internal cache using the 'is' operator (and put a big warning in
the docs about not changing 'value' attributes in-place). Not exactly
safe, but the speed savings over comparison with '==' will be
significant. Is this OK, bad or an abomination?

Again it would be helpful to know the terminology associated with the
behavior I'm looking for and any packages that implement it nicely.


Many thanks in advance and apologies for the long post,
Anand
 
T

thebjorn

Hi all,

I have two questions about a class, which we'll call MyWrapperClass,
in a package to which I'm contributing.

1) MyWrapperClass wraps functions. Each instance has an attribute
called 'value' and a method called 'eval', which calls the wrapped
function. An instance D that depends on instances A, B and C can be
created as follows:

@mywrapperclass
def D(A, B, C):
return foo(A.value, B.value, C.value)

Now that D exists, the call D.eval() will work without any arguments
(D remembers that the arguments are A, B and C and passes their values
to foo). What is the standard terminology for such classes, and does
anyone know of a package that implements them in a nice way? (It's
easy enough to roll our own, but reading about other implementations
might give us good ideas).

2) D.eval() will frequently be called multiple times in succession
before A.value, B.value or C.value has had the chance to change. It
would be _extremely_ helpful to have D detect this situation and skip
recomputation. I'm looking for the fastest safe way to do this.
There's no restriction on what kind of object A.value, etc. are, so
unfortunately they might be mutable.

Our current solution is to have D compare A.value, B.value and C.value
to an internal cache using the 'is' operator (and put a big warning in
the docs about not changing 'value' attributes in-place). Not exactly
safe, but the speed savings over comparison with '==' will be
significant. Is this OK, bad or an abomination?

Again it would be helpful to know the terminology associated with the
behavior I'm looking for and any packages that implement it nicely.

Many thanks in advance and apologies for the long post,
Anand

Cells (A dataflow extension to CLOS) seems like what you want:

http://common-lisp.net/project/cells/

I think there was talk of a Python version a while back...

-- bjorn
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Members online

No members online now.

Forum statistics

Threads
473,744
Messages
2,569,484
Members
44,903
Latest member
orderPeak8CBDGummies

Latest Threads

Top