Operators#

-- Arithmetic, comparison and logic.
task main() -> void {
    pilot a: int = 17
    pilot b: int = 5

    say word_from_int(a + b)
    say word_from_int(a - b)
    say word_from_int(a * b)
    say word_from_int(a / b)
    say word_from_int(a % b)

    say word_from_bool(a > b)
    say word_from_bool(a == 17)
    say word_from_bool(a != b)
    say word_from_bool(a <= 17)

    say word_from_bool(a > b and b > 0)
    say word_from_bool(a < b or b > 0)
    say word_from_bool(not false)

    -- Unary minus applies to an expression. A negative *literal*
    -- is written as a subtraction: `0 - 5`.
    pilot neg: int = 0 - 5
    say word_from_int(-neg)
}

22
12
85
3
2
true
true
true
true
true
true
true
5

-- The anime operators that V3 actually implements.
-- The three unary forms are PREFIX and accept `int` only.
task main() -> void {
    pilot base: int = 6

    say word_from_int(FINAL FORM base)    -- base * base
    say word_from_int(PLUS ULTRA base)    -- base * 2
    say word_from_int(TSUNDERE base)      -- 0 - base

    -- NAKAMA is infix, at the same precedence as + and -.
    say word_from_int(3 NAKAMA 4)
}

36
12
-6
8

-- `|>` feeds the left value in as the FIRST argument of the call on the
-- right, so `x |> f(y)` is exactly `f(x, y)`.
task double(n: int) -> int { give back n * 2 }
task offset(n: int, by: int) -> int { give back n + by }

task main() -> void {
    say word_from_int(5 |> double())
    say word_from_int(5 |> offset(3))
    say word_from_int(5 |> double() |> offset(1))
}

10
8
11

-- `impl Doctrine for Shape` registers an operator implementation.
-- V3 does not accept a `doctrine` *declaration*, but it does accept
-- this impl form for the built-in operator doctrines, and the method
-- is callable by name.
shape Vec2 {
    x: int
    y: int
}

impl Add for Vec2 {
    task add(self, other: Vec2) -> Vec2 {
        give back Vec2 { x: self.x + other.x, y: self.y + other.y }
    }
}

impl Vec2 {
    task show(self) -> word {
        give back "({self.x}, {self.y})"
    }
}

task main() -> void {
    pilot a: Vec2 = Vec2 { x: 1, y: 2 }
    pilot b: Vec2 = Vec2 { x: 10, y: 20 }
    pilot c: Vec2 = a.add(b)
    say c.show()
}

(11, 22)