Nemerle Language Reference

• 1. Introduction
• 2. Lexical Conventions
  • 2.1. Tokens
  • 2.2. Blanks
  • 2.3. Preprocessing directives
  • 2.4. Identifiers
  • 2.5. Keywords
  • 2.6. Literals
• 3. Compilation units
• 4. Stuff that doesn't fit anywhere else
  • 4.1. Identifier or dummy
  • 4.2. Qualified identifier
• 5. Type declarations
  • 5.1. Type header
  • 5.2. Type parameters
  • 5.3. Type alias
  • 5.4. Interface definition
  • 5.5. Class definition
  • 5.6. Structure definition
  • 5.7. Module definition
  • 5.8. Variant definition
  • 5.9. Enum type definition
  • 5.10. Delegate type definition
• 6. Attributes
• 7. Declarations within types
  • 7.1. Field definition
  • 7.2. Property definition
  • 7.3. Event definition
  • 7.4. Interface member
  • 7.5. Method definition
  • 7.6. Operator definition
  • 7.7. Method header
  • 7.8. Method parameters
  • 7.9. Method body
• 8. Type expressions
  • 8.1. Type constructor application
  • 8.2. Type variable reference
  • 8.3. Grouping types
  • 8.4. Void type
  • 8.5. Ref and Out types
  • 8.6. Array types
  • 8.7. Tuple type
  • 8.8. Function type
• 9. Literal expressions
  • 9.1. Boolean
  • 9.2. Null
  • 9.3. Void
  • 9.4. String
  • 9.5. Number
  • 9.6. Character
• 10. Primary expressions
  • 10.1. Literal expression
  • 10.2. Variable reference
  • 10.3. this pointer reference
  • 10.4. base pointer reference
  • 10.5. Grouping expression
  • 10.6. Member reference
  • 10.7. Tuple constructor
  • 10.8. Indexer reference
• 11. Core Expressions
  • 11.1. Primary expression
  • 11.2. Function call
  • 11.3. Assignment
  • 11.4. Match expression
  • 11.5. Throw expression
  • 11.6. Try..catch expression
  • 11.7. Try..finally expression
  • 11.8. Unary operator application
  • 11.9. Binary operator application
  • 11.10. Type cast
  • 11.11. Type enforcement
  • 11.12. One-case matching
  • 11.13. Dynamic type check
  • 11.14. checked/unchecked blocks
  • 11.15. Block expression
  • 11.16. Array constructor
  • 11.17. Value definition
  • 11.18. Local function definition
  • 11.19. Mutable value definition
• 12. Secondary Expressions
  • 12.1. Conditional expression
  • 12.2. While loop
  • 12.3. do ... while loop
  • 12.4. When expression
  • 12.5. Unless expression
  • 12.6. Lambda expression
  • 12.7. List constructor
  • 12.8. Increment operator
  • 12.9. Decrement operator
  • 12.10. Swap operator
• 13. Expression helpers
  • 13.1. Sequence
  • 13.2. Block
  • 13.3. Try..catch handler
  • 13.4. Function parameter
  • 13.5. Match case
• 14. Patterns
  • 14.1. Constructor pattern
  • 14.2. Throw-away pattern
  • 14.3. Record pattern
  • 14.4. As binding
  • 14.5. Type check pattern
  • 14.6. Tuple pattern
  • 14.7. List constructor pattern
  • 14.8. List literal pattern
  • 14.9. Literal pattern
  • 14.10. Type enforcement in pattern
• 15. Macros

1. Introduction

This document presents in a semi-formal way the syntax and semantics of the Nemerle language. It is not meant to be a tutorial.

We often refer to .NET terminology [FIXME: reference it].

2. Lexical Conventions

Programs are written using the Unicode character set. Every Nemerle source file is reduced to a sequence of lexical units (tokens) separated by sequences of white characters (blanks).

2.1. Tokens

There are five classes of lexical tokens:

• identifiers
• type variables
• keywords
• literals
• blanks

/* A comment. */
// Also a comment

foo               // identifier
foo_bar foo' foo3 // other identifiers
42                // integer literal
1_000_000         // _ can be used for readability
1_42_00           // or unreadability...
0x2a              // hexadecimal integer literal
0o52              // octal integer literal
0b101010          // binary integer literal
'a'               // character literal
'\n'              // also a character literal
"foo\nbar"        // string literal
"foo" "bar"       // same as "foobar"
@"x\n"            // same as "x\\n"
@if               // keyword used as identifier

3.14f             // float literal
3.14d, 3.14       // double literal
3.14m             // decimal literal

10         // int
10u        // unsigned int
10b        // signed byte
10ub, 10bu // unsigned byte
10L        // long
10UL, 10LU // unsigned long

2.2. Blanks

Spaces, vertical and horizontal tabulation characters, new-page characters, new-line characters and comments (called blanks altogether) are discarded, but can separate other lexical tokens.

A traditional comment begins with a /*, and ends with */. An end-of-line comment starts with //, and ends with the line terminator (ASCII LF character).

2.3. Preprocessing directives

There is a set of preprocessing directives used for conditional compilation and changing line numbering context. They are the same as in C#. Allowed directives are: #define, #undef, #if, #elif, #else, #endif, #line, #error, #warning, #region and #endregion.

2.4. Identifiers

Ordinary identifiers consist of letters, digits, underscores and apostrophe, but cannot begin with a digit nor an apostrophe. Identifiers may be quoted with the @ character, which is stripped. It removes any lexical and syntactic meaning from the following string of characters until blank, thus enabling programmer to use keywords as identifiers.

There is an important difference between identifiers starting with underscore character _ and the other ones. When you define local value with name starting with _ and won't use it, compiler won't complain about it. It will warn about other unused values though.

Symbolic identifiers consist of following characters: =, <, >, @, ^, |, &, +, -, *, /, $, %, !, ?, ~, ., :, #. Symbolic identifiers are treated as standard identifiers except to the fact that they are always treated as infix operators.

2.5. Keywords

Following identifiers are used as keywords, and may not be used in any other context unquoted: _, abstract, and, array, as, base, catch, class, def, delegate, do, else, enum, event, extern, false, finally, for, foreach, fun, if, implements, in, interface, internal, lock, macro, match, module, mutable, namespace, new, null, out, override, params, private, protected, public, ref, sealed, static, struct, syntax, this, throw, true, try, type, typeof, unless, using, variant, virtual, void, when, where, while, assert, ignore.

Following infix identifiers are reserved keywords: =, $, ?, |, <-, ->, =>, <[, ]>, &&, ||.

2.6. Literals

There are few kinds of literals:

• String literals, enclosed in "". Compiler processes backslash escapes much like in C#. You can use $ operator before the string literal to enable string interpolation feature (the `$' operator is now a shorthand to Nemerle.IO.sprint).

  def x = 40; def y = 42; System.Console.Write ($ "$(x + 2) == $y\n")

  Any expression can be used in $(...), but there might be problems with embedded strings and so on. It is meant to be used with simple expressions like array/field access, method call, etc.
• Raw string literals, written like ordinary string literals, but prefixed with @. Escapes are not processed.
• Character literals, enclosed in '. Escapes are processed.
• Numeric literal are allowed have suffix describing their type as seen in tokens section.
• Integer literals, possibly prefixed with 0x, 0o or 0b to denote hexadecimal, octal or binary encoding respectively.
• Floating point literals, defined as:

  floating_point_literal ::= digits . [ digits ] [ exponential_marker [ sign ] digits ]

  digits ::= { }

  exponential_marker ::= e

  exponential_marker ::= E

  sign ::= +

  sign ::= -

3. Compilation units

A Nemerle program consists of one or more compilation units. Compilation units are text files with the .n extension. A compilation unit consists of namespace-related declarations and types within them.

Add the specified namespace (which, unlike in C#, can also be a type name) to the symbol search path. Every symbol till end of current namespace or compilation unit (if not within namespace) will be searched also in location specified by this path.

Define an alias for a namespace or type. After using Foo = Bar.Baz; any reference to Foo.bar will be expanded to Bar.Baz.bar.

Put declarations within the specified namespace. Namespaces can be nested, creating a tree of namespaces.

Define a new top level type.

4. Stuff that doesn't fit anywhere else

This section lists grammar rules common to most of other sections.

4.1. Identifier or dummy

In several places it is possible to use the _ keyword to denote the intent to ignore a parameter or a return value. Semantics of _ in such places is to generate a new temporary name. For example assigning to _ means ignoring returned value of computed expression.

4.2. Qualified identifier

Identifiers can be qualified with namespaces.

5. Type declarations

Types are defined at the top level, within namespaces or within other types. Top level type names are prefixed with the namespace they are defined in. Nested type names are prefixed with the parent type name. Nesting affects accessibility of a type.

5.1. Type header

Type header is similar to .NET. The main difference is the optional type_parameters list, defined below.

5.2. Type parameters

When defining polymorphic type one has to specify list of type variables in declaration. It can have following form:

class Foo [a, b]

An optional list of where parameters can be used to add constraints to the type variables (type coercion).

where a : Nemerle.Collections.IEnumerable, IComparable
where b : Nemerle.Collections.IDictionary

5.3. Type alias

This type declaration creates an alias to another type.

5.4. Interface definition

Nemerle interfaces are similar to .NET.

5.5. Class definition

Class definition is similar to .NET.

5.6. Structure definition

5.7. Module definition

A module is much like a class, but all module members are static. There is no need to place static attributes on module members. It is also not possible to create instances of module types.

5.8. Variant definition

A variant declaration consists of a type name and a list of bar-separated constructors enclosed in brackets.

The constructor declaration describes the constructor associated to this variant type. A constructor may take an argument. Constructor name must be capitalized.

Variants (unlike variant options) can also have other members (methods and fields).

5.9. Enum type definition

Nemerle enums are similar to enums in C#.

5.10. Delegate type definition

6. Attributes

The semantics of attributes is the same as in C#, except for mutable attribute, meaning lack of readonly.

7. Declarations within types

The following fields are allowed in class or module body:

7.1. Field definition

Unless the optional mutable attribute is used, the field can be modified only inside the constructor.

7.2. Property definition

The fields defined in a property are local for it, they cannot be referenced outside the property.

7.3. Event definition

7.4. Interface member

Keyword new is necessary when the declared method hides the inherited one from another interface.

7.5. Method definition

This is a definition of method within class or module. Program entry point is method static Main.

7.6. Operator definition

Operator definitions must have static attribute. The name of method must be simply any valid OPERATOR, which can be then used (as a prefix or unary operator) on expressions of type specified by parameters.

7.7. Method header

The declaration of a polymorphic method needs its type variables listed after the identifier.

This is a declaration of method. Unlike in C#, the type is specified after the parameters list.

A special method named this specifies a constructor. This declaration cannot contain the method type and the method has to have type void.

7.8. Method parameters

A method parameter is a pair consisting of identifier or _ and its type specification. Type declaration can be omitted in local functions definitions.

Method parameters are comma-separated list of parameter specification.

7.9. Method body

The method body can be linked to an external function, for example:

static ps (s : string) : void = extern "System.Console.Write";

This feature is used to give meaning to infix operators. It is not currently fully supported. It should not be considered rock-stable feature.

Empty method body (a ;) is a method declaration.

This is a classical method definition.

8. Type expressions

Type expressions relate to type declarations much like function calls relate to function and value definitions. Type declarations define ways of constructing types and type expressions define actual types.

Types are both static and dynamic characterization of values. The static type of expression depends on its building blocks and is defined in the paragraph describing given expression. The dynamic (runtime) type is bound to the value at the moment it is created, and remains there until the value is garbage collected.

The type system is modeled after .NET Generics design, except for tuple and function types, which are new, but can be easily simulated using generics.

8.1. Type constructor application

A type constructor (defined with type declaration) can be applied to zero or more arguments forming a type expression. The number of type arguments in type application must match the number of type arguments in definition. Moreover, actual type arguments must solve where constraints imposed on formal type arguments.

8.2. Type variable reference

Refer to the type substituted to a given type variable. The type variable has to be defined (bound, quantified) before it is used. A type variable can be defined in type arguments or method header (of a global or local function).

8.3. Grouping types

This construct has no semantic meaning -- it exists only to enforce particular syntax decomposition.

8.4. Void type

This is mostly an alias for System.Void -- a type with exactly one inhibiting value. It is, however, a first class value -- it can be passed as a function parameter as well as returned from functions.

The name comes from System.Void, but should be in fact unit.

8.5. Ref and Out types

These are for parameters passed by reference.

8.6. Array types

Define array type. The number is the rank. It defaults to one.

8.7. Tuple type

Construct product (tuple) type. This operator is not associative, which means that each two of following types are different:

int * int * int
(int * int) * int
int * (int * int)

8.8. Function type

Construct function type with a specified argument and return types respectively. The -> operator is right associative, which means that the following types are equivalent:

int -> int -> int
int -> (int -> int)

Multi-argument function types are written using tuple notation, for example after local declaration:

def some_function (a : int, b : string) : float { ... }

the expression some_function has type int * string -> float.

9. Literal expressions

These are used in expressions and patterns.

9.1. Boolean

These literals have type bool and represent respectively true (false) boolean value.

9.2. Null

Represents null reference, one that does not refer to any object. It possesses types of all reference types -- can be used in any context reference type is required. It does not, however, possess the void type nor any value type (like System.Int32 or System.Single).

9.3. Void

Indicates returning no value. It is the only possible value of type void. See also void type.

9.4. String

Represents string constant. Nemerle supports two forms of string:

• regular string literals
• verbatim string literals

A regular string literal consists of zero or more characters enclosed in double quotes and may include both simple escape sequences (such as \n for the newline character) and hexadecimal and Unicode escape sequences (See character literals for details).

A verbatim string literal consists of an @ character followed by a double-quote character, zero or more characters, and a closing double-quote character. In a verbatim string literal, the characters between the double-quotes are recognized verbatim, the only exception is a sequence "" (used to indicate '"' character) (Note that simple escape sequences and hexadecimal and Unicode escape sequences are not recognized in verbatim string literals). A verbatim string literal may span multiple lines.

Examples:

def s1 = "Nemerle string !";            // Nemerle string !
def s2 = @"Nemerle string !";           // Nemerle string !
def s3 = "Nemerle\tstring !";           // Nemerle    string !
def s4 = @"Nemerle\tstring !";          // Nemerle\tstring !
def s5 = "I heard \"zonk !\"";          // I heard "zonk !"
def s6 = @"I heard ""zonk !""";         // I heard "zonk !"
def s7 = "\\\\trunk\\ncc\\ncc.exe";     // \\trunk\ncc\ncc.exe
def s8 = @"\\trunk\ncc\ncc.exe";        // \\trunk\ncc\ncc.exe
def s9 = "\"Nemerle\"\nstring\n!";      // "Nemerle"
                                        // string
                                        // !
def s10 = @"""Nemerle""                 // same as s9
rocks
!";

String s10 is a verbatim string literal that spans 3 lines.

9.5. Number

Represents one of numeric types. See literals for details of representing particular numerical types.

9.6. Character

A character literal consists of one character enclosed in single-quotes (' ') or escape character of form '\X' where X can be one of the following: [FIXME: characters with (N) are not implemented yet (will they?)]

• \, ', " - this allows representation of (respectively) backslash, single-quote double-quote
• 0X - where X is an octal ASCII code (up to three digits) of the character we want to represent (N)
• xX - where X is an hexadecimal ASCII code (exactly two digits) of the character we want to represent (N)
• uX - where X is an hexadecimal UNICODE code (exactly four digits) of the character we want to represent (N)
• a - matches a bell (alarm) (N)
• b - matches a backspace \u0008
• r - matches carriage return \u000D
• v - matches vertical tab \u000B (N)
• f - matches form feed \u000C (N)
• n - matches a new line \u000A
• e - matches an escape \u001B (N)
• cX - matches an ASCII control character; for example \cC represents control-C (N)

It has type char.

10. Primary expressions

Primary expressions are a grammar category referring to expressions that have a closed structure and are otherwise simple. Primary expressions and plain expressions do not differ at the semantic level.

10.1. Literal expression

The value and type of an expression being literal is the value and the type of the respective literal.

10.2. Variable reference

This expression result is a variable itself (not its value). [[FIXME: hem?!]] Type of this expression is ref 'a where 'a is a type of variable being referenced.

10.3. this pointer reference

This expression can only be used within non-static methods and indicates a reference to the current instance of the class (which posses this method).

Expression like this.foo can be shortened to foo unless it would generate an identifier ambiguity with some variable being in this lexical scope.

The this keyword can be also used to call instance constructor from another constructor.

10.4. base pointer reference

This expression can only be used within non-static methods and indicates a reference to the current instance of the class coerced to the type of the base class. Calls made on base pointer are non virtual.

The base keyword can be also used to call instance constructor of base class from another constructor.

10.5. Grouping expression

A grouping expression allows to enforce particular syntax decomposition of expression.

10.6. Member reference

This expression allows referring to the field or method that the object represented by primary_expr contains.

10.7. Tuple constructor

This expression allows creating a tuple of expr whose types may differ. The type of that tuple is type_1 * ... * type_n where type_1 and the following are types of corresponding expressions.

10.8. Indexer reference

This expression allows to refer to indexed (even by multiple indexes) fields of objects represented by leftmost expr where second (and further) expr are indexes values of the field we want to refer to. expr must refer to an indexing object.

11. Core Expressions

11.1. Primary expression

The value and type are the same as primary_expr we are referring to.

11.2. Function call

Call a function with given parameters. The type of the function call expression is the same as the type of the function return value; that is, if the function's type is 'a -> 'b, then the type of the function call expression is 'b. The value of the whole expression is the return value of the function.

11.3. Assignment

Assign a value to a variable. The left side of the assignment expression must evaluate to a mutable variable. The type of the assignment is always void.

In earlier versions there was <- assignment operator, which is now (Nemerle 0.2.x) deprecated.

11.4. Match expression

expr is matched sequentially to the patterns in given match cases. If one of the patterns is consistent with the value of expr, then the corresponding computation branch of the match case is evaluated. Patterns in all the match cases must be of the same type. Expressions being computation branches in all the match cases must be of the same type, as well. The type of the match expression is the same as the type of the computation branch in all the match cases.

11.5. Throw expression

Throws given exception. The expression given must be of type System.Exception.

11.6. Try..catch expression

If the evaluation of expr does not throw any exception, then the result is that of the evaluation of expr. Otherwise, the runtime type of the exception which was thrown is compared against each type description in handlers. The first matching handler is executed and its value returned. If none of the handlers matches, the exception is propagated. The type of the whole expression is the same as type of guarded expression. The value is the value of expression or launched handler. Consult .NET specification if you want to know more about exceptions.

The optional finally clause has the same meaning as below.

11.7. Try..finally expression

Evaluates the first expression and -- regardless of whether the evaluation has finished correctly or some exception has been thrown during the evaluation -- the second expression is evaluated. The value (and thus the type) of the whole expression is the value of the first expression.

11.8. Unary operator application

Unary operator for integer types:

• ++ prefix increment with void return type
• -- prefix decrement with void return type

11.9. Binary operator application

There is a number of standard operators, which are predefined for arithmetic types (floating point and integer):

• ~ bitwise negation
• - subtraction
• * multiplication
• / division
• < less comparison
• > more comparison
• <= less-equals
• >= more-equals
• == equality
• != inequality
• += addition with assignment
• -= subtraction with assignment
• *= multiplication with assignment
• /= division with assignment

For integer types only (int, uint, short, ushort, long, ulong, byte, sbyte) there are:

• << left bitwise shift
• >> right bitwise shift
• % modulus
• %= modulus with assignment
• <<= left bitwise shift with assignment
• >>= right bitwise shift with assignment
• | bitwise or
• & bitwise and
• ^ bitwise xor
• %|| bitwise `or' returning true iff result of `or' is nonzero
• %&& bitwise `and' returning true iff result of `and' is nonzero
• %^^ bitwise `xor' returning true iff result of `xor' is nonzero
• |= bitwise or with assignment
• &= bitwise and with assignment
• ^= bitwise xor with assignment

11.10. Type cast

This expression allows dynamic type coercion. It is done during runtime and if it cannot be realized then System.InvalidCastException is thrown. If it succeeds, the type of this expression is equal to the type of type.

11.11. Type enforcement

This expression allows static type enforcement. It is checked during compile-time and an error is reported if expr type is not a subtype of type. It allows only type widening. If it succeeds, the type of this expression is equal to the type of type.

11.12. One-case matching

Equivalent to match (expr) { pattern => true | _ => false }.

11.13. Dynamic type check

Equivalent to match (expr) { _ is type => true | _ => false }.

11.14. checked/unchecked blocks

Turn on/off overflow checking for arithmetic operators. Checks are on by default.

11.15. Block expression

The value (and thus the type) of the whole expression is the value of the last expression in the sequence.

11.16. Array constructor

Create an array consisting of given elements. All elements must be of the same type. If the elements are of the type 'a then the whole expression is of the type array ['a].

The number in [] is array rank. It defaults to 1. If rank is specified, rows, columns and so on are specified using nested [], like in:

array .[2] [[1, 2], [3, 4], [5, 6]]
array .[3] [[[1, 2], [10, 20]], [[11, 12], [110, 120]]]

11.17. Value definition

Defines the binding between the variables in the pattern and the value of the expression expr which will be known to all subsequent expressions in the current block.

11.18. Local function definition

Defines the functions which will be known to all subsequent expressions in the current block. Names of all defined functions are put into the symbol space before their bodies are parsed.

11.19. Mutable value definition

Defines a new variable, value of which can be changed at any time using the assignment expression.

12. Secondary Expressions

This section describes expressions that are in fact just syntactic sugar over Core Expressions. We just present a translation of Secondary Expressions into Core Expressions.

12.1. Conditional expression

A standard branch, which executes and returns value of first expression if the condition evaluates to true or second elsewhere.

Internally it is translated into

match (cond) {
  | true => expr1
  | false => expr2
}

12.2. While loop

A loop, executing body expression as long as the condition is true. Its value is always checked before the execution of body and if it evaluates to false, then the loop ends.The body must be of type void.

The loop is translated internally into the following code

def loop () {
  if (cond) 
    { body; loop () }
  else
    ()
};
loop ()

12.3. do ... while loop

This loop is similar to while loop, but body is executed before the first time the condition is checked.

12.4. When expression

A version of the if condition, but having only one branch -- execution of body only when the condition is satisfied. If its value if false, then nothing is done (i. e. () is returned).

Its semantics is the same as

if (cond) body else ()

12.5. Unless expression

An opposite version of when. It executes and returns value of body only if conditions are not satisfied (i. e. evaluates to false).

Its semantics is the same as

if (cond) () else body

12.6. Lambda expression

Lambda expressions can be thought as of anonymous local functions. This construct defines such a function and returns it as a functional value. This value can be used just like the name of a regular local function.

Example:

List.Iter (fun (x) { printf ("%d\n", x) }, intList)

is equivalent to

def tmpfunc (x) { printf ("%d\n", x) };
List.Iter (tmpfunc, intList)

Lambda expression is actually translated internally to

where temporary_name is automatically created by the compiler.

12.7. List constructor

[1, 2, 3] is translated to list.Cons (1, list.Cons (2, list.Cons (3, list.Nil ()))).

12.8. Increment operator

Prefix operator ++ is used to increment integer value of assignable expression. It is translated to something similar to e = e + 1, except that e is evaluated only once, so ++a[x.Next()] can be used safely. The entire expression has type void (the incremented value is not returned).

12.9. Decrement operator

Prefix operator -- is used to decrement integer value of assignable expression. It is translated to something similar to e = e - 1, except that e is evaluated only once, so --a[x.Next()] can be used safely. The entire expression has type void (the decremented value is not returned).

12.10. Swap operator

Infix operator <-> is used to swap values of two assignable expressions. You can think about it as being translated to

def temp = e2;
e2 = e1;
e1 = temp

except that subexpressions of e1 and e2 are evaluated only once (there is a special macro to assure this), so a[x.Next()] <-> a[x.Next()] can be used safely.

13. Expression helpers

This section describes some constructs used in Expressions section.

13.1. Sequence

Expressions in the sequence are evaluated sequentially, and the value (and thus the type) of the sequence is the value of the last expression in the sequence.

Values of expression (except for the last one) are ignored, and thus if the type of some expression is not void -- a warning is generated.

The ; is optional after after } inside a sequence.

13.2. Block

This is just a standard execution of a sequence of expressions. The value (and type) of this block is the same as the last expression in the sequence.

This syntax is a shortcut for matching parameters of a defined function with a given list of patterns. It is equivalent to making a tuple from parameters of function and creating match expression.

def f (p1, p2, p3) { 
  | (1, 3, "a") => 1
  | _ => 2
}

translates to

def f (p1, p2, p3) { 
  match ((p1, p2, p3)) {
    | (1, 3, "a") => 1
    | _ => 2
  }
}

It is also to note that when a function has only one parameter, the matching goes just on this parameter itself (no one-element tuple is created).

13.3. Try..catch handler

13.4. Function parameter

ref and out are used to denote a parameter passed by reference.

13.5. Match case

A guarded pattern requires expression expr to be of type bool. An expression e satisfies the guarded pattern only if it is pattern-matched with pattern and expression expr is evaluated to true.

An expression e satisfies this match case if and only if it satisfies one of the guarded patterns in this match case.

14. Patterns

Patterns are a form of accessing data structures, especially trees. Patterns can match values. A definition of the term to match is given with each pattern construct. However, the main idea behind patterns is that they match values that look like them.

Pattern are used in match expression and value definitions.

14.1. Constructor pattern

The identifier should refer to the name of variant option. This pattern matches a value if it is a specified variant option, and sub-pattern matches variant option payload.

14.2. Throw-away pattern

This pattern matches any value.

14.3. Record pattern

This pattern matches a value of a class, that has all specified fields (this is checked statically), and a value of each field matches respective pattern.

14.4. As binding

This pattern matches the same value as an enclosed pattern does. However, in addition the value matched by the enclosed pattern is bound to a specified variable, which can be used in when guard or match body.

14.5. Type check pattern

This pattern matches a value if it possesses a given type. In addition, the value matched is bound to a specified variable, which gets the given type.

This pattern can be used both for checking the type and hinting the type checker (if the value is statically known to always have given type, compiler issues a warning and no runtime checks are performed).

14.6. Tuple pattern

This pattern matches a tuple with specified contents (each tuple member is matched be respective pattern).

In addition, when a tuple pattern is seen, where a record pattern would be otherwise expected -- the tuple pattern is transformed to record pattern by adding field identifiers in order they appear in the definition of the given class. A tuple pattern transformed to a record pattern cannot match fields inherited from the base class.

14.7. List constructor pattern

The following two lines are equivalent:

pattern1 :: pattern2
list.Cons (pattern1, pattern2)

14.8. List literal pattern

The following are equivalent:

[ pattern1 , pattern2 , ... , patternN ]
list.Cons (pattern1, list.Cons (pattern2, ... list.Cons (pattern2, list.Nil) ... ))

14.9. Literal pattern

This pattern matches a specified constant value.

14.10. Type enforcement in pattern

This construct is used to statically enforce type of subpattern to given type. If a matched expression might not have such a type, compiler issues an error. It is used mainly for hinting type inference engine and improving code clarity.

15. Macros

Please refer to macros.html for now.