rust_book_code 0.2.1

The code of rust book
Documentation 
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use std::fs::File;
use std::io::{ErrorKind, Read};
use std::{fs, io};

pub fn open_file() {
    let f = File::open("./rust_book_code/hello.txt");

    let f = match f {
        Ok(file) => file,
        Err(error) => panic!("Problem opening the file: {:?}", error),
    };
}

pub fn recoverable_errors() {
    let f = File::open("./rust_book_code/hello.txt");

    let f = match f {
        Ok(file) => file,
        Err(error) => match error.kind() {
            ErrorKind::NotFound => match File::create("./rust_book_code/hello.txt") {
                Ok(fc) => fc,
                Err(e) => panic!("Problem creating the file: {:?}", e),
            },
            other_error => panic!("Problem opening the file: {:?}", other_error),
        },
    };
}

pub fn unwrap_or_else() {
    let f = File::open("./rust_book_code/hello.txt").unwrap_or_else(|error| {
        if error.kind() == ErrorKind::NotFound {
            File::create("./rust_book_code/hello.txt").unwrap_or_else(|error| {
                panic!("Problem creating the file: {:?}", error);
            })
        } else {
            panic!("Problem opening the file: {:?}", error)
        }
    });
}

pub fn unwrap_and_expect() {
    let f = File::open("./rust_book_code/hello.txt").unwrap();

    let f = File::open("./rust_book_code/hello.txt").expect("Failed to open hello.txt");
}

pub fn propagate_errors() {
    let result = match read_username_from_file() {
        Ok(s) => s,
        Err(err) => panic!("failed to read username"),
    };

    println!("{}", result);

    fn read_username_from_file() -> Result<String, io::Error> {
        let f = File::open("./rust_book_code/hello.txt");

        let mut f = match f {
            Ok(file) => file,
            Err(e) => return Err(e),
        };

        let mut s = String::new();

        match f.read_to_string(&mut s) {
            Ok(_) => Ok(s),
            Err(e) => Err(e),
        }
    }
}

pub fn propagate_errors_shortcut() {
    let result = match read_username_from_file() {
        Ok(s) => s,
        Err(err) => panic!("failed to read username"),
    };

    println!("{}", result);

    fn read_username_from_file() -> Result<String, io::Error> {
        let mut username_file = File::open("./rust_book_code/hello.txt")?;
        let mut username = String::new();
        username_file.read_to_string(&mut username)?;
        Ok(username)
    }
}

pub fn shortcut_chains() {
    let result = match read_username_from_file() {
        Ok(s) => s,
        Err(err) => panic!("failed to read username"),
    };

    println!("{}", result);

    fn read_username_from_file() -> Result<String, io::Error> {
        let mut username = String::new();
        File::open("./rust_book_code/hello.txt")?.read_to_string(&mut username)?;
        Ok(username)
    }
}

pub fn read_to_string() {
    let result = match read_username_from_file() {
        Ok(s) => s,
        Err(err) => panic!("failed to read username"),
    };

    println!("{}", result);

    fn read_username_from_file() -> Result<String, io::Error> {
        fs::read_to_string("./rust_book_code/hello.txt")
    }
}

pub fn last_char() {
    assert_eq!(
        last_char_of_first_line("Hello, world\nHow are you today?"),
        Some('d')
    );

    assert_eq!(last_char_of_first_line(""), None);
    assert_eq!(last_char_of_first_line("\nhi"), None);
}

fn last_char_of_first_line(text: &str) -> Option<char> {
    text.lines().next()?.chars().last()
}