ds-learn-rust 0.1.1

Code that I wrote while learning Rust from the 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

use std::{thread, time};

#[derive(Debug)]
enum ShirtColor {
    Red,
    Blue,
}

struct Inventory {
    shirts: Vec<ShirtColor>,
}

impl Inventory {
    fn giveaway(&self, user_preferece: Option<ShirtColor>) -> ShirtColor {
        user_preferece.unwrap_or_else(|| self.most_stocked())
    }

    fn most_stocked(&self) -> ShirtColor {
        let mut red_count = 0;
        let mut blue_count = 0;
        for shirt in &self.shirts {
            match shirt {
                ShirtColor::Red => red_count += 1,
                ShirtColor::Blue => blue_count += 1,
            }
        }
        if red_count > blue_count {
            ShirtColor::Red
        } else {
            ShirtColor::Blue
        }
    }
}

fn fn_traits() {
    // Test the Fn, FnOnce & FnMut traits

    fn call_once<F, T>(func: F) -> T
    where
        F: FnOnce() -> T,
    {
        func()
        // calling func() here fails; as expected!
    }
    let i = 10;
    let call_once_func = move || i * 2;
    let x = call_once(call_once_func);
    let y = call_once(call_once_func); // works because i32 implements copy hence call_once_func is copy
    let z = call_once_func(); // Also works becasuse of Copy

    dbg!(i, x, y, z);

    let s = String::from("hello");
    let call_once_func = move || s;
    let x = call_once(call_once_func);
    // But the following lines will fail because call_once_func is now not a copy
    // let y = call_once(call_once_func);
    // let z = call_once_func();
    dbg!(x);

    fn call_mut<F>(mut func: F)
    where
        F: FnMut(),
    {
        func();
        func();
    }

    let mut s = String::from("Loop");

    dbg!(&s);
    let call_mut_func = || s.push('q');

    call_mut(call_mut_func);
    dbg!(&s);
}

pub fn ch_13_01() {
    let inventory = Inventory {
        shirts: vec![ShirtColor::Red, ShirtColor::Blue, ShirtColor::Red],
    };
    let user_preferece = Some(ShirtColor::Blue);
    let giveaway1 = inventory.giveaway(user_preferece);
    dbg!(giveaway1);

    let giveaway2 = inventory.giveaway(None);
    dbg!(giveaway2);

    let mut list = vec![1, 2, 3];
    dbg!(&list);

    let mut borrow_mutably = || list.push(5);
    borrow_mutably();
    dbg!(&list);

    thread::spawn(move || println!("From thread: {:?}", list))
        .join()
        .unwrap();

    fn some_long_func() {
        let duration = time::Duration::from_millis(10);
        let start = time::Instant::now();
        thread::sleep(duration);
        let end = time::Instant::now();
        dbg!(end.duration_since(start));
    }

    thread::spawn(some_long_func).join().unwrap();

    fn_traits();
}