1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#![feature(macro_rules)]

// the possible things that can go wrong
enum SlurpError {
    // The input was malformed (could have line/column number info too)
    InvalidInput,
    // Some piece of IO failed (e.g. couldn't open a file)
    FailedIo(IoError)
}

// short-circuiting macro: "unwrap" the value, an error will return
// from the surrounding function propagating that error upwards.
//
// macro_rules! macros take a sequence of tokens/AST non-terminals and
// attempt to pattern match on them, taking the first branch that
// fits, and then effectively replace the macro invocation with the
// right-hand side of that branch.
macro_rules! try_slurp {
    // `$...` is a special variable, a "macro argument", this `value`
    // is an expression, e.g. `1 + 2`, `foo()`, `if ... { ... } else {
    // ... }`. Hence, to match, this arm needs to be passed an
    // expression, a comma, then a literal `FailedIo`.
    // e.g. `try_slurp!(foo(), FailedIo)`
    ($value: expr, FailedIo) => {
        // The macro expands to this code if the pattern matches. The
        // `$value` expression is `match`d as a `Result<..., IoError>`
        // (passing in something else will be a type error, after the
        // macro expands). Success is unwrapped, and a failure is
        // returned from the function/closure in which the macro is
        // called.
        match $value {
            Ok(x) => x,
            Err(e) => return Err(FailedIo(e))
        }
    };

    // similarly here, this branch takes an arbitrary expression and
    // then has to match exactly `InvalidInput`
    ($value: expr, InvalidInput) => {
        // as above, except handling `$value` as an `Option<...>`.
        match $value {
            Some(x) => x,
            None => return Err(InvalidInput)
        }
    }
}

fn slurp_file(file: &Path) -> Result<Vec<LabelPixel>, SlurpError> {
    use std::{result, option};
    let mut file = BufferedReader::new(try_slurp!(File::open(file), FailedIo));

    let lines = file.lines()
        .skip(1)
        .map(|line| {
            let line = try_slurp!(line, FailedIo);

            let mut splits = line.as_slice().trim().split(',').map(|x| from_str(x));

            // .and_then is flattening Option<Option<int>> to Option<int>.
            let label = try_slurp!(splits.next().and_then(|x| x), InvalidInput);

            let pixels = try_slurp!(option::collect(splits), InvalidInput);

            Ok(LabelPixel {
                label: label,
                pixels: pixels
            })
        });

    result::collect(lines)
}

1
2
3
4
5
6
7
8
9
10
11
let training_set = match slurp_file(&Path::new("trainingsample.csv")) {
    Ok(data) => data,
    Err(e) => {
        match e {
            FailedIo(io) => println!("Couldn't read file: {}", io),
            InvalidInput => println!("Invalid file format")
        }
        std::os::set_exit_status(1);
        return
    }
};