Structural equality

// `==` and `!=` work on more than numbers. Two structs of the same type can be compared without
// writing anything: they are equal when every field is equal, compared in order. The same goes
// for tuples, arrays and variants, and for any mix of them, because comparing a field that is
// itself a struct simply repeats the rule one level down.
//
// This is called structural equality: equal shape, equal parts, equal values. It is the right
// answer for plain data such as points and dates. When a type means something else by "equal",
// as 1/2 and 2/4 did in the Equatable lesson, it defines its own `==`, which the next lesson
// shows.
import Io::PrintLine;

struct Point {
    x: int32;
    y: int32;
}

struct Segment {
    start: Point;
    end: Point;
}

variant Reading {
    Missing,
    Celsius(int32)
}

func Main() -> int {
    let a = Point { x: 1, y: 2 };
    let b = Point { x: 1, y: 2 };
    let flipped = Point { x: 2, y: 1 };

    // Two separate values, field by field the same.
    PrintLine("a == b:        {}", a == b);
    PrintLine("a == flipped:  {}", a == flipped);
    PrintLine("a != flipped:  {}", a != flipped);

    // A struct inside a struct is compared by the same rule.
    let first = Segment { start: a, end: flipped };
    let second = Segment { start: b, end: flipped };
    PrintLine("segments:      {}", first == second);

    // Tuples and arrays compare element by element.
    PrintLine("tuples:        {}", (a, true) == (b, true));
    let left: int32[3] = [1, 2, 3];
    let right: int32[3] = [1, 2, 4];
    PrintLine("arrays:        {}", left == right);

    // Variants are equal when the case matches and so does the payload.
    let warm = Reading::Celsius(21);
    let alsoWarm = Reading::Celsius(21);
    let unknown = Reading::Missing;
    PrintLine("same reading:  {}", warm == alsoWarm);
    PrintLine("vs missing:    {}", warm == unknown);

    // Every part must have its own `==`, and a slice such as `char8[..]` has none. Add a
    // `name: char8[..]` field to Point and `a == b` is refused: "structural equality for 'Point'
    // is unavailable because element type 'char8[..]' has no '==' operator".
    return 0;
}