Historically, XL implemented a rule that in patterns, any name that was already visible was seen as a constant. This allowed the following definition of if statements to work as long as true and false were in scope:
if true then X else Y is X
if false then X else Y is Y
The three main problems with this approach were that:
There was a difference between true and X, one being a constant, the other being a formal parameter, that was not obvious by reading the code and required the whole context to understand.
The code above would be broken if someone defined X in the same scope, since now X would become a constant instead of a formal parameter.
It forced the programmer to introduce named constants for expressions such as sqrt 2.
These three problems are solved in the documentation by introducing the notion of metabox. A metabox is written as [[Expr]] and evaluates to Expr in all contexts. With the metabox notation, the proper definition for if becomes:
if [[true]] then X else Y is X
if [[false]] then X else Y is Y
The previous definition will indeed make true a formal parameter.
The metabox notation can also be used in normal evaluation context in cases where evaluation of an expression must be forced. This is the case with the definition of the for loop:
for N:name in R:[range of discrete] loop Body is
loop_context is
[[N]] : R.type := R.first
LoopVar is loop_context.[[N]]
while LoopVar <= R.last loop
(loop_context) (Body)
++LoopVar
Here, N is a name parameter, which may contain for example I when the pattern matches
for I in 1..5 loop
print "I=", I
If loop_context was written as:
loop_context is
N : R.type := R.first
N would not be evaluated in a type annotation, but instead would create a local variable named N.
Similarly, the expression loop_context.N would not evaluate N but look it up in loop_context, where it does not exist since the variable there is called I. Using the metabox forces N to be evaluated, so that this transforms into loop_context.I, which will find I.
Metabox are a recent addition to the language are are not implemented neither in the compiler nor the interpreter.
Historically, XL implemented a rule that in patterns, any name that was already visible was seen as a constant. This allowed the following definition of
ifstatements to work as long astrueandfalsewere in scope:The three main problems with this approach were that:
trueandX, one being a constant, the other being a formal parameter, that was not obvious by reading the code and required the whole context to understand.Xin the same scope, since nowXwould become a constant instead of a formal parameter.sqrt 2.These three problems are solved in the documentation by introducing the notion of metabox. A metabox is written as
[[Expr]]and evaluates toExprin all contexts. With the metabox notation, the proper definition forifbecomes:The previous definition will indeed make
truea formal parameter.The metabox notation can also be used in normal evaluation context in cases where evaluation of an expression must be forced. This is the case with the definition of the
forloop:Here,
Nis anameparameter, which may contain for exampleIwhen the pattern matchesIf
loop_contextwas written as:Nwould not be evaluated in a type annotation, but instead would create a local variable namedN.Similarly, the expression
loop_context.Nwould not evaluateNbut look it up inloop_context, where it does not exist since the variable there is calledI. Using the metabox forcesNto be evaluated, so that this transforms intoloop_context.I, which will findI.Metabox are a recent addition to the language are are not implemented neither in the compiler nor the interpreter.