Your search query "linkto%3A%22AlternateLambdaSyntax%22" didn't return any results. Please change some terms and refer to HelpOnSearching for more information.
(!) Consider performing a full-text search with your search terms.

Clear message

As it stands, Guido van Rossum has suggested that lambda forms will disappear in Python3.0. This started a number of threads on comp.lang.python suggesting alternate syntaxes for lambda in the hopes that one of them might be more amenable to GvR's tastes. This pages summarizes these suggestions.

The main hope of this page is to find a way to retain the functionality of existing Python lambdas - a way to create simple deferred expressions within another expression. For many uses (e.g. lazy argument evaluation, or simple callbacks) separating the deferred expression out into a named function can actually reduce clarity, as it overemphasises the deferred expression at the expense of the expression that the deferred expression is only one part of.

Goals for Alternate Form

Definitely Desirable Features

Arguably Desirable Features

Current Syntax

   1 lambda a, b, c:f(a) + o(b) - o(c)
   2 lambda x: x * x
   3 lambda : x
   4 lambda *a, **k: x.bar(*a, **k)
   5 ((lambda x=x, a=a, k=k: x(*a, **k)) for x, a, k in funcs_and_args_list)

New Syntaxes

Args Before Expression

Nick Coghlan: def-to syntax 1]

   1 (def (a, b, c) to f(a) + o(b) - o(c))
   2 (def (x) to x * x)
   3 (def () to x)
   4 (def (*a, **k) to x.bar(*a, **k))
   5 ((def (x=x, a=a, k=k) to x(*a, **k)) for x, a, k in funcs_and_args_list)

Nick Coghlan: def-arrow syntax 1]

   1 (def (a, b, c) -> f(a) + o(b) - o(c))
   2 (def (x) -> x * x)
   3 (def () -> x)
   4 (def (*a, **k) -> x.bar(*a, **k))
   5 ((def (x=x, a=a, k=k) -> x(*a, **k)) for x, a, k in funcs_and_args_list)

Alex Martelli: def-as syntax 2]

   1 (def (a, b, c) as f(a) + o(b) - o(c))
   2 (def (x) as x * x)
   3 (def () as x)
   4 (def (*a, **k) as x.bar(*a, **k))
   5 ((def (x=x, a=a, k=k) as x(*a, **k)) for x, a, k in funcs_and_args_list)

Dave Benjamin: fun syntax 7]

   1 (fun(a, b, c): f(a) + o(b) - o(c))
   2 (fun(x): x * x)
   3 (fun(): x)
   4 (fun(*a, **k): x.bar(*a, **k))
   5 ((fun(x=x, a=a, k=k): x(*a, **k)) for x, a, k in funcs_and_args_list)

Roman Suzi: quote-colon syntax 9]

   1 ` a, b, c:f(a) + o(b) - o(c)
   2 ` x: x * x
   3 ` : x
   4 ` *a, **k: x.bar(*a, **k)
   5 ((` x=x, a=a, k=k: x(*a, **k)) for x, a, k in funcs_and_args_list)

Ka-Ping Yee: arrow syntax

   1 a, b, c -> f(a) + o(b) - o(c)
   2 x -> x * x
   3 -> x
   4 *a, **k -> x.bar(*a, **k)
   5 ((x=x, a=a, k=k) -> x(*a, **k) for x, a, k in funcs_and_args_list)

to-syntax

   1 a, b, c to f(a) + o(b) - o(c)
   2 x to x * x
   3 to x
   4 *a, **k to x.bar(*a, **k)
   5 ((x=x, a=a, k=k) to x(*a, **k) for x, a, k in funcs_and_args_list)

Tom Anderson: anonymous def syntax, normal form 12]

   1 def (a, b, c): return f(a) + o(b) - o(c)
   2 def (x): return x * x
   3 def (): return x
   4 def (*a, **k): return x.bar(*a, **k)
   5 ((def (x=x, a=a, k=k): return x(*a, **k)) for x, a, k in funcs_and_args_list)

Tom Anderson: anonymous def syntax, shorthand form 12]

   1 def (a, b, c) = f(a) + o(b) - o(c)
   2 def (x) = x * x
   3 def () = x
   4 def (*a, **k) = x.bar(*a, **k)
   5 ((def (x=x, a=a, k=k) = x(*a, **k)) for x, a, k in funcs_and_args_list)

Anders Munch: bare def syntax

   1 (def (a, b, c) f(a) + o(b) - o(c))
   2 (def (x) x*x)
   3 (def () x)
   4 (def (*a, **k) x.bar(*a, **k))
   5 ((def (x=x, a=a, k=k) x(*a, **k)) for x, a, k in funcs_and_args_list)

Expression Before Args

Nick Coghlan: post-def syntax This is based on the "normally nested expression before statement keyword" idiom used with generator expressions, list comprehensions and PEP 308 conditional expressions.

   1 (f(a) + o(b) - o(c) def (a, b, c))
   2 (x * x def (x))
   3 (x def ()) # Making the empty param list optional would be good for lazy arguments: (x def)
   4 (x.bar(*a, **k) def (*a, **k))
   5 ((x(*a, **k) def (x=x, a=a, k=k)) for x, a, k in funcs_and_args_list)

Nick Coghlan: for syntax 6]

   1 (f(a) + o(b) - o(c) for (a, b, c))
   2 (x * x for (x))
   3 (x for ())
   4 (x.bar(*a, **k) for (*a, **k))
   5 ((x(*a, **k) for (x=x, a=a, k=k)) for x, a, k in funcs_and_args_list)

Robert Brewer: for (no-parens) syntax 3]

   1 (f(a) + o(b) - o(c) for a, b, c)
   2 (x * x for x)
   3 (x for ())
   4 (x.bar(*a, **k) for *a, **k)
   5 ((x(*a, **k) for (x=x, a=a, k=k)) for x, a, k in funcs_and_args_list)

Nick Coghlan: def-from syntax 4]

   1 (def f(a) + o(b) - o(c) from (a, b, c))
   2 (def x * x from (x))
   3 (def x from ())
   4 (def x.bar(*a, **k) from (*a, **k))
   5 ((def x(*a, **k) from (x=x, a=a, k=k)) for x, a, k in funcs_and_args_list)

Nick Coghlan: from syntax (posted to clp, no reference handy)

   1 (f(a) + o(b) - o(c) from (a, b, c))
   2 (x * x from (x))
   3 (x from ())
   4 (x.bar(*a, **k) from (*a, **k))
   5 ((x(*a, **k) from (x=x, a=a, k=k)) for x, a, k in funcs_and_args_list)

Michael Spencer: from-args syntax 5]

   1 (f(a) + o(b) - o(c) from args(a, b, c))
   2 (x * x from args(x))
   3 (x from args())
   4 (x.bar(*a, **k) from args(*a, **k))
   5 ((x(*a, **k) from args(x=x, a=a, k=k)) for x, a, k in funcs_and_args_list)

Michael Spencer: for-args syntax 5]

   1 (f(a) + o(b) - o(c) for args(a, b, c))
   2 (x * x for args(x))
   3 (x for args())
   4 (x.bar(*a, **k) for args(*a, **k))
   5 ((x(*a, **k) for args()) for x, a, k in funcs_and_args_list)

Bengt Richter: colon-function-application syntax 8]

   1 (:f(a) + o(b) - o(c))(a, b, c)
   2 (:x*x)(X)
   3 (:x)()
   4 (:x.bar(*a, **k))(*a, **k)
   5 ((:x(*a, **k))(x=x, a=a, k=k) for x, a, k in funcs_and_args_list)

Talin: 'given' keyword (Same as the 'for no parens' except uses a different keyword.)

   1 (f(a) + o(b) - o(c) given a, b, c)
   2 (x * x given x)
   3 (x given ())
   4 (x.bar(*a, **k) given *a, **k)
   5 ((x(*a, **k) given (x=x, a=a, k=k)) for x, a, k in funcs_and_args_list)

functional syntax

lwickjr: How about converting the lambda functionality into a function? For example, in pure can-do-now Python:

   1 from types import FunctionType as function
   2 def anonymous(
   3         name=None,
   4         filename=None,
   5         mode="eval",
   6         func_globals=None,
   7         func_closure=None,
   8         func_argdefs=(),
   9         flags=0,
  10         dont_inherit=False,
  11         source=None,
  12         code=None,
  13         ):
  14         """Create a possibly anonymous function inline"""
  15         ## Compute suitable default values from stack frame, omitted for brevity.
  16         if source: code = compile(soource, filename, mode, flags, dont_inherit=True)
  17         return function(code, func_globals, name, func_argdefs, func_closure)

If you don't like anynomous for the name, suggest something else! ;)

Real Closures

Real closures subsume the functionality of lambda plus allow for multi-line statements.


Curly braces for single-line and anonymous def for multi-line (from 10], boo 11], and this is also very similar to how Ruby does it):

   1 #single-line (similar to ruby syntax)
   2 {a,b,c | return f(a) + o(b) - o(c)}
   3 {x | return x*x}
   4 {return x}
   5 {*a, **k | return x.bar(*a, **k)}
   6 
   7 #multi-line
   8 x = def (a,b,c):
   9     return f(a) + o(b) - o(c)


Perhaps anonymous def for single line, anonymous def for single-line?

foo.addCallback(def (result): result + 1)
foo.addCallback(def (result, myExtra, args):
                     print 'hi!'
                     result += 1
                     return result
                , extra, args=here)

Tom Anderson's syntax (which is subtly different - it still wants a return in single-line anonymous defs) could also be used for multi-line closures in this way.

References

Unable to edit the page? See the FrontPage for instructions.