If you haven't seen closures before (e.g., lambda in Scheme or LISP),
the idea of a block may be somewhat confusing.  This message is to try
to explain one way to thinking about what a block does.
(For those who have seen it before, we're going to use the beta rule
from the lambda calculus.)

Let's consider 1 argument blocks first.

We may calculate the value of sending a block the value: message as follows
 [ :x | x + 2 ] value: 3
= <by definition>
 3 + 2
= <by arithmetic>
 5

To expand on the "by definition" above:
you can think of [ :x | x + 2 ] as a procedure (unnamed) that takes 1 argument,
called x, with body x+2 (or "return x+2" for C fans).
The expression
 [ :x | x + 2 ] value: 3
assigns 3 to x, and then runs the expression "x + 2" in that environment,
when we look up the x in "x + 2", we get 3...

Another calculation may help:
 [ :y | (y + 2) print. y ] value: 4
= <by definition>
 (4 + 2) print.  4
= <by arithmetic>
 "6 printed, then"
 4
To handle side effects like the above example, it's helpful to introduce
more notation: let Effect(exp,env) stand for the effect of expression exp
in the environment env.  We write environments (in ASCII) as { x |-> 3},
meaning the function that binds x to 3.  The result of Effect is a value
and a new environment.  For example Effect(y <- 2, {y |-> 4}) = (2, {y |-> 2}).
Two more things.  The notation (val,env) - v where (val,env) is a pair
of a value and an environment is pair (val,env'), where env' is the same
as env, except that it is undefined on v.
The notation f + {x |-> y} means the function g
such that g(x) = y, and for w not equal to x, g(w) = f(w).
So we can calculate:
 Effect([ :z | i <- z + 1. z ] value: 3, {i |-> 2})
= <by definition>
 Effect(i <- z + 1. z, {i |-> 2} + {z |-> 3}) - z
= <by definition of + for environments>
 Effect(i <- z + 1. z, {i |-> 2, z |-> 3}) - z
= <meaning of assignment>
 Effect(z, {i |-> 4, z |-> 3}) - z
= <meaning of a variable>
 Effect(3, {i |-> 4, z |-> 3}) - z
= <meaning of - for (val,env) pairs>
 Effect(3, {i |-> 4})

So in general, the meaning of a block with one argument is as follows:
 Effect([ :fml | body ] value: actl, env)
=
 Effect(body, env + {fml |-> actl}) - fml
In words, evaluate the body in an environment where the formal is bound
to the actual, and return the result (together with any side effects on
the environment).  We could treat side-effects to the store similarly,
but this would really get us into denotational semantics...

Briefly, the meaning of a zero argument block is as follows
 Effect([ body ] value, env) = Effect([ :fresh | body] value: nil, env)
			where fresh is a variable that does not occur
				either in body or in the domain of env.
Finally, the meaning of a n>1 argument block can be expressed in terms
of the meaning of an n-1 argument block as follows:
 Effect([ :v1 :v2 ... :vn |body ] value: arg1 ... value: argn, env)
=
 Effect(([ :v1 | [ :v2 ... :vn | body]] value: arg1)
				 value: arg2 ... value: argn, env)

I'll let you puzzle that out for yourself; or just try it out.

	Gary