Add LazySequenceProtocol overloads that maintain laziness

Author: timvermeulen

Sources/Algorithms/Chain.swift

@@ -289,3 +289,19 @@ extension Sequence {
     Chain(base1: self, base2: other)
   }
 }
+
+//===----------------------------------------------------------------------===//
+// lazy.chained(with:)
+//===----------------------------------------------------------------------===//
+
+extension LazySequenceProtocol {
+  /// Returns a new lazy sequence that iterates over this sequence, followed by
+  /// the given sequence.
+  public func chained<S: Sequence>(
+    with other: S
+  ) -> LazySequence<Chain<Elements, S>>
+    where Element == S.Element
+  {
+    elements.chained(with: other).lazy
+  }
+}

Sources/Algorithms/Combinations.swift

@@ -151,3 +151,17 @@ extension Collection {
     return Combinations(self, k: k)
   }
 }
+
+//===----------------------------------------------------------------------===//
+// lazy.combinations(count:)
+//===----------------------------------------------------------------------===//
+
+extension LazyCollectionProtocol {
+  /// Returns a lazy collection of combinations of this collection's elements,
+  /// with each combination having the specificed number of elements.
+  public func combinations(
+    ofCount k: Int
+  ) -> LazySequence<Combinations<Elements>> {
+    elements.combinations(ofCount: k).lazy
+  }
+}

Sources/Algorithms/Cycle.swift

@@ -71,13 +71,7 @@ extension Collection {
   public func cycled() -> Cycle<Self> {
     Cycle(base: self)
   }
-}
-
-//===----------------------------------------------------------------------===//
-// repeated(count:)
-//===----------------------------------------------------------------------===//
-
-extension Collection {
+  
   /// Returns a sequence that repeats the elements of this collection the
   /// specified number of times.
   ///
@@ -99,3 +93,23 @@ extension Collection {
     repeatElement(self, count: times).joined()
   }
 }
+
+//===----------------------------------------------------------------------===//
+// lazy.cycled()
+//===----------------------------------------------------------------------===//
+
+extension LazyCollection {
+  /// Returns a lazy sequence that repeats the elements of this collection
+  /// forever.
+  public func cycled() -> LazySequence<Cycle<Elements>> {
+    elements.cycled().lazy
+  }
+  
+  /// Returns a lazy sequence that repeats the elements of this collection the
+  /// specified number of times.
+  public func cycled(
+    times: Int
+  ) -> LazySequence<FlattenSequence<Repeated<Elements>>> {
+    elements.cycled(times: times).lazy
+  }
+}

Sources/Algorithms/Indexed.swift

@@ -59,6 +59,10 @@ extension Indexed: RandomAccessCollection where Base: RandomAccessCollection {}
 extension Indexed: Equatable where Base: Equatable {}
 extension Indexed: Hashable where Base: Hashable {}
 
+//===----------------------------------------------------------------------===//
+// indexed()
+//===----------------------------------------------------------------------===//
+
 extension Collection {
   /// Returns a collection of pairs *(i, x)*, where *i* represents an index of
   /// the collection, and *x* represents an element.
@@ -79,3 +83,15 @@ extension Collection {
     Indexed(base: self)
   }
 }
+
+//===----------------------------------------------------------------------===//
+// lazy.indexed()
+//===----------------------------------------------------------------------===//
+
+extension LazyCollectionProtocol {
+  /// Returns a lazy collection of pairs *(i, x)*, where *i* represents an index
+  ///  of the collection, and *x* represents an element.
+  public func indexed() -> LazySequence<Indexed<Elements>> {
+    elements.indexed().lazy
+  }
+}

Sources/Algorithms/Permutations.swift

@@ -177,7 +177,7 @@ extension MutableCollection
 }
 
 //===----------------------------------------------------------------------===//
-// permutations(count:)
+// permutations(ofCount:)
 //===----------------------------------------------------------------------===//
 
 extension Collection {
@@ -234,3 +234,17 @@ extension Collection {
     return Permutations(self, k: k)
   }
 }
+
+//===----------------------------------------------------------------------===//
+// lazy.permutations(ofCount:)
+//===----------------------------------------------------------------------===//
+
+extension LazyCollectionProtocol {
+  /// Returns a lazy collection of the permutations of this collection of the
+  /// specified length.
+  public func permutations(
+    ofCount k: Int? = nil
+  ) -> LazySequence<Permutations<Elements>> {
+    elements.permutations(ofCount: k).lazy
+  }
+}