typetui 0.2.1

A terminal-based typing test.
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

fn ownership_basics() {
    let s1 = String::from("hello");
    let s2 = s1;
    println!("{}", s2);

    let x = 5;
    let y = x;
    println!("x = {}, y = {}", x, y);
}

fn borrowing_examples() {
    let mut s = String::from("hello");

    let r1 = &s;
    let r2 = &s;
    println!("{} and {}", r1, r2);

    let r3 = &mut s;
    r3.push_str(" world");
    println!("{}", r3);
}

fn lifetimes_demo<'a>() {
    let s1 = String::from("long string");
    {
        let s2 = String::from("xyz");
        let result = longest(&s1, &s2);
        println!("Longest: {}", result);
    }
}

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

fn move_semantics() {
    let data = vec![1, 2, 3, 4, 5];
    
    let doubled: Vec<i32> = data.into_iter()
        .map(|x| x * 2)
        .collect();
    
    println!("Doubled: {:?}", doubled);
}

fn clone_example() {
    let s1 = String::from("hello");
    let s2 = s1.clone();
    
    println!("s1 = {}, s2 = {}", s1, s2);
}

fn reference_counting() {
    use std::rc::Rc;
    
    let data = Rc::new(String::from("shared data"));
    let data2 = Rc::clone(&data);
    let data3 = Rc::clone(&data);
    
    println!("Reference count: {}", Rc::strong_count(&data));
    println!("Data: {}, {}, {}", data, data2, data3);
}

fn atomic_reference() {
    use std::sync::Arc;
    use std::thread;
    
    let data = Arc::new(String::from("thread-safe data"));
    let data2 = Arc::clone(&data);
    
    let handle = thread::spawn(move || {
        println!("In thread: {}", data2);
    });
    
    println!("In main: {}", data);
    handle.join().unwrap();
}

fn slice_examples() {
    let s = String::from("hello world");
    
    let hello = &s[0..5];
    let world = &s[6..11];
    
    println!("hello: {}, world: {}", hello, world);
    
    let a = [1, 2, 3, 4, 5];
    let slice = &a[1..3];
    println!("Array slice: {:?}", slice);
}

fn box_smart_pointer() {
    let b = Box::new(5);
    println!("Box value: {}", b);
    
    let list = Box::new(Cons(1, Box::new(Cons(2, Box::new(Cons(3, Box::new(Nil)))))));
    println!("List created");
}

enum List {
    Cons(i32, Box<List>),
    Nil,
}

fn deref_trait() {
    let x = 5;
    let y = &x;
    
    assert_eq!(5, x);
    assert_eq!(5, *y);
}

fn main() {
    ownership_basics();
    borrowing_examples();
    lifetimes_demo();
    move_semantics();
    clone_example();
    reference_counting();
    atomic_reference();
    slice_examples();
    box_smart_pointer();
    deref_trait();
}