beginCell().storeInt(42, 7).asSlice().loadInt(7);

// Let's flip some bits! (~˘▾˘)~
let nice: Int = ~~~~42 + ~~~~27;

// ~(˘▾˘~)
dump(nice);

a = a & 01000101; // bitwise AND
b = b | 01000101; // bitwise OR
c = c ^ 01000101; // bitwise XOR

a &= 01000101;
b |= 01000101;
c ^= 01000101;

// This now works:
struct You { likeJazz: Bool }

// And that works too:
message GuessCoin {
    probably: Int as coins;
    nothing: Int as coins
    // no trailing semicolon above!
}

// Now you can omit the obvious:
let a = 42;
let b = 27;
let c = a + b; // nice

// Explicit approach continues to work:
let d: Int = a + b; // also nice

let slice = beginCell().storeBool(true).asSlice();
let dice = slice.loadBool(); // true

import "@stdlib/deploy";

contract WhatCoin with Deployable {
    c: map<Address, Int as coins>; // ← 👀
}

struct Profit {
    big: String?;
    dict: map<Int, Int as uint64>;
    energy: Int;
}

contract MilkMoney with Deployable {
    // 100% sure here
    get fun gotProfit(src: Cell): Profit {
        let profit = Profit.fromCell(src);
        return profit;
    }
    
    // not 100% sure here,
    // being cautious for good reasons
    get fun gotProfitSlice(src: Slice): Profit? {
        let profit: Profit? = null;
        try {
            profit = Profit.fromSlice(src);
        catch (e) {
            dump("Slice doesn't match Profit!");
        }
        return profit;
    }
}

try {
    // If you don't need the return value
    let _ = myReturnIsUseless();

    // If you found yourself looking for map length,
    // and don't care about neither keys nor values
    let counter = 0;
    foreach (_, _ in map) {
        counter += 1;
    }

// If you never wanted that exit code anyways
catch (_) { }