Nested optional

// A player who has not played yet has no score, so the team sheet stores each
// score as an `int?`. Now look a player up by number. The answer can be
// missing for two different reasons:
//
//     none                   nobody wears that number
//     .Some(none)            the player exists, but has no score yet
//     .Some(.Some(score))    the player exists and has scored
//
// The type that holds all three is `int??`, an optional of an optional. Rux
// never squashes the two levels into one, so the two kinds of "nothing" stay
// different and you can tell them apart.
import Io::PrintLine;

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

// `player.score` is an `int?`. Returned from here it becomes a present `int??`
// on its own, even when the score inside is `none`. Only the `none` at the
// bottom means "not found".
func ScoreOf(players: Player[..], number: int) -> int?? {
    for player in players {
        if player.number == number {
            return player.score;
        }
    }
    return none;
}

// Each `?` in a pattern opens one level. `score??` is "a present, present
// score". `none?` is "a present `none`": the player was found but has no
// score. Plain `none` is the outer absence.
func Report(players: Player[..], number: int) {
    match ScoreOf(players, number) {
        score?? => PrintLine("#{} scored {}", number, score),
        none? => PrintLine("#{} has not played yet", number),
        none => PrintLine("#{} is not on the team", number)
    }
}

// The same three cases in the long spelling.
func ReportLong(players: Player[..], number: int) {
    match ScoreOf(players, number) {
        .Some(.Some(score)) => PrintLine("#{} scored {}", number, score),
        .Some(none) => PrintLine("#{} has not played yet", number),
        none => PrintLine("#{} is not on the team", number)
    }
}

func Main() -> int {
    let players = [
        Player { number: 7, score: 12 },
        Player { number: 9, score: none }
    ];

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

    // `??` opens just one level too. For #9 the outer level is present, so
    // the fallback is not used and `once` is the inner `none`, still an
    // `int?`. A second `??` deals with that one.
    let once = ScoreOf(players, 9) ?? 0;
    let twice = once ?? 0;
    PrintLine("#9 opened once is still none: {}", once == none);
    PrintLine("#9 opened twice: {}", twice);

    // Watch out: that first `?? 0` looks as if it gives an `int`, and it does
    // compile, but only because the `0` is made into a present `int?` to
    // match the inner level. Try printing `once` directly: the compiler
    // refuses, because an `int?` is not something `PrintLine` can show.
    return 0;
}