As of tcl8.5, Tcl has native support for [lambda], provided by means of [apply] per [TIP] 194 [http://www.tcl.tk/cgi-bin/tct/tip/194].

The [apply] command is documented here http://www.tcl.tk/man/tcl8.5/TclCmd/apply.htm

This enables the following:

   proc lambda {arglist body {ns {}}} {
     list ::apply [list $arglist $body $ns]
   }

An example of its use:

   set q [lambda {x} {incr x}]
   {*}$q 1
   % 2

The significant thing here is that (in the above example) $q will contain an anonymous proc which will byte compile itself.  So subsequent invocations of {*}$q will '''not''' incur a recompilation.  The anonymous proc will persist as long as it's not shimmered away, and can be passed around as a value!

This is ubercool - guilt-free [lambda].

[NEM] notes also that in many places where lambdas are useful, the explicit
[{*}] is not necessary -- e.g. most commands which accept callbacks will
automatically expand the command anyway:

 % lsort -command [lambda {x y} {
     expr {[string length $x] < [string length $y]}
   }] "My name is Neil"
 name Neil My is
 % trace add variable ::foo write [lambda args {
     puts "foo = $::foo"
 }]
 % set foo 12
 foo = 12
 12

----
[pmarin]. Scheme like define:

 proc def { _name arglist body {ns {}} } { 
    upvar $_name name        
    set name [list ::apply [list $arglist $body $ns]]
 }
   
 def q {x} {incr x}
 >{*}$q 1
 2

With this unknown function is possible to call an anonymous proc like a normal proc (without "{*}$" )

 rename unknown _original_unknown
 proc unknown args {
    set _name [lindex $args 0]        
    upvar $_name name
    if { ![catch {set name }]} {
       if { [lindex $name 0] == "::apply"} {
          return [uplevel 1 [list {*}$name {*}[lrange $args 1 end]]]
       } 
    }
    uplevel 1 [list _original_unknown {*}$args]
 }
 
 >def q {x} {incr x}
 ::apply {x {incr x} {}}
 >q 1
 2

[Duoas] 2009-12-30 09:22

I think it worth noting that abusing the '''unknown''' proc with '''lambda'''s is just a way to walk circles around Tcl's '''proc''' command, and, IMHO, negates the guiltlessness of lambda. If you are going to give a name to a proc, why not do it the Tcl way? The usefulness of '''lambda''' is nicely illustrated by [NEM] above -- where he applies a truly nameless proc to his commands. Once the proc is named, there is no point to a lambda.

 % proc q {x y} {
    return [expr {[string length $x] < [string length $y]}]
 }
 % lsort -command q [list My name is Michael]
 Michael name My is

If all you want is to keep a proc name out of the global namespace, then use a private namespace for your proc names.

My $0.02.

[pmarin] 2009-12-30
The Unknown proc is just another tool in my ''toolbox'', you are free to use it or not :)
You can specific the namespace for the unknown command if you like. You can also to name a lambda function using a interp alias: 

======
interp alias {} q {} [lambda {x} {incr x} ] }
======

I have written the function becouse when I am prototyping with Tcl I find the language too verbose (to type "{*}$" is not very comfortable in a spanish keyboard) so I have a lot of shorthands in my ''toolbox'' like `car, cdr, system, dir, sleep, date` and so on that make the language less verbose and fun, later many of them are removed from the code. 

Hacking the syntax is one of the cool things of Tcl, without it is like to use C without pointers.
----
[[ [Category Example] ]]