Mutating method

// A method that changes the value it is called on takes `self: &var T`, the writable reference
// from the MutableReference lesson. Its writes land in the value before the dot.
//
// This is where methods start to pay off. A `Stack` is an array plus a count of how much of it is
// in use, and the two must change together. If every caller updated them by hand, one would
// sooner or later forget the count. With `Push` and `Pop` as the only code that changes them,
// they stay in step.
import Io::PrintLine;

struct Stack {
    items: int[4];
    length: uint;
}

extend Stack {
    // A reading method still takes `&Stack`, and can be called on any stack.
    func IsEmpty(self: &Stack) -> bool {
        return self.length == 0;
    }

    func IsFull(self: &Stack) -> bool {
        return self.length == 4;
    }

    // A writing method takes `&var Stack`. It may also return a value: here, whether the push
    // happened, since a full stack has no room left.
    func Push(self: &var Stack, value: int) -> bool {
        if self.IsFull() {
            return false;
        }
        self.items[self.length] = value;
        self.length += 1;
        return true;
    }

    // Only to be called on a stack that is not empty; the caller checks `IsEmpty` first.
    func Pop(self: &var Stack) -> int {
        self.length -= 1;
        return self.items[self.length];
    }
}

func Main() -> int {
    // A writing method needs a `var` to work on, just as assigning a field would. Had `stack`
    // been declared with `let`, every `Push` and `Pop` below would be rejected, while `IsEmpty`
    // and `IsFull` would still be allowed.
    var stack = Stack { items: [0; 4], length: 0 };

    for value in 1..=5 {
        let pushed = stack.Push(value * 10);
        PrintLine("push {}  accepted {}", value * 10, pushed);
    }
    PrintLine("full {}", stack.IsFull());

    while !stack.IsEmpty() {
        PrintLine("pop  {}", stack.Pop());
    }
    PrintLine("empty {}", stack.IsEmpty());
    return 0;
}