additionally, unnamed complex-msg args no longer need to be prefixed
with a colon. this allows complex-msgs to more closely emulate
traditional function calls. this also applies to the call-operator.
for example, take the following lambda:
var f = [ :x :y | ^x * 2 + y ].
before, this lambda would be invoked using the following syntax:
f(:2 :4).
now, this syntax is used instead:
f(2, 4).
previously, an expression like:
x arg1:a arg2:(c subArg:d).
were being parsed incorrectly. This expression was parsed
as single -arg1:arg2:subArg: message being sent to x. the
parentheses around the `c subArg:d` sub-expression were
being ignored.
now, this expression is correcly parsed as the value
of `c subArg:d` being passed as a parameter to the message
-arg1:arg2:
the var keyword allows greater control over what scope a
particular variable exists in. it clarifies whether a new
variable is being defined or an existing variable is being
assigned to. it will also facilitate the implementation of
global variables.
the () operator can be used to call lambdas in a more functional way than the standard
message-send syntax
for example, with a lambda stored in variable `x`:
x(a:2 b:6).
is equivalent to
x call(a:2 b:6).
the cascade operator now uses the precedence of the last message parsed
to determine the recipient of the subsequent messages, reducing the need
for parentheses and making the semantics of the operator more
predictable.
all messages in a cascade now inherit the precedence of the first
message in the cascade.
