Add conditional LazySequenceProtocol conformance where appropriate

Author: timvermeulen

Sources/Algorithms/Chain.swift

@@ -250,6 +250,7 @@ extension Chain: BidirectionalCollection
 
 extension Chain: RandomAccessCollection
   where Base1: RandomAccessCollection, Base2: RandomAccessCollection {}
+extension Chain: LazySequenceProtocol where Base1: LazySequenceProtocol {}
 
 extension Chain: Equatable where Base1: Equatable, Base2: Equatable {}
 extension Chain: Hashable where Base1: Hashable, Base2: Hashable {}

Sources/Algorithms/Combinations.swift

@@ -111,6 +111,7 @@ extension Combinations: Sequence {
   }
 }
 
+extension Combinations: LazySequenceProtocol where Base: LazySequenceProtocol {}
 extension Combinations: Equatable where Base: Equatable {}
 extension Combinations: Hashable where Base: Hashable {}
 

Sources/Algorithms/Cycle.swift

@@ -38,6 +38,8 @@ extension Cycle: Sequence {
   }
 }
 
+extension Cycle: LazySequenceProtocol where Base: LazySequenceProtocol {}
+
 //===----------------------------------------------------------------------===//
 // cycled()
 //===----------------------------------------------------------------------===//
@@ -71,13 +73,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.
   ///

Sources/Algorithms/Indexed.swift

@@ -56,9 +56,14 @@ extension Indexed: BidirectionalCollection where Base: BidirectionalCollection {
 }
 
 extension Indexed: RandomAccessCollection where Base: RandomAccessCollection {}
+extension Indexed: LazySequenceProtocol where Base: LazySequenceProtocol {}
 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.

Sources/Algorithms/Permutations.swift

@@ -129,6 +129,8 @@ extension Permutations: Sequence {
   }
 }
 
+extension Permutations: LazySequenceProtocol where Base: LazySequenceProtocol {}
+
 //===----------------------------------------------------------------------===//
 // nextPermutation(by:)
 //===----------------------------------------------------------------------===//
@@ -177,7 +179,7 @@ extension MutableCollection
 }
 
 //===----------------------------------------------------------------------===//
-// permutations(count:)
+// permutations(ofCount:)
 //===----------------------------------------------------------------------===//
 
 extension Collection {