Previous Contents Next

---

3.8 Processes and expressions

The join-calculus possesses two base syntactic classes: processes and expressions. Processes form the skeleton of the join-calculus as a concurrent language, whereas expressions are more oriented toward functional programming. Both processes and expressions have a similar concrete syntax. Generally, they are discriminated by context: expressions are adequate in a context where a result is needed (such as arguments to message sending), whereas processes occur where some actions are to be performed.

A noticeable exception to the uniformity of concrete syntax is grouping, which is performed using curly braces {...} in the process case, and parenthesis (...) in the expression case. Such groupings can be used to disambiguate between processes and expressions. This trick is mandatory in the branches of the conditional construct if... then... else... , where curly braces {...} must be used in the process case.

The table below shows the relative precedences and associativity of operators and non-closed constructions. The constructions with higher precedence come first. For infix symbols, we write ``*...'' to mean ``any symbol starting with *''.

3.8.1 Basic constructs

Empty process

The empty process ``'' does nothing. Its presence can be emphasized by using process grouping { } .

Constants

Expressions consisting in a constant evaluate to this constant.

Names as expressions

When occurring alone in an expression context, names evaluate to the value they are bound to. Names bound to primitives are not allowed as expressions, and cause a runtime-error.

Message passing

The construct a ( expr ₁ , ... , expr _n ) denotes sending the results of the evaluations of expr ₁ , ..., expr _n on the port name (or the primitive) a . The expressions expr ₁ , ..., expr _n are evaluated in some unspecified order. In a process context, the name a must be asynchronous, whereas in an expression context, the name a must be synchronous. This constraint is checked when typing programs.

Note that channels are polyadic in their arguments. Polyadicity also occur at the result level: a synchronous channel takes n arguments and gives back m result, where n and m are any integer greater than or equal to zero.

Some synchronous binary channels can be invoked using infix notation: expr ₁ full-infix-name expr ₂ is equivalent to full-infix-name ( expr ₁ , expr ₂ ).

Continuation invocation

The process reply expr ₁, ... , expr _n to name executes by sending the message expr ₁, ..., expr _n on the continuation of name . As the continuation of name is an implicit argument to name , the reply ... to name construct may only occur in a process guarded by a join pattern that defines name (see below). In the current implementation, some additional restrictions apply to continuation usage (see section 7.4).

When name is the only channel being defined, the to name part can be omitted.

Channel definitions

New channels are defined by the process-decl construct. The simple declaration join-pattern = process is both a definition for some fresh channel names and the specification of a synchronization pattern on these names (see section 3.7). This synchronization guards process .

Channel definitions are recursive definitions: if a is a port named defined by join-pattern above, then a may occur free inside process and its occurrence refers to the channel defined by the declaration join-pattern = process .

The composite declaration join-pattern ₁ = process ₁ and ... and join-pattern _n = process _n is a definition for all the names that the simple declarations join-pattern ₁ = process ₁, ...join-pattern _n = process _n define. The same channel name a may be defined by several simple declarations inside a composite declaration. Then, only one fresh channel a is defined and channel a takes part to several synchronizations.

Value binding

Any value in the language can be bound to a name by using the expr-decl construct. Evaluating a declaration x ₁ , ... , x _n = expr is evaluating expr , which must return n values, which are then bound to x ₁ , ..., x _n. Basically, expr is a message sending construct on a synchronous channel that gives back n results. Such basic n-ary expressions can be combined by using other language constructs such as conditionals or local definitions.

Value bindings are non-recursive: in x ₁ , ... , x _n = expr , the scope of x ₁, ..., x _n does not comprise expr . Similarily, the scope of the x _jⁱ in x ₁¹ , ... , x _n¹ = expr ₁ and ... and x ₁^m , ... , x _p^m = expr _m , does not comprise the expr _j. Such composite value binding are evaluated in some unspecified order and all the names they bind must be different.

Location definitions

The simple location definition loc name with process-decl init process end executes by making a new location, which is bound to name , whose initial active channels are defined by process-decl , and whose initial active process is process . Note that both initial active channels definition and initial active process may be omitted.

The composite location definition agent ₁ and ... and agent _n is the simultaneous definition of n locations. Such a declaration is recursive, that is the scope of the location and initial port names defined by agent ₁, ...agent _n comprises the whole composite definition.

Local definitions

The decl in process and decl in expr constructs bind values locally both inside processes and expressions.

They are evaluated by first evaluating decl , binding some new names, then evaluating expr or executing process in an environment extended by the new names defined in decl . In an expression context, the result of evaluating the decl in expr construct is the result of evaluating expr .

3.8.2 Control structures

Sequence

The expression expr ₁ ; expr ₂ evaluates expr ₁ first, then expr ₂, and returns the value of expr ₂. The process expr ₁ ; process ₂ executes expr ₁ first, then it executes process ₂. The expression expr ₁ must return an empty result. In fact, sequence is a shorthand for a zero-ary local value binding let = expr in ....

Concurrent execution

The process process ₁ | process ₂ executes by concurrently executing process ₁ and process ₂. The expression spawn { process } launches the concurrent execution of process and returns an empty result.

Conditional

The process if expr ₁ then { process ₂ } else { process ₃ } executes process ₂ if expr ₁ evaluates to the boolean true, and process ₃ if expr ₁ evaluates to the boolean false. The else process ₃ part can be omitted, in which case it defaults to else {}.

The expression if expr ₁ then expr ₂ else expr ₃ evaluates to the value of expr ₂ if expr ₁ evaluates to the boolean true, and to the value of expr ₃ if expr ₁ evaluates to the boolean false. The else expr ₃ part can be omitted, in which case it defaults to an expression that returns zero result.

3.8.3 Operators

Symbols from the class infix-symbols can appear in infix position (between two expressions). Infix symbols do not have a fixed meaning: they are simply interpreted as message sending on the channels corresponding to the symbols.

The table below lists the symbols defined in the initial environment and their initial meaning. (See the description of the standard library module sys in chapter 4 for more details). Their meaning may be changed at any time using let infix-op ( x ₁ , x ₂ ) = ...

---

Previous Contents Next