Expressions

simple-expr	::=	value-path
	\|	constructor
	\|	constructor expr
	\|	immediate
	\|	`(` expr `)`
	\|	`{` label `=` expr { `;` label `=` expr } `}`
	\|	simple-expr `.` label

multiple-matching	::=	pattern-list `->` expr
	\|	pattern-list `=>` expr

pattern-list	::=	pattern { pattern }

expr	::=	simple-expr
	\|	simple-expr simple-expr { simple-expr }
	\|	`fun` multiple-matching
	\|	simple-expr `where` [ `rec` ] definition { `and` definition }
	\|	`let` [ `rec` ] definition { `and` definition } `in` expr
	\|	`if` expr `then` expr `else` expr
	\|	prefix-op expr
	\|	expr infix-op expr
	\|	expr `or` expr
	\|	`not` expr
	\|	expr `when` expr
	\|	expr `whenot` expr
	\|	`merge` expr expr expr
	\|	expr `fby` expr
	\|	`pre` expr
	\|	`last` ident
	\|	expr `->` expr
	\|	`run` simple-expr { simple-expr }
	\|	`await` signal-pattern `do` expr
	\|	`match` expr `with` match-handlers `end`
	\|	`reset` expr `every` expr
	\|	`automaton` automaton-handlers `end`
	\|	`present` present-handlers `end`

match-handlers	::=	[ `\|` ] pattern `->` expr { `\|` pattern `->` expr }

present-handlers	::=	[ `\|` ] signal-pattern `->` expr { `\|` signal-pattern `->` expr }

automaton-handlers	::=	[ `\|` ] automaton-handler { `\|` automaton-handler }

automaton-handler	::=	constructor [ pattern ] `->` expr transitions

transitions	::=	є
	\|	`then` state-expression
	\|	`continue` state-expression
	\|	transition { transition }

transition	::=	`until` signal-pattern `then` state-expression
	\|	`until` signal-pattern `continue` state-expression
	\|	`unless` signal-pattern `then` state-expression
	\|	`unless` signal-pattern `continue` state-expression

The precedence and associativity rules are the one of Objective Caml. For special Lucid Synchrone primitives, they are given below: higher precedences come first.

`run`	left
`last`	right
`pre`	-
function application	right
`fby`	left
`when`, `whenot`	left
`merge`	left
... `let`,...	-
`->`	right

3.9.1 Simple expressions

Constants

Expressions consisting in a constant evaluate to an infinite stream made of this constant.

Variables

Expressions consisting in a variable evaluate to the value bound to this variable in the current evaluation environment.

Parenthetised expressions

Function abstraction

fun pattern₁ ... pattern_n -> expr

defines a combinatorial (or state-less) function. This means that expression expr must not contain any state constructions.

fun pattern₁ ... pattern_n => expr

Function application

The expression expr₁ expr₂ is an application. The expression expr₁ must evaluate to a functional value which is applied to the value of expr₂.

The expression expr₁ expr₂ ... expr_n stands for (...(expr₁ expr₂) ... expr_n). No evaluation order is specified.

When expr₁ is a function imported from the host language Objective Caml and expr₂ is a stream then expr₁ expr₂ stands for the point-wise application of expr₁ to every element of expr₂.

Local definitions

let definition₁ and ... and definition_n in expr

let rec definition₁ and ... and definition_n in expr

Reverse local definition

The language provides an alternate form of local definitions written in a reverse order and borrowed from Caml Light. In this way, functions may be defined is a way similar to Lustre. The expression:

simple-expr where [ rec ] definition₁ and ... and definition_n

let [ rec ] definition₁ and ... and definition_n in expr

3.9.2 Operators

The operators written infix-op in the grammar can appear in infix position (between two expressions). The operators written prefix-op in the grammar (section 3.9 can appear in prefix position (in front of an expression).

Classical operators provided by Objective Caml (from the Pervasives module) are imported. As for general scalar value imported from the host language, they become stream operators which are applied point-wisely to streams.

Delays

The expression pre expr is the delayed stream. expr must be a stream. The clock of the result is the clock of expr. The n-th value of the result is the n−1-th value of expr. Its value at the first instant is undefined.

The binary operator fby is the initialized delay operator. The first value of expr₁ fby expr₂ is the first value of expr₁. Its n-th value is the n−1-th value of expr₂.

Shared Memory

The expression last ident denotes a shared memory which contains the last computed value of ident.

Initialization

expr₁ -> expr₂ initializes a stream. The expr_i must be streams of the same type and on the same clock. It returns a stream with the same type and clock. The first value of the result is the first value of expr₁. Then, the n-th value of the result is the n-th value of expr₂.

Point-wise conditional

The expression if expr₁ then expr₂ else expr₃ is the point-wise conditional. expr₁ must be a boolean stream, expr₂ and expr₃ two streams of the same type. The type of the result is the type of expr₂. The expressions expr_i must be on the same clock. The clock of the result is the clock of expr₁. The conditional returns a stream such that its n-th value is the n-th value of expr₂ if the n-th value of expr₁ is true and the n-th value of expr₃ otherwise.

Under-sampling

The expression expr₁ when expr₂ is the under-sampling operator. expr₁ must be a stream and expr₂, a clock made from a boolean stream. The type of the result is the type of expr₁. The expressions expr_i must be on the same clock cl. The clock of the result is a sub-clock cl on expr₂. This expression returns the sub-stream of expr₁ defined for all instants where expr₂ is defined and is true.

Over-sampling

The expression merge expr₁ expr₂ expr₃ merges two complementary streams. expr₁ must be a boolean stream, expr₂ and expr₃ two streams of the same type. The type of the result is the type of expr₂. If expr₁ is on clock cl, expr₂ must be on clock cl on expr₁ (expr₂ must be present when expr₁ is present and true) and expr₃ must be on clock cl on not expr₁. This expression returns a stream such that its n-th value is the n-th value of expr₂ if the n-th value of expr₁ is true and the n-th value of expr₃ otherwise.

3.9.3 Control Structures

The constructions reset, match/with, reset and automaton are control-structures which combine equations and thus belong to the syntactic class of definitions (see section 3.10).

A derived form belonging to the syntactic class of expressions is also provided. The derived form is useful for textual programming whereas the original one is motivated by the graphical representation of dataflow programs. The derived form is only syntactic sugar for the original form.

Awaiting Signals

The expression await spat do expr awaits for the presence of a signal before executing the expression expr. This construction is a short-cut for the expression:

`let`	`automaton`
	`\| Await -> do unless` `spat` `then Go(v)`
	`\| Go(v) -> do emit` `o` `=` `expr` `done`
	`end in`
o

provided o is a fresh name and v is the list of free variables from the signal pattern spat.

Pattern Matching

The expression match expr with pat₁ -> expr₁ | …| pat_n -> expr_n end is a short-cut for the expression:

`let`	`match` expr `with`
	`\|` pat₁ `->` `do` o `=` expr₁ `done`
	…
	`\|` pat_n `->` `do` o `=` expr_n `done`
	`end` `in`
o

Modular Reset

The expression reset expr₁ every expr₂ is a short-cut for let reset o = expr₁ every expr₂ in o, provided o is a fresh name.

Automata

The expression automaton state₁ -> expr₁ trans₁ | …| state_n -> expr_n trans_n end is a short-cut for the expression:

Testing the Presence

The expression present spat₁ -> expr₁ | …| spat_n -> expr_n end is a short-cut for the expression:

let	`automaton`
	`\|` state₁ `->` `do` o = expr₁ trans₁
	…
	`\|` state_n `->` `do` o = expr_n trans_n
	`end in`
o

`let`	`present`
	`\|` spat₁ `->` `do` o `=` expr₁ `done`
	…
	`\|` spat_n `->` `do` o `=` expr_n `done`
	`end` `in`
o

3.9 Expressions