[SS] 18Mar2005

This page is a simple introduction to one of the [Jim] features: [closures].
Actually closures in Jim are the sum of many features:

   * [lambda]
   * [static vars] with context capturing
   * [garbage collection]

'''Anonymous procedures'''

Jim has a [lambda] command that creates anonymous procedures. Actually
they are not unnamed at all, just a random name is assigned to procedures
crated using the [lambda] command:

 . set f [lambda x {+ $x $x}]
 <reference.<functio>.00000000000000000000>
 . $f 10
 20
 . $f 5
 10

lambda does not need the ''name'' of the procedure as argument, the name
assigned to the created procedure is instead the return value.

Unlike normal procedures, anonymous procedures in Jim are
''garbage collected''. You don't need to delete they in some explicit
way, as long they are no longer referenced they are automatically
destroied. In other words just don't care to free what [lambda] returns
and you will do the right thing.

'''Static variables'''

Static variables are a set of variables relative to a given procedure
that are persisent accross calls. In other words static vars are the
''state'' of a procedure. In order to create a procedure with static
vars, what is needed is to pass an additional argument to the [proc]
command:

 proc counter {} {{x 0}} {
    incr x
 }

As you can see just after the ''arguments list'', that is empty in the
example, there is the list of static vars associated with the procedure.
The syntax used to specify ''default arguments'', here is used to specify
the initial value of the variable. Because the variable is persistent
to specify the initial value is needed.

This is an interactive usage of the '''counter''' procedure:

 . counter
 1
 . counter
 2
 . counter
 3

Every time I call the procedure, the static '''x''' is incremented, and
the value is returned to the caller. Statics are automatically destroied
when a procedure is destroied.

'''Context capturing'''

In Jim the initialization of static variables is mandatory, but if the
initialization value is not provided directly as in the above example,
it is "captured" from a local variable having the same name of the
static variable. So the above '''counter''' procedure can be written
also in this form:

 set x 0
 proc counter {} x {
    incr x
 }

The initialization value was not specified, so it is obtained from the
value of the '''x''' variable that appears in the context where [proc]
was called. If no local '''x''' variable exists, an error is generated
by the proc command.

'''Closures'''

Static variables can also be used with ''anonymous procedures'' in
exactly the same way. This allows to write the following procedure
that '''creates''' a counter anonymous procedure:

 proc make-counter {} {
     set count 0
     lambda {} count {
         set count [+ $count 1]
     }
 }

Usage example:

 . set a [make-counter]
 <reference.<functio>.00000000000000000001>
 . $a 
 1
 . $a
 2
 . $a
 3

Note how similar the Jim procedure is compared to the scheme version:

 (define (make-counter)
   (let ((count 0))
     (lambda ()
       (set! count (+ count 1))
       count)))

In pratice, Jim supports something very similar to lexical scoping, but
the semantic is much simpler than the one of the Scheme programming language
because the user only need to know about static variables and the feature
of capturing a copy from the context to initialize statics.

We can make the counter procedure smarter, allowing us to specify an
initialization value:

 proc make-counter initval {
     set count $initval
     lambda {} count {
         set count [+ $count 1]
     }
 }

Usage example:

 . set b [make-counter 10]
 <reference.<functio>.00000000000000000002>
 . $b
 11
 . $b
 12

'''More examples'''

The following is a more complex example of closure that uses another feature
of Jim: arrays are not collection of variables but [dict]ionaries.
So an array is just a list with an even number of elements, and you
can still use $var($index) form and so on. A very small example before
to introduce the new closure example:

 . set foo [list x 1 y 2]
 x 1 y 2
 . puts $foo(x)
 1
 . puts $foo(y)
 2
 . set foo(z) 5
 5
 . puts $foo
 x 1 y 2 z 5

It's simple Tcl arrays done The Right Way ;)
Of course because in Jim arrays are values like any other thing a
Jim static can contain an array (that is, a dictionary).
So we can create a '''make-words-counter''' procedure, that returns
a closure that is able to count the number occurrences of words:

 proc make-words-counter {} {
     lambda word {{dictionary {}}} {
         if {$word eq {}} {
             return $dictionary
         }
         if {![info exists dictionary($word)]} {
             set dictionary($word) 0
         }
         incr dictionary($word)
     }
 }

Now we can create a words counter, and use it to count words:

 . set d [make-words-counter]
 <reference.<functio>.00000000000000000000>
 . $d apple
 1
 . $d foo
 1
 . $d bar
 1
 . $d bar
 2
 . $d bar
 3
 . $d apple
 2
 . $d {}
 apple 2 foo 1 bar 3

Called with the empty string the words counter will return the full
dictionary. Usually it returns the number of occurrences of the input
word. As usually we don't need to care to free it at all.

'''Closures as objects'''

Closures are after all code with associated data, this is why they
are somewhat similar to objects. The following is the usual bank account
example done with Jim closures:

 proc make-bank-account {} {
     lambda {method args} {{balance 0}} {
         switch $method {
             see {set balance}
             deposit {incr balance [lindex $args 0]}
             withdraw {set balance [- $balance [lindex $args 0]]}
             default {error "unknown method $method"}
         }
     }
 }

Usage:

 . set a [make-bank-account]
 <reference.<functio>.00000000000000000000>
 . $a deposit 100
 100
 . $a deposit 50
 150
 . $a withdraw 15
 135
 . $a see
 135

Of course it's possible to have multiple bank accounts, and every bank
account will be indipendent, and as usually objects done this way are
automatically garbage collected.