SS: This is a Pure TCL implementation of TIP187. Note that the semantic is the same, including the fact that lambda will never leak. The only difference with the TIP is the "prcedence" of lambda. In this implementation the order is: command lookup, lambda lookup, unknonw call. This should not make any difference.
# Pure Tcl implementation of TIP 187 (Procedures as Values)
# Copyright(C) 2004 Salvatore Sanfilippo <antirez (at) invece (dot) org>
# Under the Same license as Tcl8.4
namespace eval tip187 {set counter 0}
rename unknown tip187_orig_unknown
proc unknown args {
set func [lindex $args 0]
set funcargs [lrange $args 1 end]
if {[llength $func] == 3 && [lindex $func 0] eq {lambda}} {
set c [incr ::tip187::counter]
set t [list proc ::tip187::lambda$c [lindex $func 1] [lindex $func 2]]
if {![catch {uplevel $t}]} {
set retval [uplevel ::tip187::lambda$c $funcargs]
rename ::tip187::lambda$c {}
return $retval
}
catch {rename ::tip187::lambda$c {}}
} else {
uplevel tip187_orig_unknown $args
}
}
proc lambda {arglist body} {
list lambda $arglist $body
}
### Variadic MAP version
proc map {func args} {
if {[llength $args] > 1} {
for {set j 1} {$j < [llength $args]} {incr j} {
if {[llength [lindex $args $j]] != [llength [lindex $args 0]]} {
error "Lists of different length as input for \[map\]"
}
}
}
set result {}
for {set i 0} {$i < [llength [lindex $args 0]]} {incr i} {
set callargs {}
for {set j 0} {$j < [llength $args]} {incr j} {
lappend callargs [lindex [lindex $args $j] $i]
}
lappend result [eval [list $func] $callargs]
}
return $result
}
### Examples ###
set l1 {1 2 3 4 5}
set l2 {10 20 30 40 50}
set l3 [map [lambda {x y} {expr $x+$y}] $l1 $l2]
puts $l3EB: These examples fails:
% map [list string length] {az bn dfg}
invalid command name "string length"
% lsort -command [lambda {x y} {expr {$x < $y}}] {2 4 1}
wrong # args: should be "lambda arglist body"[map] must be used with with a command or a lambda, not a command prefix, and lambda must be list-quoted. Sounds counter-intuitive to me.
% lsort -command [list [lambda {x y} {expr {$x < $y}}]] {2 4 1}
4 2 1SS: It must be list quoted for a lsort specific issue, actually the option does not do what the name is suggesting (i.e. using the -command option as a command), but is using eval. You can't even use a standard procedure if its name contains spaces in the same condition. This lambas works in any place where a command is expected, If instead a "token" is expected it must be list-quoted.
About your first example, it's not correct. The correct version is:
map [list lambda x {string length $x}] {az bn dgf} ; # => {2 2 3}But you can kill "list" if you want and just write
map [lambda x {strnig length $x}] {az bn dgf}DKF: Actually lsort's guts are even nastier than that. It does something grotty because like that it can at least be a bit faster, and that makes a huge difference for a sorting engine.
Oh, and if you make the first word of the list returned by [lambda] be itself a command, you can make the lambda engine much more robust against such sloppy use.