cantrip 0.5.0

Practical extension methods for standard Rust collections
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

use crate::core::unfold::unfold;

/// List operations.
///
/// Methods have the following properties:
///
/// - Requires the collection to represent a list
/// - Does not consume the list or its elements
/// - Does not create a new list
pub trait List<Item> {
  /// Returns the first element of this sequence, or `None` if it is empty.
  ///
  /// # Examples
  ///
  /// ```
  /// use std::collections::LinkedList;
  ///
  /// use cantrip::*;
  ///
  /// let a = LinkedList::from([1, 2, 3]);
  ///
  /// assert_eq!(a.first(), Some(&1));
  /// ```
  #[must_use]
  fn first(&self) -> Option<&Item>;

  /// Returns the last element of this sequence, or `None` if it is empty.
  ///
  /// # Examples
  ///
  /// ```
  /// use std::collections::LinkedList;
  ///
  /// use cantrip::*;
  ///
  /// let a = LinkedList::from([1, 2, 3]);
  ///
  /// assert_eq!(a.last(), Some(&3));
  /// ```
  #[must_use]
  fn last(&self) -> Option<&Item>;

  /// Creates a new collection by repeating this collection the specified number of times.
  ///
  /// # Example
  ///
  /// ```
  /// use std::collections::LinkedList;
  ///
  /// use cantrip::*;
  ///
  /// # let a_source = LinkedList::from([1, 2, 3]);
  /// let a = LinkedList::from([1, 2, 3]);
  ///
  /// assert_eq!(a.repeat(2), LinkedList::from([1, 2, 3, 1, 2, 3]));
  /// # let a = a_source.clone();
  /// assert_eq!(a.repeat(0), LinkedList::new());
  /// ```
  #[must_use]
  fn repeat(self, n: usize) -> Self
  where
    Item: Clone;
}

pub(crate) fn repeat<'a, Item: Clone + 'a, Collection: FromIterator<Item>>(
  iterator: impl Iterator<Item = &'a Item>, n: usize,
) -> Collection {
  let collection = iterator.collect::<Vec<&Item>>();
  let mut values = collection.iter().cycle();
  let mut remaining = collection.len() * n;
  unfold(|| {
    if remaining == 0 {
      return None;
    }
    let new_item = values.next().map(|&x| x.clone());
    remaining -= 1;
    new_item
  })
  .collect()
}