Operator overload

// The operators from the Operators part are not reserved for numbers. A type of your own can say
// what `+`, `==` or `<` mean for it, by declaring a function whose name is the operator.
//
// The point is not cleverness. Money adds to money, and `rent + food` says that plainly where
// `Money { cents: rent.cents + food.cents }` buries it. A declared `==` also replaces the
// field-by-field comparison from the previous lesson, so a type decides what "equal" means.
import Io::PrintLine;

// Money as a whole number of cents, so no fraction of a cent ever goes missing.
struct Money {
    cents: int64;
}

extend Money {
    func Money(cents: int64) -> Money {
        return Money { cents: cents };
    }

    // `self` is the left operand and the second parameter is the right one. Taking the right
    // operand by value lets it be a value built on the spot, as in `rent == Money(120000)`.
    // `other: &Money` works as well, but a borrow needs a named value on the right.
    func +(self: &Money, other: Money) -> Money {
        return Money { cents: self.cents + other.cents };
    }

    func -(self: &Money, other: Money) -> Money {
        return Money { cents: self.cents - other.cents };
    }

    // The two sides need not have the same type. Money times a count makes sense; money times
    // money does not, so only this one exists.
    func *(self: &Money, count: int64) -> Money {
        return Money { cents: self.cents * count };
    }

    // Comparisons answer with `bool`, not with Money.
    func ==(self: &Money, other: Money) -> bool {
        return self.cents == other.cents;
    }

    func <(self: &Money, other: Money) -> bool {
        return self.cents < other.cents;
    }
}

func Main() -> int {
    let rent = Money(120000);
    let food = Money(35050);

    // Each operator below calls one of the functions above.
    let total = rent + food;
    let left = rent - food;
    let quarter = rent * 3;
    PrintLine("rent + food = {} cents", total.cents);
    PrintLine("rent - food = {} cents", left.cents);
    PrintLine("rent * 3    = {} cents", quarter.cents);

    PrintLine("rent == 120000 cents: {}", rent == Money(120000));
    PrintLine("food < rent:          {}", food < rent);

    // Only the operators declared exist. Money has no `/`, so `rent / 2` is an error rather
    // than something invented on Money's behalf.
    return 0;
}