3 Context-Free Syntax

Statements

<statement>	::=	<statement> <statement>
	|	local <in statement> end
	|	"(" <in statement> ")"
	|	proc { <atom> } "{" <expression> { <pattern> } "}"
		<in phrase>
		end
	|	fun { <atom> } "{" <expression> { <pattern> } "}"
		<in expression>
		end
	|	"{" <expression> { <expression> } "}"
	|	if <expression> then <in statement>
		[ <else statement> ]
		end
	|	case <expression> of <case statement clause>
		{ [] <case statement clause> }
		[ <else statement> ]
		end
	|	lock <expression> then <in statement> end
	|	thread <in statement> end
	|	try <in statement>
		[ catch <case statement clause> { "[]" <case statement clause> } ]
		[ finally <in statement> ]
		end
	|	raise <in expression> end
	|	<expression> "=" <expression>
	|	<expression> ":=" <expression>
	|	<expression> "." <expression> ":=" <expression>
	|	skip

Expressions

<expression>	::=	local <in expression> end
	|	"(" <in expression> ")"
	|	proc { <atom> } "{" "$" { <pattern> } "}"
		<in phrase>
		end
	|	fun { <atom> } "{" "$" { <pattern> } "}"
		<in expression>
		end
	|	"{" <expression> { <expression> } "}"
	|	if <expression> then <in expression>
		<else expression>
		end
	|	case <expression> of <case expression clause>
		{ [] <case expression clause> }
		[ <else expression> ]
		end
	|	lock <expression> then <in expression> end
	|	thread <in expression> end
	|	try <in expression>
		[ catch <case expression clause> { "[]" <case expression clause> } ]
		[ finally <in statement> ]
		end
	|	raise <in expression> end
	|	<expression> "=" <expression>
	|	<expression> orelse <expression>
	|	<expression> andthen <expression>
	|	<monop> <expression>
	|	<expression> <binop> <expression>
	|	<expression> ":=" <expression>
	|	<expression> "." <expression> ":=" <expression>
	|	<possibly escaped variable>
	|	"_"
	|	<atom> | <int> | <float>
	|	unit | true | false
	|	<label> "(" { <subtree> } [ "..." ] ")"
	|	"[" { <expression> }+ "]"
	|	<expression> "|" <expression>
	|	<expression> { "#" <expression> }+
	|	"$"

<label>	::=	<variable label> | <atom label>
	|	<unit label> | <true label> | <false label>

<feature>	::=	<variable> | <atom> | <int>
	|	unit | true | false

<subtree>

::=

[ <feature> ":" ] <expression>

Precedence

Note that in both <statement>s and <expression>s there is potential ambiguity between <expression> ":=" <expression> and <expression> "." <expression> ":=" <expression>. In fact ". :=" is a ternary operator and has precedence. Parenthesis must be used for the alternate parse, that is, (<expression>"."<expression>) ":=" <expression>.

Operators

Expressions with operators need additional disambiguating rules introduced in Section 3.5.

<monop>

::=

"~" | "!!" | "@"

<binop>	::=	"." | "^"
	|	"==" | "\=" | "<" | "=<" | ">" | ">="
	|	"+" | "-" | "*" | "/" | div | mod

Declarations

A <declaration part> is a sequence of variables and statements. Singleton variables serve only for explicit declaration and are otherwise ignored. Variables within statements are implicitly declared if they occur at a pattern position. A prefixed escape (!) prevents implicit declaration.

<declaration part>	::=	<variable>
	|	<statement>
	|	<declaration part> <declaration part>

<in statement>

::=

[ <declaration part> in ] <statement>

<in expression>

::=

[ <declaration part> in ] [ <statement> ] <expression>

<possibly escaped variable>

::=

[ "!" ] <variable>

Patterns

Pattern matching is performed as a top-down left-to-right sequence of tests. Record patterns test a value's constructor; constant patterns and escaped variable patterns test for equality with the given value; nonlinearities (variables occurring multiply in one pattern) test for equality of the corresponding subtrees. Equation patterns and non-escaped variables introduce variable bindings.

<pattern>	::=	<label> "(" { <subpattern> } [ "..." ] ")"
	|	"[" { <pattern> }+ "]"
	|	<pattern> "|" <pattern>
	|	<pattern> { "#" <pattern> }+
	|	<atom> | <int> | <float>
	|	unit | true | false
	|	<possibly escaped variable>
	|	"_"
	|	<pattern> "=" <pattern>
	|	"(" <pattern> ")"

<subpattern>

::=

[ <feature> ":" ] <pattern>

Else Clauses

If the else part to an if statement is omitted, it is taken to be else skip. The else part to an if expression is mandatory.

Statements

<statement>	+=	<fd compare>
	|	<fd in>
	|	fail
	|	not <in statement> end
	|	cond <cond statement clause>
		{ "[]" <cond statement clause> }
		[ else <in statement> ]
		end
	|	or <dis statement clause> { "[]" <dis statement clause> }+ end
	|	dis <dis statement clause> { "[]" <dis statement clause> }+ end
	|	choice <in statement> { "[]" <in statement> } end

<cond statement clause>

::=

[ <declaration part> in ] <statement> then <in statement>

<dis statement clause>

::=

[ <declaration part> in ] <statement> [ then <in statement> ]

Expressions

<expression>	+=	<fd compare>
	|	<fd in>
	|	fail
	|	cond <cond expression clause>
		{ "[]" <cond expression clause> }
		[ else <in expression> ]
		end
	|	or <cond expression clause> { "[]" <cond expression clause> }+ end
	|	dis <cond expression clause> { "[]" <cond expression clause> }+ end
	|	choice <in expression> { "[]" <in expression> } end

<cond expression clause>

::=

[ <declaration part> in ] <statement> then <in expression>

<fd compare>

::=

<expression> ( "=:" | "\=:" | "<:" | "=<:" | ">:" | ">=:" ) <expression>

<fd in>

::=

<expression> ( "::" | ":::" ) <expression>

Class Definitions

<statement>	+=	class <expression>
		{ <class descriptor> }
		{ <method> }
		end

<expression>	+=	class [ "$" ]
		{ <class descriptor> }
		{ <method> }
		end

<class descriptor>	::=	from { <expression> }+
	|	prop { <expression> }+
	|	attr { <attr or feat> }+
	|	feat { <attr or feat> }+

Methods

The first-class message used to invoke a method can be referenced by appending = <variable> to the method head. This message does not contain defaulted arguments (see below) if they have not been explicitly given.

<method>	::=	meth <method head> [ "=" <variable> ]
		<in phrase>
		end

Operations

To the following operators, self is an implicit operand. Their use is syntactically restricted to the body of method definitions.

<statement>	+=	lock <in statement> end
	|	<expression> ":=" <expression>
	|	<expression> "<-" <expression>
	|	<expression> "," <expression>

The assignment operators ":=", "<-", when used in an expression position, perform an atomic exchange, the result of the operation being the previous value of the attribute assigned to.

<expression>	+=	lock <in expression> end
	|	"@"<expression>
	|	<expression> ":=" <expression>
	|	<expression> "<-" <expression>
	|	<expression> "," <expression>
	|	self

Import Specification

The import specification names values (usually modules) to be made available to the body. They represent formal arguments to the body abstraction. The additional at clause allows to specify where the actual argument is to come from. This must be an atom (interpreted as a relative URL) so that a functor creating the referenced module may be located at compile time.

<functor descriptor>

::=

import { <import clause> }+

<import clause>	::=	<variable> [ at <atom> ]
	|	<variable label> <import features> [ at <atom> ]

If the expected structure of an imported value is partially specified, occurrences of the module name are restricted to a single syntactic context: the first operand in applications of the dot operator, where the second operand is one of the features mentioned in the import specification.

<import features>

::=

"(" { <module feature> <import alias> }+ ")"

<module feature>

::=

<atom> | <int>

An import alias introduces a variable bound to one of the imported module's subtrees.

<import alias>

::=

[ ":" <variable> ]

Functor Body

The body of the functor is a statement (usually a sequence of definitions that compute the exported values). This statement is a pattern position. Note the difference between this abbreviated declaration and the <in statement> rule: The <statement> following the in keyword is optional, not the <declaration part> preceding it.

<functor descriptor>

+=

define <declaration part> [ in <statement> ]

Export Specification

The export specification specifies the structure the modules created by applications of this functor will have.

<functor descriptor>

+=

export { [ <module feature> ":" ] <variable> }+

The value of the variables mentioned in the export declaration are made available under the given features. If a feature is omitted, then it is computed from the corresponding variable's print name by changing its initial capital letter into a lower-case letter (unless it's a backquote variable, in which case the print name is taken as-is).

Computed Functors

A functor that contains one of the following additional functor descriptors is called a computed functor. The require and prepare clauses correspond to the import and define clauses respectively, only they are executed upon functor definition instead of functor application. The variables introduced by these clauses are visible in the define and export clauses.

<functor descriptor>	+=	require { <import clause> }+
	|	prepare <declaration part> [ in <statement> ]