On Mon, 03 Jan 2005 18:54:06 GMT, Steven Bethard <[EMAIL PROTECTED]> wrote:
>Roman Suzi wrote:
>> I wish lambdas will not be deprecated in Python but the key to that is
>> dropping the keyword (lambda). If anybody could think of a better syntax for
>> lambdas _with_ arguments, we could develop PEP 312 further.
>
>Some suggestions from recent lambda threads (I only considered the ones
>that keep lambda as an expression):
>
Just for reference, am I correct in assuming these are the equivalent
uses of lambda?:
lambda a, b, c:f(a) + o(b) - o(c)
lambda x: x * x
lambda : x
lambda *a, **k: x.bar(*a, **k)
(lambda : x(*a, **k)) for x, a, k in funcs_and_args_list)
That last seems like it might need the default-arg-value hack: i.e.,
(lambda x=x, a=a, k=k: x(*a, **k)) for x, a, k in funcs_and_args_list)
>***** Args Before Expression *****
>
>Nick Coghlan: def-to syntax [1]
>(def (a, b, c) to f(a) + o(b) - o(c))
>(def (x) to x * x)
>(def () to x)
>(def (*a, **k) to x.bar(*a, **k))
>((def () to x(*a, **k)) for x, a, k in funcs_and_args_list)
>
>Nick Coghlan: def-arrow syntax [1]
>(def (a, b, c) -> f(a) + o(b) - o(c))
>(def (x) -> x * x)
>(def () -> x)
>(def (*a, **k) -> x.bar(*a, **k))
>((def () -> x(*a, **k)) for x, a, k in funcs_and_args_list)
>
>Alex Martelli: def-as syntax [2]
>(def (a, b, c) as f(a) + o(b) - o(c))
>(def (x) as x * x)
>(def () as x)
>(def (*a, **k) as x.bar(*a, **k))
>((def () as x(*a, **k)) for x, a, k in funcs_and_args_list)
>
>Dave Benjamin: fun syntax [7]
>(fun(a, b, c): f(a) + o(b) - o(c))
>(fun(x): x * x)
>(fun(): x)
>(fun(*a, **k): x.bar(*a, **k))
>((fun(): x(*a, **k)) for x, a, k in funcs_and_args_list)
>
>
>***** Expression Before Args *****
>
>Robert Brewer: for (no-parens) syntax [3]
>(f(a) + o(b) - o(c) for a, b, c)
>(x * x for x)
>(x for ())
>(x.bar(*a, **k) for *a, **k)
>((x(*a, **k) for ()) for x, a, k in funcs_and_args_list)
>
>Nick Coghlan: for syntax [6]
>(f(a) + o(b) - o(c) for (a, b, c))
>(x * x for (x))
>(x for ())
>(x.bar(*a, **k) for (*a, **k))
>((x(*a, **k) for ()) for x, a, k in funcs_and_args_list)
>
>Nick Coghlan: def-from syntax [4]
>(def f(a) + o(b) - o(c) from (a, b, c))
>(def x * x from (x))
>(def x from ())
>(def x.bar(*a, **k) from (*a, **k))
>((def x(*a, **k) from ()) for x, a, k in funcs_and_args_list)
>
>Michael Spencer: from-args syntax [5]
>(f(a) + o(b) - o(c) from args(a, b, c))
>(x * x from args(x))
>(x from args())
>(x.bar(*a, **k) from args(*a, **k))
>((x(*a, **k) from args()) for x, a, k in funcs_and_args_list)
>
>Michael Spencer: for-args syntax [5]
>(f(a) + o(b) - o(c) for args(a, b, c))
>(x * x for args(x))
>(x for args())
>(x.bar(*a, **k) for args(*a, **k))
>((x(*a, **k) for args()) for x, a, k in funcs_and_args_list)
>
>
>So there's a bunch of ideas out there. I don't know if any of them
>could be overwhelmingly preferred over lambda.
Just thought of another, more concise and keywordless, expression-before-args
syntax:
(:expression)(formalparams) # equivalent to lambda formalparams:expression
(:f(a) + o(b) - o(c))(a, b, c)
(:x*x)(X)
(:x)()
(:x.bar(*a, **k))(*a, **k)
((:x(*a, **k)() for x, a, k in funcs_and_args_list)
and with args default hack:
((:x(*a, **k)(x=x, a=a, k=k) for x, a, k in funcs_and_args_list)
I would have proposed (expression)(formalparams), but that is already legal ;-)
>
>Personally, I lean slightly towards the def-from syntax because it uses
>the 'def' keyword to bring your attention to the fact that a function is
>being defined, and it gives the expression precedence over the arglist,
>which makes sense to me for an anonymous function, where (IMHO) the
>expression is really the most important part of the declaration.
The syntax above panders to that ;-)
>
>OTOH, I think Michael Spencer's args() function, if implementable, could
>have a lot of cool uses, like getting the arguments passed to next
>within a generator. (See the thread about that[8].)
>
Actually, I would rather have seen the function interface itself used for that,
and
not have a scan for yields magically convert the normal function calling
interface to
a generator factory interface. But we are past that, unless we invent something
new.
E.g. if functions had an f.multicall() factory function that would return a
generator
"next" function with the same interface as f but starting code execution at the
start
the first time, and after yields on subsequent calls, then we could write
def f(x):
yield x+2
yield x*2
g = f.multicall() # not currently available
[g(n) for n in (2,5)]
and get (untested)
[4, 10]
instead of as now having to write something like
>>> def f(x):
... yield x[0]+2
... yield x[0]*2
...
>>> x = ['ignored']
>>> g = f(x).next
>>> [g() for x[0] in (2,5)]
[4, 10]
or wrapping with something more sugary.
>
>Steve
>
>[1]http://mail.python.org/pipermail/python-list/2004-December/256859.html
>[2]http://mail.python.org/pipermail/python-list/2004-December/256881.html
>[3]http://mail.python.org/pipermail/python-list/2004-December/257023.html
>[4]http://boredomandlaziness.skystorm.net/2004/12/anonymous-functions-in-python.html
>[5]http://mail.python.org/pipermail/python-list/2004-December/257893.html
>[6]http://mail.python.org/pipermail/python-list/2004-December/257977.html
>[7]http://mail.python.org/pipermail/python-list/2005-January/258441.html
>[8]http://mail.python.org/pipermail/python-list/2005-January/258238.html
Regards,
Bengt Richter
--
http://mail.python.org/mailman/listinfo/python-list
