Structures and fields

Tolk supports structures — similar to TypeScript classes.

Structure syntax

struct Demo {
    allowExotic: bool = false
    customData: tuple
}

• Every field has a required type and an optional default value.
• Fields are separated by newlines, which are preferred, or by commas or semicolons.
• Fields can be private and readonly.

Object creation

Use { ... } when the type is clear, or StructName { ... } explicitly.

fun demo() {
    // the type is clear from the assignment
    var o1: Demo = { customData: someTuple };
    o1.someMethod();

    // alternatively, `Demo { ... }`
    Demo{customData: someTuple}.someMethod();
}

Shorthand object syntax

The shorthand { a, b } expands to { a: a, b: b }. This syntax is similar to object shorthand in TypeScript.

fun createDemo(allowExotic: bool, customData: tuple) {
    return Demo { allowExotic, customData }
}

Methods for structures

Methods are declared separately as extension functions:

fun Demo.hasData(self): bool {
    return self.customData.size() != 0
}

Empty structures

A structure without fields is used as a grouping construct for static methods. For example, standard functions such as blockchain.now() are declared this way:

struct blockchain

fun blockchain.now(): int
    asm "NOW"

fun blockchain.logicalTime(): int
    asm "LTIME"

These methods are static because they do not accept self.

Default values for fields

Fields with default values may be missed out of a literal:

struct DefDemo {
    f1: int = 0
    f2: int? = null
    f3: (int, coins) = (0, ton("0.05"))
}

fun demo() {
    var d: DefDemo = {};         // ok
    var d: DefDemo = { f2: 5 };  // ok
}

Private and readonly fields

• private – accessible only within methods.
• readonly – immutable after object creation.

struct PositionInTuple {
    private readonly t: tuple
    currentIndex: int
}

fun PositionInTuple.create(t: tuple): PositionInTuple {
    return { t, currentIndex: 0 }
}

fun PositionInTuple.next(mutate self) {
    // self.t cannot be modified: it is readonly
    self.currentIndex += 1;
}

fun demo() {
    var p = PositionInTuple.create(someTuple);
    // p.t is unavailable here: it is private
}

An object with a private field can only be constructed by a static method or an assembler function.

Generic structs

Generics exist only at the type level and incur no runtime cost.

struct Nullable<T> {
    value: T?
}

Methods for generic structs

When parsing the receiver in fun <receiver>.f(), the compiler treats unknown symbols as type parameters:

fun Nullable<T>.isNull(self) {
    return self.value == null
}

It’s a generalization. For example, fun T.copy() is valid for any receiver.

Method overloading or partial specialization is also allowed:

fun Nullable<map<K, V>>.isNull(self) {
    return self.value.isEmpty()
}

Serialization prefixes and opcodes

The syntax struct (PREFIX) Name { ... } specifies a serialization prefix for the structure. For messages, 32-bit prefixes are typically called opcodes.

struct (0x7362d09c) TransferNotification {
    queryId: uint64
    // ...
}

An outgoing message starts with the hex number:

// message will be '0x7362d09c0000000000000000' + ...
createMessage({
    // ...
    body: TransferNotification {
        queryId: 0,
        // ...
    }
});

Prefixes are not restricted to 32 bits:

• 0x000F — 16-bit hexadecimal prefix, value 15.
• 0b010 — 3-bit binary prefix, value 2.

Non-32-bit prefixes are useful for controlling union types when expressing TL-B’s multiple constructors.