.

README.md

@@ -87,7 +87,7 @@ data.group_by(|x| x % 2);         // HashMap::from([(0, vec![2]), (1, vec![1, 3]
 | *group_fold_to*           |    :heavy_check_mark:     |                    |      :heavy_check_mark:       |                    |
 | *group_reduce*            |    :heavy_check_mark:     |                    |      :heavy_check_mark:       |                    |
 | *interleave*              |    :heavy_check_mark:     |                    |                               |                    |
-| *interleave_shortest*     |    :heavy_check_mark:     |                    |                               |                    |
+| *interleave_exact*        |    :heavy_check_mark:     |                    |                               |                    |
 | *intersect*               |    :heavy_check_mark:     |                    |      :heavy_check_mark:       | :heavy_check_mark: |
 | *intersperse*             |    :heavy_check_mark:     |                    |                               |                    |
 | *intersperse_with*        |    :heavy_check_mark:     |                    |                               |                    |

src/extensions/sequence.rs

@@ -500,6 +500,30 @@ pub trait Sequence<Item> {
     iterator.take(size).collect()
   }
 
+  /// Create a new sequence by interleaving the elements of this sequence with
+  /// the elements of another collection.
+  ///
+  /// If one sequence is longer than another, the remaining elements of the
+  /// longer sequence are added to the end of the new collection.
+  ///
+  /// Elements are added to the new collection in an alternating fashion.
+  /// The first element comes from this sequence, the second element
+  /// comes from the other collection and so on.
+  ///
+  /// # Example
+  ///
+  /// ```
+  /// use cantrip::*;
+  ///
+  /// # let source = vec![1, 2, 3];
+  /// let a = vec![1, 2, 3];
+  ///
+  /// assert_eq!(a.interleave(vec![4, 5, 6]), vec![1, 4, 2, 5, 3, 6]);
+  /// # let a = source.clone();
+  /// assert_eq!(a.interleave(vec![4, 5]), vec![1, 4, 2, 5, 3]);
+  /// # let a = source.clone();
+  /// assert_eq!(a.interleave(vec![]), vec![1, 2, 3]);
+  /// ```
   fn interleave(self, elements: impl IntoIterator<Item = Item>) -> Self
   where
     Self: IntoIterator<Item = Item> + FromIterator<Item>,
@@ -508,18 +532,43 @@ pub trait Sequence<Item> {
     let mut iterator_right = elements.into_iter();
     unfold(true, |left| {
       let result = if *left {
-        iterator_left.next().or(iterator_right.next())
+        iterator_left.next().or_else(|| iterator_right.next())
       } else {
-        iterator_right.next().or(iterator_left.next())
+        iterator_right.next().or_else(|| iterator_left.next())
       };
       *left = !*left;
       result
     })
     .collect()
   }
 
+
+  /// Create a new sequence by interleaving the elements of this sequence with
+  /// the elements of another collection.
+  ///
+  /// If one sequence is longer than another, the remaining elements of the
+  /// longer sequence are omitted.
+  ///
+  /// Elements are added to the new collection in an alternating fashion.
+  /// The first element comes from this sequence, the second element
+  /// comes from the other collection and so on.
+  ///
+  /// # Example
+  ///
+  /// ```
+  /// use cantrip::*;
+  ///
+  /// # let source = vec![1, 2, 3];
+  /// let a = vec![1, 2, 3];
+  ///
+  /// assert_eq!(a.interleave_exact(vec![4, 5, 6]), vec![1, 4, 2, 5, 3, 6]);
+  /// # let a = source.clone();
+  /// assert_eq!(a.interleave_exact(vec![4, 5]), vec![1, 4, 2, 5]);
+  /// # let a = source.clone();
+  /// assert_eq!(a.interleave_exact(vec![]), vec![]);
+  /// ```
   #[inline]
-  fn interleave_shortest(self, elements: impl IntoIterator<Item = Item>) -> Self
+  fn interleave_exact(self, elements: impl IntoIterator<Item = Item>) -> Self
   where
     Self: IntoIterator<Item = Item> + FromIterator<Item>,
   {

src/lib.rs

@@ -91,7 +91,7 @@
 /// | *group_fold_to*           |    :heavy_check_mark:     |                    |      :heavy_check_mark:       |                    |
 /// | *group_reduce*            |    :heavy_check_mark:     |                    |      :heavy_check_mark:       |                    |
 /// | *interleave*              |    :heavy_check_mark:     |                    |                               |                    |
-/// | *interleave_shortest*     |    :heavy_check_mark:     |                    |                               |                    |
+/// | *interleave_exact*        |    :heavy_check_mark:     |                    |                               |                    |
 /// | *intersect*               |    :heavy_check_mark:     |                    |      :heavy_check_mark:       | :heavy_check_mark: |
 /// | *intersperse*             |    :heavy_check_mark:     |                    |                               |                    |
 /// | *intersperse_with*        |    :heavy_check_mark:     |                    |                               |                    |