rust_book14 0.1.0

Publish library on crates.io.
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
129

//! `Rust` book lessons.
//! Chapter [14](https://doc.rust-lang.org/book/ch14-00-more-about-cargo.html).

pub mod slices {
    //! Slices utils.

    /// Returns the contained first value or computes it from a closure.
    /// See: [`Option::unwrap_or_else`]
    ///
    /// # Examples
    ///
    /// ```
    /// let slice = [1, 2, 3];
    /// let it = rust_book14::slices::get_first_or_else(&slice, || &-1);
    /// assert_eq!(1, *it);
    ///
    /// let slice = [];
    /// let it = rust_book14::slices::get_first_or_else(&slice, || &-1);
    /// assert_eq!(-1, *it);
    /// ```
    pub fn get_first_or_else<'a, T, F: FnOnce() -> &'a T>(slice: &'a [T], f: F) -> &'a T {
        if slice.is_empty() {
            return f();
        }
        return &slice[0];
        // return slice.get(0).unwrap_or_else(f);
    }
}

/// Returns the contained first value or computes it from a closure.
/// See: [`Option::unwrap_or_else`]
///
/// # Examples
///
/// ```
/// let list = vec![1, 2, 3];
/// let answer = rust_book14::get_first_or_else(&list, || &-1);
/// assert_eq!(1, *answer);
///
/// let list = vec![];
/// let answer = rust_book14::get_first_or_else(&list, || &-1);
/// assert_eq!(-1, *answer);
/// ```
pub fn get_first_or_else<'a, T, F: FnOnce() -> &'a T>(list: &'a Vec<T>, f: F) -> &'a T {
    if list.is_empty() {
        return f();
    }
    return &list[0];
    // return list.get(0).unwrap_or_else(f);
}

/// Returns the contained first value or a provided default.
/// See: [`Option::unwrap_or`]
///
/// # Examples
///
/// ```
/// let list = vec![1, 2, 3];
/// let answer = rust_book14::get_first_or(&list, &-1);
/// assert_eq!(1, *answer);
///
/// let list = vec![];
/// let answer = rust_book14::get_first_or(&list, &-1);
/// assert_eq!(-1, *answer);
/// ```
pub fn get_first_or<'a, T>(list: &'a Vec<T>, default: &'a T) -> &'a T {
    if list.is_empty() {
        return default;
    }
    return &list[0];
    // return list.get(0).unwrap_or(default);
}

/// [`Some(value)`]: Some
/// [`Err(err)`]: Err
///
/// Returns the contained first [`Some(value)`] or a provided [`Err(err)`].
/// See: [`Option::ok_or`]
///
/// # Errors
///
/// If the `list` is empty, an [`Err(err)`] will be returned.
///
/// # Examples
///
/// ```
/// let list = vec![1, 2, 3];
/// let answer = rust_book14::get_first_or_error(&list, "foo");
/// assert_eq!(Ok(&1), answer);
///
/// let list: Vec<u8> = vec![];
/// let answer = rust_book14::get_first_or_error(&list, "foo");
/// assert_eq!(Err("foo"), answer);
/// ```
pub fn get_first_or_error<T, U>(list: &Vec<T>, err: U) -> Result<&T, U> {
    if list.is_empty() {
        return Err(err);
    }
    return Ok(&list[0]);
    // return list.get(0).ok_or(err);
}

/// Returns the contained first value or panics with a `msg`.
/// See: [`Option::expect`]
///
/// # Panics
///
/// If the `list` is empty, panics with a `msg`.
///
/// # Examples
///
/// ```
/// let list = vec![1, 2, 3];
/// let answer = rust_book14::get_first_or_panic(&list, "foo");
/// assert_eq!(&1, answer);
///
/// let list: Vec<u8> = vec![];
/// let result = std::panic::catch_unwind(|| {
///     rust_book14::get_first_or_panic(&list, "foo")
/// });
/// assert!(result.is_err());
/// ```
pub fn get_first_or_panic<'a, T>(list: &'a Vec<T>, msg: &str) -> &'a T {
    if list.is_empty() {
        panic!("{msg}");
    }
    return &list[0];
    // return list.get(0).expect(msg);
}