Method

// So far a function that works on a struct stands on its own and is handed the struct:
// `Area(card)`. A method is a function that belongs to a type and is called on a value of it:
// `card.Area()`. The value comes first, and the reader sees at once what is being asked about.
//
// Methods are declared in an `extend` block, apart from the struct, which stays a plain list of
// fields. The value a method works on is its first parameter, which is always named `self` and
// has its type written out like any other parameter. `self: &Rectangle` is the read-only
// reference from the Reference lesson, so these methods may read the rectangle but not change it.
import Io::PrintLine;

struct Rectangle {
    width: float64;
    height: float64;
}

extend Rectangle {
    // Inside a method, fields are always reached through `self`. A bare `width` would be an
    // unknown name: `self` is an ordinary parameter, not an implied scope.
    func Area(self: &Rectangle) -> float64 {
        return self.width * self.height;
    }

    func IsSquare(self: &Rectangle) -> bool {
        return self.width == self.height;
    }

    // Further parameters come after `self`.
    func FitsInside(self: &Rectangle, other: &Rectangle) -> bool {
        return self.width <= other.width && self.height <= other.height;
    }
}

struct Circle {
    radius: float64;
}

// Each type has its own methods, so `Circle` can have an `Area` of its own without clashing with
// the one on `Rectangle`. Which one runs is decided by the value before the dot.
extend Circle {
    func Area(self: &Circle) -> float64 {
        return 3.14159 * self.radius * self.radius;
    }
}

func Main() -> int {
    let card = Rectangle { width: 9.0, height: 6.0 };
    let envelope = Rectangle { width: 11.0, height: 11.0 };
    let coin = Circle { radius: 1.25 };

    // The value before the dot becomes `self`, borrowed just as an argument would be.
    PrintLine("card area        {}", card.Area());
    PrintLine("envelope area    {}", envelope.Area());
    PrintLine("coin area        {:.2}", coin.Area());
    PrintLine("card square      {}", card.IsSquare());
    PrintLine("envelope square  {}", envelope.IsSquare());

    // The remaining arguments go in the parentheses, as for any call.
    PrintLine("card in envelope {}", card.FitsInside(envelope));
    PrintLine("envelope in card {}", envelope.FitsInside(card));
    return 0;
}