I’ve got some more of the specs up at

http://rubyforge.org/cgi-bin/viewvc.cgi/Rameau/Rameau.pdf?root=cougar&view=co

It’s interesting to see the justaposition of all the people putting highly dynamic languages into the CLR and JVM with the Spec# static analysis stuff.

I am a little fuzzier on the details of continuations than closures, though, so perhaps I’m missing something.

I thought, incorrectly mind you, that closures copied the environments that they reference variables from.
This is not true.
Closures maintain pointers to the scopes they reference variables from, thereby keeping outer scopes alive and free from garbage collection.

Copy behavior, or at least copy on write indicative of continuations not closures, which are a whole other ballgame.

Here are some examples of closures that show that the environment is not copied only linked to.

Ruby:
class A
def add_method(name)
method_name = “method” + name.to_s
self.class.send(:define_method, method_name , Proc.new { puts method_name; method_name = “George” + name.to_s } )
method_name = “method” + name.to_s + “2″
self.class.send(:define_method, method_name , Proc.new { puts method_name } )
end
end

a = A.new
a.add_method(:a)
a.add_method(:b)
a.methoda
a.methodb
a.methoda2
a.methodb2

Perl:
#!/usr/bin/perl

sub a
{
$m = 10;
sub b
{
print $m . “\n”;
}

$m = 20;

sub c
{
print $m . “\n”;
}
}
a();
b();
c();

Scheme:
(define (a)
(define b 10)
(define (c) (printf “~a~n” b) (set! b 20))
(set! b 15)
(let ((d (lambda () (printf “~a~n” b))))
(c)
(d)
))

(a)

Since no variable foo is defined within the block, the reference is lexically bound to the foo in the enclosing scope. Note that foo inside the block now refers to the variable, or storage location, of the outer scope’s foo. Thus it is perfectly consistent with the idea of closure for a subsequent change to the value stored in the outer scope’s variable foo to be visible within the block.

Closures mostly come into play when you create a variable at run-time, close over it with a lambda, block, or whatever, and return the resulting closure. You haven’t done this in your examples, so you’re not really testing for closures. Try making a function that returns an incrementor by closing over a counter variable that is created afresh upon function invocation and closing over it with a block that returns 1 plus the variable. Then create a couple of incrementors with your function, store them in variables, and ensure they increment independantly of one another.