Iterator

// `for` has walked ranges and arrays since the Control flow part. It can walk a type of your own
// too, once that type has one method:
//     func Next(self: &var T) -> Item?
// Each call hands out the next item, or `none` when there are no more. `for` calls `Next` again
// and again, runs the loop body with every item it gets, and stops at the first `none`. The item
// type is whatever the optional carries: `int32` here.
//
// A type with such a `Next` is called an iterator. `extend Countdown : Iterator` names that role
// for a reader, but Core's `Iterator` interface lists no methods, because an interface cannot
// spell out an item type that each iterator chooses for itself. `for` goes by `Next` alone.
import Core::Iterator;
import Io::{ Print, PrintLine };

// Counts down from a starting number to 1.
struct Countdown {
    remaining: int32;
}

extend Countdown : Iterator {
    // `&var`, because handing out an item moves the countdown along.
    func Next(self: &var Countdown) -> int32? {
        if self.remaining == 0 {
            return none;
        }
        let current = self.remaining;
        self.remaining -= 1;
        return current;
    }
}

func Main() -> int {
    // `for` calls `Next` until it sees `none`. The parentheses keep the struct's braces apart
    // from the loop body's.
    Print("for:    ");
    for second in (Countdown { remaining: 5 }) {
        Print(" {}", second);
    }
    PrintLine(" liftoff");

    // The same walk by hand. This is all that `for` does.
    var countdown = Countdown { remaining: 5 };
    Print("by hand:");
    loop {
        let second = countdown.Next() ?? break;
        Print(" {}", second);
    }
    PrintLine(" liftoff");

    // An iterator is used up as it goes. Once it has said `none`, it keeps saying `none`.
    PrintLine("anything left? {}", countdown.Next() is int32);
    return 0;
}