On Tue, 22 Mar 2005 15:05:55 +0100, bruno modulix <[EMAIL PROTECTED]> wrote:
>bruno modulix wrote: >> Kay Schluehr wrote: >> >>> Since George Sakkis proposed a new way of doing list comprehensions >>> letting tuples-like objects (x,y,z=0) acting as functions on other >>> tuples I wonder why this would not be a good starting point of >>> rethinking anonymus functions? >>> >>> In Georges proposition the action is >>> >>> (x,y,z=0) -> (x,y,z) What about a safe exec as a replacement to lamba but witht he flexability of exec in a safe and limeted way? safe_exec ( (*inputs) , (expressionstring) , ( *outputs) ) Functon to return a default value: >> def dfv( arg = value): return arg Safe exec command: >> x, y = 1, 2 >> safeexec ( (x, y, dfv(z=0)), "# do nothing", ( x, y, z) ) (1, 2, 0) What could we do, not do with this? * I actually started this reply here, so below is how I got to the above exression. I'm trying to put my finger on the basic inconsistency here. It has something to do with the z=0 as a way to defining a default . Then there's the lamba which I hear may be removed, but is difficult to understand for beginners, and isn't readable in that the name doesn't say what it does. An alternative name, and possibly a simpler syntax would be a plus. Another concept that this touches is the indirect execution of an expression. Exec and eval do that, but then you introduce security issues. I'm wondering if there's a fundamental concept under these issues such as a base function class or command that can evaluate the contents of a tuple in a secure way? value = fn(arg, returnvalue) >> x = 1 >> fn( x, x*2) 2 Use lists or tuples for multiple arguments and return expressions: >> x, y, z = 1, 2, 3 >> fn( (x,y,z=0), (x,y,z) ) (1, 2, 3) But it's that "z=0" causes problems here. In a tuple it's equivalent to saying 1=2. or 'a'='b' So we need a way to say 'if name is undefined, bind it to object'. # function to give a default value def dfv( arg = value): return arg >> x, y = 1, 2 >> fn( (x, y, dfv(x=0)), ( x, y, z )) (1, 2, 3) Now since this could execute in it's own private space, it might also offer a way to use exec or eval() indirectly in a very limited and safe way. >> estring = \ """ result = '' data = 'abcdefghigklmnop' for ch in data: if ch != filterc: result.join(ch) """ >> fn( ( dfv(filterc='d'), evalstring), (exec estring) ) So we need to use a three item tuple: safe_exec ( (*inputs) , (expressionstring) , ( *outputs) ) >> def dfv( arg = value): return arg >> x, y = 1, 2 >> safeexec( (x, y, dfv(z=0)), "# do nothing", ( x, y, z) ) (1, 2, 0) Long way around to here, but is this something that has potential? It would have to be a built in to ensure it's safe to use. But with an exec string, it can possibly do a lot more than lamba, and it probably wouldn't be as fast. But the flexibility could be useful. Ron -- http://mail.python.org/mailman/listinfo/python-list