Overview

Definitions declare new types that can be used throughout a program. Types can have properties, methods, and nested definitions.

Functions, Procedures, and Operators

A routine is introduced by one of three keywords, and that keyword — not the spelling of the name — decides how the routine behaves:

• function declares a pure function: its inputs are borrowed and immutable, and it returns a result without side effects. A function is applied prefix, by writing its name before a parenthesized argument list.

• procedure declares a routine that may mutate its inputs and have side effects (builders, I/O).

• operator declares an operator: a pure routine applied infix between its two operands (or prefix, for a unary operator).

The three identifier forms from the lexical chapter — alphanumeric, operator-character, and single-quoted string identifiers — are interchangeable as names here. A function may be named with operator characters, and an operator may be named with letters or a quoted string; what makes one a function and the other an operator is the declaration keyword, never the first character of the name.

function 'add seven'(n: int) returns int      ; string-named function
    n + 7

function ++(n: int) returns int               ; operator-char-named function
    n + 1

let a 'add seven'(35)                          ; applied prefix -> 42
let b ++(41)                                   ; applied prefix -> 42
    

Operators may be declared at the top level, not only as members of a type. Like functions, they accept any of the three name forms:

operator <+>(left: int, right: int) returns int    ; operator-char name
    left + right

operator 'divided by'(left: int, right: int) returns int   ; quoted name
    left / right

let c 40 <+> 2              ; infix -> 42
let d 84 'divided by' 2     ; infix -> 42
    

Built-in arithmetic, comparison, and logical operators carry their usual precedences. A custom operator with a text or single-quoted name binds most weakly of all — at the same level as || — so the built-in arithmetic in an expression combines before it. For example, given the 'minus' operator above, 20 'minus' 3 + 5 parses as 20 'minus' (3 + 5) and yields 12.

Definitions

Definitions declare new types that can be used throughout a program.

define Point(x: int, y: int)
Point(3, 4)

define Point(x: int, y: int)
Point(3, 4).x

define Point(x: int, y: int)
let p Point(3, 4)
p.x + p.y

define Point(x: int, y: int)
define Rectangle(origin: Point, width: int, height: int)
Rectangle(Point(0, 0), 10, 5).width

define Option union(Some: int, None)
Some(5)

define Option union(Some: int, None)
None

define Result union(Ok: int, Err: String)
Ok(42)

define Result union(Ok: int, Err: String)
Err("error")

define Option union(Some: int, None)
Option.Some(5).value

function 'add seven'(n: int) returns int
    n + 7
'add seven'(35)

function ++(n: int) returns int
    n + 1
++(41)

operator <+>(left: int, right: int) returns int
    left + right
40 <+> 2

operator 'plus'(left: int, right: int) returns int
    left + right
40 'plus' 2

operator 'divided by'(left: int, right: int) returns int
    left / right
84 'divided by' 2

operator 'minus'(left: int, right: int) returns int
    left - right
20 'minus' 3 + 5