Derived operator

// There are six comparison operators, but a type declares at most two of them. From `==` the
// compiler derives `!=`, and from `<` together with `==` it derives the other three:
//     a != b    means    !(a == b)
//     a >  b    means    b < a
//     a <= b    means    a < b || a == b
//     a >= b    means    b < a || a == b
// So there is less to write, and the six can never disagree with one another.
//
// A type may still declare one of the derived operators itself, and then its own declaration is
// used instead. That is rarely a good idea: it is exactly how the six come to disagree.
import Io::PrintLine;

// Players are ranked by score alone. Two players with the same score tie, whatever their names.
struct Player {
    name: char8[..];
    score: int32;
}

extend Player {
    func ==(self: &Player, other: Player) -> bool {
        return self.score == other.score;
    }

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

func Main() -> int {
    let ann = Player { name: "Ann", score: 7 };
    let bob = Player { name: "Bob", score: 9 };
    let cy = Player { name: "Cy", score: 7 };

    // The two that were declared.
    PrintLine("Ann == Cy  {}", ann == cy);
    PrintLine("Ann <  Bob {}", ann < bob);

    // The four that were derived.
    PrintLine("Ann != Bob {}", ann != bob);
    PrintLine("Bob >  Ann {}", bob > ann);
    PrintLine("Ann <= Cy  {}", ann <= cy);
    PrintLine("Ann >= Bob {}", ann >= bob);

    // Derivation needs something to start from. Delete `<` and `bob > ann` is refused:
    // "operator '>' is not defined for 'Player'", with the hint "declare '>' on 'Player', or the
    // '<' it is derived from". And `Player` could not use field-by-field `==` at all, since its
    // `name` is a slice; the declared `==` is what makes players comparable.
    return 0;
}