Operators & Arithmetic​

print(`${7 / 2} ${7.0 / 2} ${7 % 3} ${2 + 3 * 4}`);
auto x = 5;
print(`${x++} ${x} ${--x} ${-x}`);
print(`${6 & 3} ${6 | 3} ${6 ^ 3} ${~0} ${1 << 4} ${32 >> 2}`);
print(`${3 <=> 7} ${7 <=> 7} ${"a" < "b"} ${1 == 1.0}`);
auto calls = 0;
function tick() { calls += 1; return true; }
auto skipped = false && tick();       // short-circuit: tick never runs
print(calls);
try { print(1 / 0); } catch (e) { print(`caught: ${e}`); }
print(`${1.0 / 0.0} ${-1 / 0.0} ${0.0 % 0.0}`);

auto big = 9223372036854775807;   // INT64_MAX
try { big = big + 1; } catch (e) { print("caught: ", e, ", big is still ", big); }
int h = -3750763034362895579;     // the FNV-1a offset basis, 0xcbf29ce484222325, as an int
for (auto c : "abc") { h = math::wrap_mul(h ^ c, 1099511628211); }
print("fnv1a = ", h);

class Weapon { string name = "axe"; }
class Hero { var weapon = null; }
Hero bare;
Hero armed;
armed.weapon = Weapon();
var nobody = null;
print(bare.weapon?.name ?? "fists", " ", armed.weapon?.name ?? "fists", " ", nobody?.weapon.name ?? "no hero");
var settings = {"volume": 7};
print(settings["volume"] ?? 5, " ", settings.get("music") ?? 5, " ", 0 ?? 5);
var cache = null;
cache ??= [1, 2];
cache ??= [9];
print(cache);

function a() { print("argument a"); return 1; }
function b() { print("argument b"); return 2; }
function add(x, y) { return x + y; }
function pick() { print("callee"); return add; }
print("sum = ", pick()(a(), b()));

var scores = [10, 20, 30];
function bump() { scores[1] = 99; return 1; }
function add_ref(int& x, y) { return x + y; }
print("by value: ", add(scores[1], bump()));        // 20 was taken before bump ran
scores[1] = 20;
print("by reference: ", add_ref(scores[1], bump()));

var i = 0;
var hits = [0, 0];
function inc(int& x, y) { x += 1; return y; }
inc(hits[i], i++);                                  // binds hits[0], then i moves
print(hits);

string log = "";
class Box { int v = 1; }
shared_ptr<Box> box = new Box();
function target() -> shared_ptr<Box> { log += "target "; return box; }
function value() -> int { log += "value "; return 5; }
target().v += value();                              // the right side runs first
print(log, "-> ", box.v);

var s = "abc";
print('z' - 'a', " ", s[0] + 0, " ", s[0] == 97, " ", 'a' & 0x7F, " ", -'a', " ", ~'a', " ", type_of('a' + 1));
string word = "banana";
int count = 0;
for (auto ch : word) { if (ch == "a") { count++; } }
char first = "b";                  // a one-character string fills a char
print(count, " ", word[0] == first, " ", word + '!', " ", 'a' < "ab", " ", 'a' == "ab");
switch (word[2]) {
    case "n": print("n at 2");
    default: print("something else");
}
char c = cast<char>(65);           // int -> char, range-checked 0..255
print(c, " ", cast<int>('a'), " ", cast<string>('z') + "!", " ", cast<char>("q"), " ", to_char(66));
try { cast<char>(256); } catch (e) { print("caught: ", e); }
try { char two = word.substr(0, 2); } catch (e) { print("caught: ", e); }

class Stats { int hp = 10; array<int> buffs = [1, 2]; }
Stats a = Stats();
Stats b = Stats();                 // a second value with the same fields
Stats c = Stats(); c.buffs.push(3);
print("values:  ", a == b, " ", a == c);
print("arrays:  ", [1, [2, 3]] == [1, [2, 3]], " ", [1, 2] == [1, 2, 3], " ", [1, 5] < [2]);
print("maps:    ", {"x": 1, "y": 2} == {"y": 2, "x": 1}, " ", {1: "a"} == {1.0: "a"});
var h1 = new Stats();
var h2 = h1;                       // a copy of a handle shares its object
var h3 = new Stats();              // a different object with equal fields
print("handles: ", h1 == h2, " ", h1 == h3);
print("same:    ", same_object(a, b), " ", same_object(h1, h2), " ", same_object(a, a));

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); }
    Vec operator*(int k) { return Vec(x * k, y * k); }
    Vec operator-() { return Vec(-x, -y); }
    bool operator==(Vec o) { return x == o.x && y == o.y; }
    bool to_bool() { return x != 0 || y != 0; }
    string to_string() { return `(${x}, ${y})`; }
}
auto v = Vec(1, 2) + Vec(3, 4);
v *= 2;                                    // v = v * 2, through operator*
print(v, " ", -v, " ", v == Vec(8, 12), " ", !Vec(0, 0));

class Version {
    int major = 0; int minor = 0;
    Version(int a, int b) { major = a; minor = b; }
    int operator<=>(Version o) { return major != o.major ? major - o.major : minor - o.minor; }
    int operator<=>(int m) { return major - m; }   // against a bare major number
}
Version v1 = Version(1, 4);
Version v2 = Version(2, 0);
print(v1 < v2, " ", v1 >= v2, " ", v1 == Version(1, 4), " ", v1 != v2, " ", v2 == 2, " ", 1 < v2, " ", 3 <=> v1);
array<var> versions = [v2, Version(0, 9), v1];
versions.sort();                           // sort() orders through the same <
print(versions[0].major, ".", versions[0].minor);

class Grid {
    array<int> cells = [0, 0, 0];
    int& operator[](int i) { return cells[i]; }      // a reference return: g[i] is an lvalue
    int operator()(int a, int b) { return a + b; }
}
Grid g;
g[2] = 7;
g[2] += 1;
print(g.cells, " ", g(2, 3));