arraylib 0.3.0

Tools for working with arrays
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
130

use core::{mem, slice, slice::SliceIndex};

use crate::Array;

/// Shorthand methods those just refer to `self.as_slice().smt()`
pub trait ArrayShorthand: Array {
    /// Returns a reference to the value corresponding to the supplied index.
    ///
    /// ## Example
    /// ```
    /// use arraylib::{Array, ArrayShorthand};
    ///
    /// fn slice<A>(arr: &A) -> (&A::Item, &[A::Item])
    /// where
    ///     A: Array,
    /// {
    ///     (arr.index(0), arr.index(1..))
    /// }
    ///
    /// assert_eq!(slice(&[1, 2, 3]), (&1, &[2, 3][..]))
    /// ```
    ///
    /// See also: [`index_mut`](ArrayShorthand::index_mut)
    #[inline]
    fn index<Idx>(&self, idx: Idx) -> &Idx::Output
    where
        Idx: SliceIndex<[Self::Item]>,
    {
        &self.as_slice()[idx]
    }

    /// Returns a unique reference to the value corresponding to the supplied
    /// index.
    ///
    /// ## Example
    /// ```
    /// use arraylib::{Array, ArrayShorthand};
    ///
    /// fn slice<A>(arr: &mut A) -> &mut [A::Item]
    /// where
    ///     A: Array,
    /// {
    ///     arr.index_mut(1..)
    /// }
    ///
    /// assert_eq!(slice(&mut [1, 2, 3]), &mut [2, 3])
    /// ```
    ///
    /// See also: [`index`](ArrayShorthand::index)
    #[inline]
    fn index_mut<Idx>(&mut self, idx: Idx) -> &mut Idx::Output
    where
        Idx: SliceIndex<[Self::Item]>,
    {
        &mut self.as_mut_slice()[idx]
    }

    /// Replace element of the array
    ///
    /// ## Example
    /// ```
    /// use arraylib::ArrayShorthand;
    ///
    /// let mut arr = ["hello", "", "world"];
    /// assert_eq!(arr.replace(1, ", "), "");
    /// assert_eq!(arr, ["hello", ", ", "world"])
    /// ```
    #[inline]
    fn replace(&mut self, idx: usize, item: Self::Item) -> Self::Item {
        mem::replace(self.index_mut(idx), item)
    }

    /// Take element of the array, replacing it with default
    ///
    /// ## Example
    /// ```
    /// use arraylib::ArrayShorthand;
    ///
    /// let mut arr = [String::from("hello, "), String::from("world")];
    /// assert_eq!(arr.take(1), "world");
    /// assert_eq!(arr, ["hello, ", ""])
    /// ```
    #[inline]
    fn take(&mut self, idx: usize) -> Self::Item
    where
        Self::Item: Default,
    {
        self.replace(idx, <_>::default())
    }

    /// Returns an iterator over refs to the array.
    ///
    /// # Examples
    ///
    /// ```
    /// use arraylib::ArrayShorthand;
    ///
    /// let arr = [1, 2, 4];
    /// let mut iterator = arr.iter();
    ///
    /// assert_eq!(iterator.next(), Some(&1));
    /// assert_eq!(iterator.next(), Some(&2));
    /// assert_eq!(iterator.next(), Some(&4));
    /// assert_eq!(iterator.next(), None);
    /// ```
    #[inline]
    fn iter(&self) -> slice::Iter<'_, Self::Item> {
        self.as_slice().iter()
    }

    /// Returns an iterator that allows modifying each value.
    ///
    /// # Examples
    ///
    /// ```
    /// use arraylib::ArrayShorthand;
    ///
    /// let mut arr = [1, 2, 4];
    /// for elem in arr.iter_mut() {
    ///     *elem += 2;
    /// }
    /// assert_eq!(arr, [3, 4, 6]);
    /// ```
    #[inline]
    fn iter_mut(&mut self) -> slice::IterMut<'_, Self::Item> {
        self.as_mut_slice().iter_mut()
    }
}

impl<A> ArrayShorthand for A where A: Array {}