On Wed, 2008-09-17 at 16:18 -0700, Bruce Leban wrote:
On Wed, Sep 17, 2008 at 3:41 PM, Cliff Wells
wrote: I'd prefer to write def foo ( lambda: arg ): return arg # evaluation happens here foo ( x )
("lambda" not necessarily being the actual name of the token in the second case).
I'd rather use the time machine. You can already do this quite easily.
def foo (arg): return arg() # evaluation happens here foo(lambda: x)
Except I'd prefer not having lambda sprinkled throughout the calling code (or worse, forgotten).
The idea of something automagically changing from an unevaluated to an evaluated value strikes me as a very bad one so requiring explicit evaluation here is a *good* thing. Aside from that, why should arg be evaluated on return as opposed to being passed along unevaluated until its value is really needed?
Didn't suggest that. That was merely an example. What I'm suggesting is that the *first* time it's used, evaluate then (my example used return for simplicity).
How would I check to see if an arg was provided? I certainly can't use a default value of None and then check for None since the check would cause it to be evaluated.
I don't consider that a problem. You either care about the value of an argument or you don't. If you care then you will eventually evaluate it anyway. If you don't, then don't evaluate it, ever.
Maybe we have a special operator that allows us to look at the unevaluated value. What's the context of the evaluation? Can it access variables in the place where it's evaluated? Maybe there's a special way to do that too. Let's not go down that path.
Agreed we shouldn't go down that path, but don't agree that it's needed. Cliff