Presence

// An `int?` holds either an `int` or nothing, and the program cannot do sums
// with it until it knows which. `match` is how you find out. It opens the
// optional and hands you what is inside, but only in the arm where something
// is actually there.
//
// There are two arms to write:
//
//     score? => ...    present: `score` is the `int` inside
//     none => ...      absent: there is nothing to bind
//
// `score?` is a pattern, not a question. Read the `?` as "a present ...". The
// name before it becomes an ordinary `int`, but only inside its arm.
import Io::PrintLine;

struct Player {
    number: int;
    score: int;
}

// The score of the player wearing `number`, or `none` when nobody does.
func ScoreOf(players: Player[..], number: int) -> int? {
    for player in players {
        if player.number == number {
            return player.score;
        }
    }
    return none;
}

func Report(players: Player[..], number: int) {
    match ScoreOf(players, number) {
        score? => PrintLine("#{} scored {}", number, score),
        none => PrintLine("#{} is not on the team", number)
    }
}

// The same match with the long spelling. `.Some(score)` and `score?` mean the
// same thing, much as a variant case is matched by name. The short form is the
// usual one.
func ReportLong(players: Player[..], number: int) {
    match ScoreOf(players, number) {
        .Some(score) => PrintLine("#{} scored {}", number, score),
        none => PrintLine("#{} is not on the team", number)
    }
}

// The `?` wraps any pattern, so a literal and a guard work as usual. The arms
// are tried from the top, so the general `score?` arm comes after the
// specific ones.
func Rating(players: Player[..], number: int) -> char8[..] {
    return match ScoreOf(players, number) {
        0? => "has not scored yet",
        score? if score >= 20 => "is the top scorer",
        score? => "is a regular",
        none => "is not on the team"
    };
}

func Main() -> int {
    let players = [
        Player { number: 4, score: 0 },
        Player { number: 7, score: 12 },
        Player { number: 10, score: 25 }
    ];

    Report(players, 7);
    Report(players, 9);
    ReportLong(players, 10);

    for number in [ 4, 7, 10, 9 ] {
        let rating = Rating(players, number);
        PrintLine("#{} {}", number, rating);
    }

    // Watch out: the `none` arm is required. If you leave it out, the
    // compiler stops with "match on 'int?' is not exhaustive; missing none",
    // because that is the case the optional exists to make you handle.
    return 0;
}