Wrapl, The Programming Language

Basic Expressions

NIL

Evaluates to the constant Std.Object.Nil, used to denote the absence of any other value.

BACK

Fails to produce any value, causing the current expression to backtrack.

. expr

Returns the value of expr. If expr is a reference, then . expr returns the current value of expr without any reference.

? expr

Returns the type of expr.

expr₁ == expr₂

Returns expr₂ if expr₁ and expr₂ are the same object, fails otherwise.

expr₁ ~== expr₂

Returns expr₂ if expr₁ and expr₂ are not the same object, fails otherwise.

Structure Expressions

[expr₁, ..., expr_k]

Returns a list (instance of Std.List.T) with elements expr₁, expr₂, ..., expr_k

{expr_k1 IS expr_v1, ..., expr_kk IS expr_vk}

Returns a table (instance of Std.Table.T) with pairs (expr_ki, expr_vi). Any value expr_vj is omitted, the value NIL is used.

ALL expr

Returns a list of all the values produced by expr.

UNIQ expr

Returns a table with the (unique) values produced by expr as keys.

METH :method(signature) IS expr

where signature is of the form [@|= expr₁], ..., [@|= expr_k].

Adds expr (which should be an invokable object) to :method corresponding to signature, where @ type denotes a type match and = value denotes a value match, using Std.Symbol.Set. Returns expr.

The old keyword can still be used instead of .

Assignment Expressions

expr₁ <- expr₂

Assigns the value of expr₂ to the reference produced by expr₁. If expr₁ does not evalute to a reference then Wrapl.Loader.IncorrectAssignMessageT message is sent. Within the evaluation of expr₂ the special variable $ can be used to refer to the current value of expr₁.

expr₁ -> expr₂

Assigns the value of expr₁ to the reference produced by expr₂. If expr₁ does not evalute to a reference then Wrapl.Loader.IncorrectAssignMessageT message is sent.

Function Expressions

<id₁[+][| expr], ..., id_k[+|*]> expr

Creates a new function object with parameters id₁, ..., id_k and body expr. If a parameter is followed by + it is passed by reference, other it is passed by value. A * after the final parameter indicates that it is a variadic parameter, any extra arguments are collected into a Wrapl.Loader.VariadicT and passed in this parameter.

<> VAR expr

Creates a new Std.Function.VariableT object that returns the variable produced by expr. This is equivalent to a call to Std.Function.VariableNew with expr.

<> DEF expr

Creates a new Std.Function.ConstantT function object that returns the value produced by expr. This is equivalent to a call to Std.Function.ConstantNew with expr.

TO :method(signature) [ VAR | DEF ] expr

where signature is of the form [id₁[+]] [@|= expr₁], ..., [id_k[+|*]] [@|= expr_k].

Equivalent to METH :method(signature') IS func (see here) where signature' is the type/value information in signature (i.e. ignoring any identifiers and pass-by-reference markers) and func is the function: <id₁[+], ..., id_k[+]> [ VAR | DEF ] expr (creating unique id's for those omitted). Returns func.

The old keyword can still be used instead of .

Function Invocation Expressions

expr₀(expr₁, ..., expr_k)

Calls the function expr₀ with arguments expr₁, ..., expr_k. If the function fails, expr_k is resumed and the function is called again. If expr_k fails, expr_k-1 is resumed, and so on.

expr₀{expr₁, ..., expr_k}

Calls the function expr₀ with arguments expr₁, ..., expr_k. If the function fails, each expr₁, expr₂, ..., expr_k is resumed and the function is called again.

Function Control Expressions

RET expr

Returns expr from the current function.

FAIL

Exits the current function without producing any value (failing).

SUSP expr

Suspends the current function producing the value expr. If the function in resumed, evaluation continues with SUSP expr producing the value of expr.

Conditional Expressions

expr₀ [=> expr₁] [// expr₂]

If expr₀ succeeds, returns the values produced by expr₁ otherwise returns the values produced by expr₂. If the failure clause (// expr₂) is omitted and expr₀ fails, the entire expression fails. If the success clause (=> expr₁) is omitted and expr₀ succeeds, the entire expression fails.

Scope Expressions

({decl;|expr;})

Creates a new scope for the evaluation of each declaration decl and each expression expr. The block expression produces the value(s) of the last expression in the block. A block expression can contain a RECV expression for handling message.

WITH id₁ <- expr₁, ..., id_k <- expr_k DO expr

For each i = 1, ..., k: binds id_i to the value of expr_i and produces the values produced by expr. If expr_i produces an assignable reference, then id_i will be assignable.

expr₁.expr₂

Normally, an expression of the form id₁.id₂ denotes the variable/constant id₂ imported from the module id₁. However, if id₁ is not a constant then a runtime call to :"." is made. Thus expr₁.expr₂ is equivalent to :"."(expr₁, expr₂) except when expr₂ is an identifier, in which case expr₁.id₂ is equivalent to :"."(expr₁, "id₂").

Loop Expressions

REP expr

Repeatedly evaluates expr.

EVERY expr₀ DO expr₁

For each value produced by expr₀ evaluates expr₁.

STEP

Causes the current loop to start its next iteration.

EXIT expr

Exits the current loop with the value(s) of expr. Note that expr is evaluated in the context directly outside the loop, in particular this affects STEP, EXIT and SEND expressions.

WHILE expr and UNTIL expr

WHILE expr is equivalent to expr // EXIT NIL.

UNTIL expr is equivalent to expr => EXIT NIL.

Generator Control Expressions

expr₁ & expr₂

For each value produced by expr₁, produces all the values of expr₂. If expr₁ fails then the entire expression fails, thus expr₁ & expr₂ behaves like a shortcut logical and expression which returns it's second operand if it succeeds.

expr₁ \ expr₂

For each value V produced by expr₁, produces V for each value produced by expr₂. Within the evaluation of expr₂ the special variable $ can be used to refer to the value produced by expr₁, thus expr₁ \ expr₂ can be used to mean "such that".

expr₁ | expr₂

Produces all the values produced by expr₁ followed by the values produced by expr₂. Since expr₁ | expr₂ will produce a value if either expr₁ or expr₂ succeeds, it behaves like a shortcut logical or expression.

expr₁ ! expr₂

Causes expr₁ and expr₂ to produce values in parallel: for each value produced by expr₁ the next value produced by expr₂ is returned. The expression fails when either expr₁ or expr₂ fails.

expr₁ # expr₂ # ... # expr_k

Generates the values produced by expr₁, expr₂, ..., expr_k in an interleaved fashion; i.e. the first value produced by expr₁ is produced, followed the first from expr₂ and so on until the first value from expr_k is produced. Then the second value from expr₁ is produced, then the second from expr₂ and so on. The expression fails when any of expr₁, expr₂, ..., expr_k fail.

expr₁ OF expr₂

Produces the first expr₁ values produced by expr₂.

expr₁ SKIP expr₂

Produces all but the first expr₁ values produced by expr₂.

@ expr

Generate all the values of expr repeatedly. If expr fails to produce any values, then the entire expression fails.

SUM expr

Returns the sum of the values produced by expr. Fails if expr fails to produce any values.

PROD expr

Returns the product of the values produced by expr. Fails if expr fails to produce any values.

COUNT expr

Returns the number of values produced by expr. Returns 0 if expr fails to produce any values.

Iterator Expressions

DO expr

Returns an instance of Std.Function.IteratorT which produces the values produced by expr.

USE expr

Returns the next value produced by expr which should be an instance of Std.Function.IteratorT.

Message Handling Expressions

RECV id DO expr

Catches messages sent in the current block. The message sent is assigned to id and value(s) produced by expr is returned as the value of the block. Note that RECV expressions receive all messages, it is therefore necessary to resend unhandled messages using SEND.

SEND expr

Sends expr as a message. The first enclosing (at runtime) RECV expr will receive the message.

Precompiled Expressions

`expr`

Produces the value of expr as evaluated at compile time. If expr fails or sends msg at compile time, then `expr` is equivalent to BACK or SEND msg respectively. Since expr is evaluted at compile time, it may only use constants and global variables.