TOLK lang

// before: 50000000 nanotons
val amount = ton("0.05");

// now: 50000000 nanograms
val amount = grams("0.05");

// array<int>
var numbers = [1, 2, 3];

// array<Point?>
var optPoints = [
    Point { x: 10, y: 20 },
    Point { x: 30, y: 40 },
    null,
];

type tuple = array<unknown>

// string
val str = "hello";

StringBuilder.create()  
    .append(content.commonContent)  
    .append(individualNftContent)  
    .build()

import "@common/jettons"
import "@third_party/math-lib"

fun log(msg: string, loc: SourceLocation = reflect.sourceLocation()) {
     debug.print(loc.lineNo);
}

fun demo() {
     log("a");    // prints K — current line no
     log("b");    // prints K+1
}

struct Storage {
    // internal, checked automatically
    owner: address
}

createMessage({
    bounce: BounceMode.RichBounce,
    ...
})

fun customRead(reader: (slice) -> int) { ... }

customRead(fun(s) {
    return s.loadUint(32)
})

var m: map<int8, int32> = createEmptyMap();
m.set(1, 10);
m.addIfNotExists(9, -90);
m.delete(9);   // now: [ 1 => 10 ]
m.exists(1);   // true
m.isEmpty();   // false

val r = m.get(1);
if (r.isFound) {   // true
    val v = r.loadValue();  // 10
}

// or if the key 100% exists
val v = m.mustGet(1);  // 10

var r = m.findFirst();
while (r.isFound) {
    // use r.getKey() and r.loadValue()
    r = m.iterateNext(r);
}

map<address, Point>
map<Point, Cell<Extra>>
map<int32, map<int64, bool>>
...

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

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

var g: Gradient = { from: Color.Blue };
g.from == Color.Red;    // false

struct PosInTuple {
    private readonly t: tuple
    curIndex: int
}

fun PosInTuple.last(mutate self) {
    // `t` is visible only in methods
    // and cannot be modified
    self.curIndex = self.t.size() - 1;
}

// general implementation
fun Iterator<T>.next(self) { ... }

// a more specific one
fun Iterator<Cell<T>>.next(self) { ... }

val st = lazy Storage.load();
// the compiler skips everything and loads only what you access
return st.publicKey;

val reply = createMessage({
    bounce: false,
    value: ton("0.05"),
    dest: senderAddress,
    body: RequestedInfo { ... }
});
reply.send(SEND_MODE_REGULAR);

// value: either tons, or tons + extra currencies
value: ton("1.5")
value: (ton("1.5"), extraDict)

// destination: various forms
dest: someAddress
dest: (workchain, hash)

// any serializable struct — no toCell!
body: RequestedInfo { ... }

dest: {
    workchain: BASECHAIN,
    stateInit: { code, data },
}

dest: {
    ...
    toShard: {
        fixedPrefixLength: 8,
        closeTo: ownerAddress,
    }
}

struct Point {
    x: int8;
    y: int8;
}

var value: Point = { x: 10, y: 20 };

// makes a cell containing "0A14"
var c = value.toCell();   
// back to { x: 10, y: 20 }   
var p = Point.fromCell(c);

// low-level is allowed:
beginCell()
  .storeUint(1, 32)    // mix manual
  .storeAny(myStruct)  // with auto

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

struct (0b001) AssetSimple { ... }
struct (0b100) AssetBooking { ... }
type Asset = AssetSimple | AssetBooking | ...;

struct A {
    ref1: cell;          // untyped ref
    ref2: Cell<Inner>;   // typed ref
    ref3: Cell<int256>?; // maybe ref
}

a.ref2.field         // error
a.ref2.load().field  // ok

Point.fromSlice(s, {
    assertEndAfterReading: false
})

struct Wallet {
    owner: address;
}

struct Point {
    x: int;
    y: int;
}

fun calcMaxCoord(p: Point) {
    return p.x > p.y ? p.x : p.y;
}

// declared like a JS object
var p: Point = { x: 10, y: 20 };

// called like a JS object
calcMaxCoord({ x: 10, y: 20 });

fun loadData(): StoredInfo {
    return {
        counterValue: ...,
        ownerAddress: ...,
    }
}

struct Nullable<T> {
    item: T? = null;
}

struct Ok<TResult> { result: TResult }
struct Err<TError> { err: TError }

type Response<R, E> = Ok<R> | Err<E>;

match (r) {
    Ok => { r.result }
    Err => { r.err }
}

fun Point.getX(self) {
    return self.x
}

fun Point.create(x: int, y: int): Point {
    return { x, y }
}

fun slice.load32(mutate self): int32 {
    return self.loadInt(32);
}

// before
someCell.cellHash();
someTuple.tupleSize();
someBuilder.getBuilderBitsCount();

// now
someCell.hash();
someTuple.size();
someBuilder.bitsCount();

// before
getMyAddress();
setContractData(c);
getLogicalTime();

// now
contract.getAddress();
contract.setData(c);
blockchain.logicalTime();

type UserId = int32;
type MaybeOwnerHash = bytes32?;

fun whatFor(a: bits8 | bits256): slice | UserId { ... }

var result = whatFor(...);  // slice | UserId

match (result) {
    slice  => { /* result is slice here  */ }
    UserId => { /* result is UserId here */ }
}

type Pair2 = (int, int);
type Pair3 = (int, int, int);

fun getLast(tensor: Pair2 | Pair3) {
    return match (tensor) {
        Pair2 => tensor.1,
        Pair3 => tensor.2,
    }
}

val nextValue = match (curValue) {
    1 => 0,
    0 => 1,
    else => -1
};

struct StoragePart {
    data: SmallPayload | LargePayload;
    // (de)serialized as '0' + ... or '1' + ...
}

match (s.data) {
    SmallPayload => ...
    LargePayload => ...
}

// don't mind about opcodes yet
struct CounterIncBy { byValue: int32 }
struct CounterReset {}
struct ... other messages

type IncomingMessage = CounterIncBy | CounterReset | ...;

// ... after parsing a message
match (msg) {
    CounterIncBy => {
        newCounter = curCounter + msg.byValue
    }
    CounterReset => {
        newCounter = 0
    }
    ...
}

struct CounterIncrement {
    counter_id: int;
    inc_by: int;
}

counterIncrement 
    counter_id:int32 
    inc_by:int64
    = CounterIncrement;

// type casting?
counter_id: int as int32; 
inc_by: int as int64;

// inline annotations?
counter_id: int @int32;
inc_by: int @int64;

// annotations above fields?
@serialize(int32)
counter_id: int;
@serialize(int64)
inc_by: int;

// this?
inc_by: (int as int32)?;
// or this?
inc_by: int? as int32?;
// or this?
inc_by: Maybe<int> as Maybe<int32>;

// this?
my_data: Both<Maybe<int as int32>, int as int64>;
// or this?
my_data: Both<Maybe<int>, int> as Both<Maybe<int32>, int64>;
// or how??

struct CounterIncrement {
    counter_id: int32;
    inc_by: int64;
}

struct MyMsg {
    inc_by: int32?;
    my_data: (int32?, int64);
}

var op: int32 = ...;
var query_id: uint64 = ...;

var v: uint8 = 255;
v += 1;    // ???

struct Resp {
    outValue: uint8;
}

resp.outValue = v;   // 256
resp.toCell();       // a runtime "overflow" error

value = x > 0 ? 1 : null;  // int?

value + 5;               // error
s.storeInt(value);       // error

if (value != null) {
    value + 5;           // ok
    s.storeInt(value);   // ok
}

if (lastCell != null) {
    // here lastCell is `cell`, not `cell?`
}

if (lastCell == null || prevCell == null) {
    return;
}
// both lastCell and prevCell are `cell`

var x: int? = ...;
if (x == null) {
    x = random();
}
// here x is `int`

// this key 100% exists, make it `cell`, not `cell?`
validators = getBlockchainConfigParam(16)!;

fun alwaysThrows(): never {
    throw 123;
}

fun f() {
    ...
    alwaysThrows();  // no return needed after this
}

var v = 0;
// compiler warning: `int` can never be `null`
if (v == null) {
    // v is `never`
}

var t = (5, someSlice, someBuilder);   // 3 stack slots
t.0                     // 5
t.0 = 10;               // t is now (10, ...)
t.0 += 1;               // t is now (11, ...)
increment(mutate t.0);  // t is now (12, ...)
t.0.increment();        // t is now (13, ...)

t.1         // slice
t.100500    // compilation error

var t = [5, someSlice, someBuilder];   // 1 tuple on a stack with 3 items
t.0                     // "0 INDEX", reads 5
t.0 = 10;               // "0 SETINDEX", t is now [10, ...]
t.0 += 1;               // "0 INDEX" to read 10, "0 SETINDEX" to write 11
increment(mutate t.0);  // also, the same way
t.0.increment();        // also, the same way

t.1         // "1 INDEX", it's slice
t.100500    // compilation error

struct User {
    id: int;
    name: slice;
}

var u: User = { id: 5, name: "" };
// u is actually 2 slots on a stack, the same as
var u: (int, slice) = (5, "");

fun getUser(): User { ... }
// on a stack, the same as
fun getUser(): (int, slice) { ... }

var u: User = ...;   // u: (int, slice) = ...
u.id;                // u.0
u.id = 10;           // u.0 = 10

struct Storage {
    lastUpdated: int;
    owner: User;
}

s.lastUpdated        // s.0
s.owner.id           // s.1.0

() f(a, b) {
    return a + b;   // a and b now int, since `+` (int, int)
}

() f(slice s) {} 

var s = null;
f(s);  // infer s as slice, since f accepts slice

int f(x) {
    (a, b) = (0, x);
    return a + b;   // x becomes int, since x and b edge
}

var x = 0;   // unify(Hole, Int) = Int
...
x = null;    // unify(Int, Nullable<Hole>) = Nullable<Int>

error: function return type (int, int) cannot be unified with implicit end-of-block return type (int, ()): cannot unify type () with int

1) can not assign `(int, slice)` to variable of type `(int, int)`
2) can not call method for `builder` with object of type `int`
3) missing `return`