From C++​

int i{5};
double d = 2;                 // double is float
char c = 'A';
var p = nullptr;
array<int> scores = [90, 72];
map<string, int> ages = {"ana": 31};
array<int> none;              // T x; default-constructs: an empty array
int zero;                     // and a number starts at 0
print(i, " ", d, " ", type_of(d), " ", cast<int>(c), " ", p == null, " ", scores.size() + ages.size(), " ", none.size(), " ", zero);

void heal(int& hp, int amount) { hp += amount; }
int total(array<int>& xs) { int s = 0; for (auto x : xs) { s += x; } return s; }
auto biggest(auto a, auto b) { return a > b ? a : b; }
class Hero { int hp = 10; }
Hero h;
heal(h.hp, 5);                          // a field binds to int&
auto& alias = h.hp;
alias += 1;
int bonus = 3;
auto add_bonus = [bonus](int v) { return v + bonus; };
function f = add_bonus;
print(h.hp, " ", total([1, 2, 3]), " ", biggest(3, 9), " ", biggest("ab", "b"), " ", f(10));

class Shape {
    string name;
    Shape(string n) { name = n; }
    float area() { return 0.0; }
}
class Square : Shape {
    float side;
    Square(float s) : super("square") { side = s; }
    float area() override { return side * side; }
}
class Vec {
    int x = 0; int y = 0;
    Vec(int px, int py) { x = px; y = py; }
    Vec operator+(Vec o) { return Vec(x + o.x, y + o.y); }
}
Square sq = Square(3.0);
Shape& s = sq;                          // a base reference: area() dispatches to Square
shared_ptr<Square> heap = new Square(2.0);
auto again = heap;                      // a second handle to one object
again.side = 5.0;
Vec v = Vec(1, 2) + Vec(3, 4);
print(s.name, " ", s.area(), " ", heap->area(), " ", v.x, ",", v.y);

enum Dir { north, south }
namespace util { int twice(int v) { return v * 2; } }
auto [lo, hi] = [3, 8];
map<string, int> stock = {"ore": 4, "gem": 1};
for (auto [name, count] : stock) { print(name, "=", count); }
try {
    throw util::twice(hi);
} catch (e) {
    print("caught ", e.value, " (", type_of(e.value), ") ", Dir.south, " ", lo);
}
print(format("{} {:.2f}", "pi", math::PI));

class Shape { int sides = 0; }
class Square : Shape { float side = 2.0; }
Shape s = Square();                          // a base-typed slot holding a whole Square
print(cast<Square&>(s).side, " ", cast<int>(2.7), " ", cast<char>(65));
shared_ptr<Shape> p = new Square();
shared_ptr<Square> q = cast<shared_ptr<Square>>(p);
weak_ptr<Shape> w = p;
print(same_object(p, q), " ", w.expired());
try { cast<Square&>(Shape()).side; } catch (e) { print("caught: ", e); }

int hits = 0;
switch (1) {
    case 1: hits += 1;          // ends here
    case 2: hits += 10;
}
switch (1) {
    case 1:
        hits += 100;
        fallthrough;            // continue into case 2
    case 2: hits += 1000;
}
print(hits);

namespace geo {
    int area(int side) { return side * side; }
    int area(int w, int h) { return w * h; }
}
print(geo::area(4), " ", geo::area(2, 3));

int area(int side) { return side * side; }
int area(int w, int h) { return w * h; }
float area(float r) { return 3.0 * r * r; }
print(area(2, 3), " ", area(4), " ", area(1.5));

class Shape { string kind() { return "shape"; } }
class Circle : Shape { float r = 1.5; string kind() override { return "circle"; } }
Shape s = Circle();
array<Shape> all = [Shape(), Circle()];
print(s.kind(), " ", type_of(s), " ", all[1].kind(), " ", cast<Circle&>(s).r);

int big = 9223372036854775807;
try { big = big + 1; } catch (e) { print("caught: ", e); }
try { print(10 / 0); } catch (e) { print("caught: ", e); }
try { print(1.0 / 0.0); } catch (e) { print("caught: ", e); }
print(1 << 63, " ", math::wrap_add(big, 1), " ", 2147483647 + 1);

string log = "";
int note(string s, int v) { log += s + " "; return v; }
int add(int a, int b) { return a + b; }
array<int> slots = [0, 0];
int r = add(note("first", 1), note("second", 2));
slots[note("index", 0)] = note("value", 7);
print(log, "| ", r, " ", slots[0]);

int total(array<int>& xs) { int s = 0; for (auto x : xs) { s += x; } return s; }
void upper(string& s) { s.to_upper(); print(s); }
print(total([1, 2, 3]));
upper("quiet");

void bump(int& x) { x += 1; }
bump(5);

function make_counter() {
    int count = 0;
    return [&count]() { count += 1; return count; };
}
auto next = make_counter();
next();
print(next());

class Player { int hp = 5; void heal() { hp += 1; } }
Player p;
var heal = reflect::bind(p, "heal");
heal();
heal();
print(p.hp);

string s = "\xC3\xA9";              // é in UTF-8: two bytes
utf8_string u = s;
print(s.size(), " ", s[0] + 0, " ", s.utf8_length(), " ", u.size());

int first(int x) { return second(x) + 1; }   // second is declared below: fine
int second(int x) { return x * 10; }
print(first(2));

class Vec2 {
    float x = 0.0;
    float y = 0.0;
    Vec2() {}
    Vec2(float px, float py) { x = px; y = py; }
    Vec2 operator+(Vec2 o) { return Vec2(x + o.x, y + o.y); }
    Vec2 operator*(float k) { return Vec2(x * k, y * k); }
}
class Body {
    string name;
    Vec2 pos;
    Vec2 vel;
    Body() {}
    Body(string n, Vec2 p, Vec2 v) { name = n; pos = p; vel = v; }
}
class Scope {
    string label;
    Scope(string l) { label = l; print("begin ", label); }
    ~Scope() { print("end ", label); }
}
void step(array<Body>& bodies, float dt) {
    Scope guard = Scope("step");
    for (auto& b : bodies) { b.pos = b.pos + b.vel * dt; }
}

array<Body> world = [Body("ship", Vec2(0.0, 0.0), Vec2(2.0, 1.0)),
                     Body("rock", Vec2(10.0, 0.0), Vec2(-1.0, 0.0))];
array<Body> snapshot = world;            // a deep copy, like std::vector<Body>
step(world, 0.5);
step(world, 0.5);
for (auto& b : world) { print(`${b.name}: (${b.pos.x:.1f}, ${b.pos.y:.1f})`); }
print(`snapshot ship: (${snapshot[0].pos.x:.1f}, ${snapshot[0].pos.y:.1f})`);