Expressions

Overview

Expressions are the core computational units of Scaly. Every expression evaluates to a value; one that answers nothing answers the empty tuple (). An expression is an operation: a sequence of things — values, names, operator names, tuples, vector literals and blocks — that the compiler reads from left to right. It holds one current value, and the type of that value says what the next thing means:

Parentheses make a tuple (and a tuple of one value is that value, so they also group), brackets a vector literal, braces a block, and the dot a member. Nothing else structures a sequence: there is no precedence table in the compiler. How strongly operators bind is stated by the standard library, as a protocol of pending types: a + answers a value that waits for its right operand, and the protocol decides what an operator after it means. The levels, strongest first, are listed under Operations.

Two consequences are worth knowing before reading the rest of this chapter:

• Application is stronger than waiting. Before an operator takes what follows, that thing takes what is applied to it: a + f(1) adds the call's result, a + v[i] the element.

• A call without parentheses takes exactly one thing. print f(x) is (print f)(x), which the compiler reports; an argument that is itself a call, an indexing or a construction takes its parentheses: print(f(x)).

Literals

Expressions are the core computational units of Scaly. Every expression evaluates to a value.

Operations

An operation is a sequence of things: values, names, operator names, tuples in parentheses, vector literals in brackets and blocks in braces, each perhaps followed by a member access with a dot. The compiler reads the sequence from left to right and holds one current value; the TYPE of that value says what the next thing means. A tuple after a function is the call, a tuple after a type the construction, a vector literal after a value the indexing, an operator name after a value one of the operators its type declares. Parentheses, brackets, braces and the dot are what structure a sequence, and nothing else does. An operation ends with a colon, a line break, or anything that is not part of it.

function twice(n: int) returns int
    n * 2
twice -5

function twice(n: int) returns int
    n * 2
3 + twice(4) * 2

function twice(n: int) returns int
    n * 2
twice 21

let a: u8 200
let b: u8 100
a + b as int

let a: u8 200
let b: u8 100
a + (b as int)

let x 5
x

let x 5
x + 3

let x 5
let y 3
x + y

let x 2 + 3
x * 2

Tuples and Function Values

A tuple is a value: an anonymous record written in parentheses. Its components may carry labels, and its type is written the same way, (int, String). The empty tuple () is the type of no value, which a routine without a result answers. Functions are values too: a name bound to a function, or a method bound to its receiver, is called later like the function itself.

let t (x: 3, y: 4)
t.x * t.y

let (a, b) (6, 7)
a * b

function pair() returns (int, int)
    (3, 4)
let (p, q) pair()
p + q

function add(a: int, b: int) returns int
    a + b
let args (40, 2)
add args

define Point(x: int, y: int)
let args (1, 2)
let p Point(args)
p.y

function twice(n: int) returns int
    n * 2
let g twice
g(21)

define Counter(n: int)
{
    function plus(this, k: int) returns int
        n + k
}
let c Counter(40)
let m c.plus
m(2)

define IntFn delegate(int) returns int
function apply(f: IntFn, x: int) returns int
    f(x)
function twice(n: int) returns int
    n * 2
apply(twice, 21)

Comparison Operators

Comparison operators compare two values and return a boolean result.

Boolean Operators

Boolean operators combine boolean values.

procedure noisy() returns bool
{
    print "evaluated"
    true
}
false and noisy()

procedure noisy() returns bool
{
    print "evaluated"
    false
}
true or noisy()

Bitwise Operators

Bitwise operators manipulate integer values at the bit level.

Lambdas

A lambda is an anonymous function written with a backslash: \params: body. Parameters are space-separated. A lambda bound to a name and applied to arguments is monomorphized at the call site for those argument types, so the same lambda works at any argument type.

let inc \x: x + 1
inc(5)

let add \x y: x + y
add(3, 4)

let dbl \x: x + x
let a dbl(10)
let b dbl(21)
a + b

let n 10
let f \x: x + n
f(5)

let a 3
let b 4
let g \x: x + a + b
g(10)

let n 10
let cap \x: { x + n }
cap(5)

let n 10
let shade \x: { let n 99
x + n }
shade(5)

let inc \x: x + 1
let add \x y: x + y
inc(5) + add(3, 4)

let inc \x: x + 1
let n 100
n + inc(9)

let n 100
let cap \x: x + n
cap(1) + cap(2)

define IntFn delegate(int) returns int
function apply(f: IntFn, x: int) returns int
    f(x)
let g: IntFn \x: x + 1
apply(g, 5)

define IntFn delegate(int) returns int
function twice(f: IntFn, x: int) returns int
    f(f(x))
let dbl: IntFn \x: x + x
twice(dbl, 20)

define IntFn delegate(int) returns int
function apply(f: IntFn, x: int) returns int
    f(x)
let n 10
let add: IntFn \x: x + n
apply(add, 5)

Choose Expressions

Choose expressions pattern match on union types, allowing different code paths based on which variant is present.

define Option union(Some: int, None)
choose Option.Some(7): when v: Some: v else 0

define Option union(Some: int, None)
choose Option.None: when v: Some: v else 0

define Result union(Ok: int, Err: int)
choose Result.Ok(42): when x: Ok: x + 1 else 0

define Result union(Ok: int, Err: int)
choose Result.Ok(10): when x: Ok: x when e: Err: e + 100

define Result union(Ok: int, Err: int)
choose Result.Err(5): when x: Ok: x when e: Err: e + 100

Optional Types

Optional types use null pointer optimization (NPO) for efficient representation.

define Option[T] union: (Some: T, None)
function check(x: int?) returns int: if x is null: 0 else 1
check(Option[int].None)

define Option[T] union: (Some: T, None)
function check(x: int?) returns int: if x is null: 0 else 1
check(Option[int].Some(42))

define Option[T] union: (Some: T, None)
function unwrap(x: int?) returns int: choose x: when v: Some: v else 0
unwrap(Option[int].Some(42))

define Option[T] union: (Some: T, None)
choose Option[int].Some(42): when v: Some: v else 0

define Option[T] union: (Some: T, None)
choose Option[int].None: when v: Some: v else -1

Variant Construction

Union variants can be constructed explicitly using Type.Variant syntax.

define Result union: (Ok: int, Error: int)
choose Result.Ok(42): when x: Ok: x else 0

define Result union: (Ok: int, Error: int)
choose Result.Error(100): when e: Error: e else 0

define Result union: (Ok: int, Error: int)
if Result.Ok(50) is Ok : 1 else 0

define Result union: (Ok: int, Error: int)
if Result.Error(33) is Ok : 1 else 0