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.    
----
[[ [Category Example] ]]