Equatable

// Two values can be "the same" in more than one sense. The fractions 1/2 and 2/4 are written
// differently, yet they stand for the same number, and a program that calls them different will
// give wrong answers.
//
// `Equatable`, from Core, is the interface a type implements to say what equality means for it.
// It asks for one method, `Equals(other: &Self) -> bool`. `Self` stands for whichever type is
// implementing it, so a Fraction is only ever compared with another Fraction.
//
// Implementing it is also a promise about how `Equals` behaves, which any code relying on it is
// entitled to assume:
//   - every value equals itself;
//   - `a.Equals(b)` and `b.Equals(a)` always agree;
//   - if a equals b, and b equals c, then a equals c.
import Core::Equatable;
import Io::PrintLine;

struct Fraction {
    top: int32;
    bottom: int32;
}

extend Fraction : Equatable {
    // Cross-multiplying compares the two numbers without dividing, so no remainder is lost:
    // 1/2 and 2/4 are equal because 1 * 4 == 2 * 2.
    func Equals(self: &Fraction, other: &Fraction) -> bool {
        return self.top * other.bottom == other.top * self.bottom;
    }
}

func Main() -> int {
    let half = Fraction { top: 1, bottom: 2 };
    let twoQuarters = Fraction { top: 2, bottom: 4 };
    let fourEighths = Fraction { top: 4, bottom: 8 };
    let third = Fraction { top: 1, bottom: 3 };

    PrintLine("1/2 equals 2/4: {}", half.Equals(twoQuarters));
    PrintLine("1/2 equals 1/3: {}", half.Equals(third));

    // The three promises, checked on these values.
    PrintLine("itself:     {}", half.Equals(half));
    PrintLine("either way: {}", half.Equals(twoQuarters) == twoQuarters.Equals(half));
    PrintLine("in a chain: {}", half.Equals(twoQuarters) && twoQuarters.Equals(fourEighths)
                                && half.Equals(fourEighths));

    // Because the meaning is settled once, in one place, every search agrees with it.
    let pile: Fraction[4] = [third, twoQuarters, fourEighths, half];
    var halves = 0;
    for each in pile {
        if each.Equals(half) {
            halves += 1;
        }
    }
    PrintLine("halves in the pile: {}", halves);

    // `Equals` is a method, not the `==` operator. Implementing Equatable leaves `==` exactly as
    // it was; the lessons on structural equality and operator overloading cover `==`.
    return 0;
}