Interface parameter

// A function can ask for an interface instead of a concrete type, and then any type that keeps
// the promise may be passed to it. The caller hands over its own thermostat or volume knob, and
// the conversion to the interface happens at the call.
//
// Written with `&`, the parameter borrows, exactly as `&T` did in the Reference lesson: nothing is
// copied, and the function sees the caller's value as it is right now. Written with `&var`, the
// borrow is writable, so a change made through the interface lands on the caller's own variable.
//
// The interface has to say which of its requirements write. A requirement with no `self` only
// reads the value; one that changes it declares `self: &var Self`, where `Self` stands for
// whichever type implements the interface. Leave that out and every `Adjust` below is refused:
// "method 'Adjust' of 'Thermostat' writes through its receiver, but requirement 'Adjust' of
// interface 'Gauge' only reads it".
import Io::PrintLine;

interface Gauge {
    func Label() -> char8[..];
    func Read() -> int32;
    func Adjust(self: &var Self, amount: int32);
}

struct Thermostat {
    degrees: int32;
}

struct Volume {
    level: int32;
}

extend Thermostat : Gauge {
    func Label(self: &Thermostat) -> char8[..] {
        return "thermostat";
    }

    func Read(self: &Thermostat) -> int32 {
        return self.degrees;
    }

    // Adjusting changes the value, so this method takes `&var` self.
    func Adjust(self: &var Thermostat, amount: int32) {
        self.degrees += amount;
    }
}

extend Volume : Gauge {
    func Label(self: &Volume) -> char8[..] {
        return "volume";
    }

    func Read(self: &Volume) -> int32 {
        return self.level;
    }

    // A volume knob stops at 10, however far it is turned.
    func Adjust(self: &var Volume, amount: int32) {
        self.level += amount;
        if self.level > 10 {
            self.level = 10;
        }
    }
}

// Only reads, so a shared borrow is enough.
func Show(gauge: &Gauge) {
    PrintLine("the {} reads {}", gauge.Label(), gauge.Read());
}

// Calls `Adjust`, which changes the value, so the borrow must be writable too. Written as
// `gauge: &Gauge`, the call below is refused: "cannot call 'Adjust' through immutable reference
// '&Gauge'".
func TurnUp(gauge: &var Gauge, amount: int32) {
    gauge.Adjust(amount);
}

func Main() -> int {
    var heating = Thermostat { degrees: 19 };
    var music = Volume { level: 7 };
    Show(heating);
    Show(music);

    // Each type's own `Adjust` runs: the knob stops at 10, the thermostat does not.
    TurnUp(heating, 5);
    TurnUp(music, 5);

    // The changes were made to these very variables, not to copies of them.
    Show(heating);
    Show(music);
    PrintLine("heating.degrees is now {}", heating.degrees);

    // A writable borrow needs a writable variable. Declare `heating` with `let` and the call is
    // refused: "argument 1 to 'TurnUp' cannot borrow immutable 'heating' as '&var Gauge'".
    return 0;
}