Enums

Tolk supports enums, similar to TypeScript and C++ enums. In the TVM (virtual machine) all enums are integers. From the compiler’s point of view, it’s a distinct type.

// will be 0 1 2
enum Color {
    Red
    Green
    Blue
}

Enum members

Values can be specified manually. Otherwise, auto-calculated as +1.

enum Mode {
    Foo = 256,
    Bar,        // implicitly 257
}

Enums are distinct types, not integers

Color.Red is Color, not int, although it holds the value 0 at runtime.

fun isRed(c: Color) {
    return c == Color.Red
}

fun demo() {
    isRed(Color.Blue);    // ok
    isRed(1);             // error, pass `int` to `Color`
}

Since enums are types, they can be:

used as variable and parameters,
extended with methods for an enum,
used in struct fields, unions, generics, and other type contexts:

struct Gradient {
    from: Color
    to: Color? = null
}

fun Color.isRed(self) {
    return self == Color.Red
}

var g: Gradient = { from: Color.Blue };
g.from.isRed();       // false
Color.Red.isRed();    // true

match (g.to) {
    null => ...
    Color => ...
}

`match` for enums is exhaustive

Pattern matching on enums requires coverage of all cases:

match (someColor) {
    Color.Red => {}
    Color.Green => {}
    // error: Color.Blue is missing
}

Alternatively, use else to handle remaining values:

match (someColor) {
    Color.Red => {}
    else => {}
}

Operator == compares values directly:

if (someColor == Color.Red) {}
else {}

Enums are integers under the hood

At the TVM level, every enum is represented as int. Casting between the enum and int is allowed:

Color.Blue as int evaluates to 2
2 as Color evaluates to Color.Blue

During deserialization with fromCell(), the compiler performs checks to ensure that encoded integers correspond to valid enum values.

Enums are allowed in `throw` and `assert`

enum Err {
    InvalidId = 0x100
    TooHighId
}

fun validate(id: int) {
    assert (id < 1000) throw Err.TooHighId;  // excno = 257
}

Stack layout and serialization

Every enum is backed by TVM INT. Serialized as (u)intN where N is:

specified manually: enum Role: int8 { ... }
or calculated automatically to fit all values

For details, follow TVM representation and Serialization.

Ecosystem

Payment processing

Standard contracts

Contract development

Languages

TVM: TON Virtual Machine

Blockchain foundations

Open network

Contribute

Enum members

Enums are distinct types, not integers

`match` for enums is exhaustive

Enums are integers under the hood

Enums are allowed in `throw` and `assert`

Stack layout and serialization

​Enum members

​Enums are distinct types, not integers

​match for enums is exhaustive

​Enums are integers under the hood

​Enums are allowed in throw and assert

​Stack layout and serialization

Enum members

Enums are distinct types, not integers

`match` for enums is exhaustive

Enums are integers under the hood

Enums are allowed in `throw` and `assert`

Stack layout and serialization