Built-ins

SAIL provides a small set of types, values, and operators that are available in every source file without any import. These are wired into the compiler's initial environment. In addition, every assembly block has access to the full set of EVM opcodes through Yul primitives.

Primitive Types

Five types are built into the language kernel.

pair and sum are the internal representation of all user-defined algebraic data types. A data type with multiple constructors is encoded as a nested sum, and a constructor with multiple fields is encoded as a nested pair. User code rarely names pair or sum directly; they appear implicitly through data declarations and tuple syntax.

word

word is the only numeric type at the kernel level. Every integer literal in SAIL has type word. There is no numeric overloading: 42, 0xff, and 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff are all word values.

function decimals() -> word {
    return 18;
}

bool

bool has exactly two constructors, true and false, both of which are always in scope.

function isActive(paused : bool) -> bool {
    match paused {
    | false => return true;
    | true  => return false;
    }
}

() — Unit

The unit type () has a single value, also written (). Functions that perform side effects and return nothing use () as their return type.

function setOwner(newOwner : word) -> () {
    assembly { sstore(0, newOwner) }
}

Tuple Syntax

The syntax (a, b) is shorthand for pair a b. Tuples with more than two elements are right-nested pairs: (a, b, c) means pair a (pair b c).

data Transfer = Transfer(word, word, word);

function unpack(t : Transfer) -> (word, word, word) {
    match t {
    | Transfer(from, to, amount) => return (from, to, amount);
    }
}

Infix Operators

SAIL provides eight infix operators as syntactic sugar over ordinary function calls. The parser rewrites each operator to the corresponding function call before name resolution; the functions themselves must be in scope at the point of use.

Because the operators desugar to function calls, the compiler resolves them through the normal type class and name resolution machinery. The functions lt, gt, le, ge, ne, and, or, and not are not built into the kernel; they must be brought into scope before use.

Note The && and || operators do not short-circuit in the current implementation. Both operands are always evaluated before the logical operation is performed.

import std.{lt, ge, and};

function isValidAmount(amount : word, balance : word) -> bool {
    return amount > 0 && amount <= balance;
}

The invokable Class

The kernel defines one built-in type class:

forall self args ret . class self:invokable(args, ret) {
    function invoke(self : self, args : args) -> ret;
}

invokable is the compiler's mechanism for encoding higher-order functions. When a function-typed value is passed as an argument or stored in a data structure, the compiler generates an invokable instance that captures the closure and implements invoke. User code rarely interacts with invokable directly. A dedicated chapter covers higher-order functions and the defunctionalization transformation in detail; see Lambda Functions.

Assembly Primops

Inside an assembly { } block, all EVM opcodes are available as Yul primitives. Each opcode is treated as a function that operates exclusively on word values. Variables declared in the surrounding SAIL scope are accessible by name inside the block.

The sections below list every available opcode grouped by category, along with its Yul type signature.

Arithmetic

function checkedAdd(x : word, y : word) -> word {
    let result : word;
    let overflow : word;
    assembly {
        result   := add(x, y)
        overflow := lt(result, x)
    }
    if (overflow != 0) {
        assembly { revert(0, 0) }
    }
    return result;
}

Bitwise

Comparison

Comparison opcodes return 1 if the condition holds and 0 otherwise. The result type is word, not bool; use tobool or a match on the result to convert.

function isOwner(account : word) -> bool {
    let owner : word;
    let result : word;
    assembly {
        owner  := sload(0)
        result := eq(account, owner)
    }
    if (result) {
        return true;
    } else {
        return false;
    }
}

Hashing

function storageSlot(account : word) -> word {
    let slot : word;
    assembly {
        mstore(0, account)
        slot := keccak256(0, 32)
    }
    return slot;
}

Memory

Storage

function transfer(to : word, amount : word) -> () {
    let callerSlot : word;
    let toSlot : word;
    let senderBal : word;
    let recipientBal : word;
    assembly {
        callerSlot   := caller()
        toSlot       := to
        senderBal    := sload(callerSlot)
        recipientBal := sload(toSlot)
        sstore(callerSlot, sub(senderBal, amount))
        sstore(toSlot,     add(recipientBal, amount))
    }
}

Call Data

Return Data

Code

Control Flow

return and revert have a polymorphic return type a because execution does not resume after them; they can appear in any expression position regardless of the expected type.

Stack and Program Counter

Gas

External Calls

Contract Creation

Logging

function emitTransfer(from : word, to : word, amount : word) -> () {
    let transferTopic : word;
    assembly {
        transferTopic := 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef
        mstore(0x00, amount)
        log3(0x00, 0x20, transferTopic, from, to)
    }
}

Blockchain Context

These opcodes expose information about the current transaction and block. All return word.

function onlyOwner(ownerSlot : word) -> () {
    let owner : word;
    let msgSender : word;
    let isAuth : word;
    assembly {
        owner     := sload(ownerSlot)
        msgSender := caller()
        isAuth    := eq(msgSender, owner)
    }
    if (isAuth) {
        return ();
    } else {
        assembly { revert(0, 0) }
    }
}