Add conformances to LazySequenceProtocol and LazyCollectionProtocol (#47)

* Conform Intersperse to LazySequenceProtocol when the base sequence does

* Add conformance to LazyCollectionProtocol

* Conform Indexed to LazyCollectionProtocol when Base conforms

* Rename XCTAssertLazy to XCTAssertLazySequence

* Add XCTAssertLazyCollection

* Add lazy test for Intersperse

* Update Indexed guide

* Add lazy conformances to SlidingWindows

* Update SlidingWindows guide

Author: danielctull

Guides/Indexed.md

@@ -30,6 +30,6 @@ extension Collection {
 ```
 
 `Indexed` scales from a collection up to a random-access collection, depending on 
-its base type. `Indexed` also conforms to `LazySequenceProtocol` when the base type
-conforms.
+its base type. `Indexed` also conforms to `LazySequenceProtocol` and 
+`LazyCollectionProtocol` when the base type conforms.
 

Guides/Intersperse.md

@@ -30,9 +30,10 @@ extension Sequence {
 ```
 
 The new `Intersperse` type represents the sequence when the separator is
-inserted between each element. Intersperse conforms to Collection and 
-BidirectionalCollection when the base sequence conforms to Collection and
-BidirectionalCollection respectively.
+inserted between each element. `Intersperse` conforms to `Collection`,
+`BidirectionalCollection`, `RandomAccessCollection`, `LazySequenceProtocol` and
+`LazyCollectionProtocol` when the base sequence conforms to those respective
+protocols.
 
 ### Complexity
 

Guides/SlidingWindows.md

@@ -37,8 +37,8 @@ The first upper bound is computed eagerly because it determines if the collectio
 ```
 
 The resulting `SlidingWindows` type is a collection, with conditional conformance to the 
-`BidirectionalCollection`, and `RandomAccessCollection`  when the base collection
-conforms.
+`BidirectionalCollection`, `RandomAccessCollection`, and
+`LazyCollectionProtocol` when the base collection conforms.
 
 ### Complexity
 

Sources/Algorithms/Indexed.swift

@@ -70,6 +70,7 @@ extension Indexed: BidirectionalCollection where Base: BidirectionalCollection {
 
 extension Indexed: RandomAccessCollection where Base: RandomAccessCollection {}
 extension Indexed: LazySequenceProtocol where Base: LazySequenceProtocol {}
+extension Indexed: LazyCollectionProtocol where Base: LazyCollectionProtocol {}
 extension Indexed: Equatable where Base: Equatable {}
 extension Indexed: Hashable where Base: Hashable {}
 

Sources/Algorithms/Intersperse.swift

@@ -152,6 +152,12 @@ extension Intersperse: BidirectionalCollection
 extension Intersperse: RandomAccessCollection
   where Base: RandomAccessCollection {}
 
+extension Intersperse: LazySequenceProtocol
+  where Base: LazySequenceProtocol {}
+
+extension Intersperse: LazyCollectionProtocol
+  where Base: LazyCollectionProtocol {}
+
 extension Sequence {
 
   /// Returns a sequence containing elements of this sequence with the given

Sources/Algorithms/SlidingWindows.swift

@@ -299,6 +299,8 @@ extension SlidingWindows: BidirectionalCollection where Base: BidirectionalColle
   }
 }
 
+extension SlidingWindows: LazySequenceProtocol where Base: LazySequenceProtocol {}
+extension SlidingWindows: LazyCollectionProtocol where Base: LazyCollectionProtocol {}
 extension SlidingWindows: RandomAccessCollection where Base: RandomAccessCollection {}
 extension SlidingWindows: Equatable where Base: Equatable {}
 extension SlidingWindows: Hashable where Base: Hashable, Base.Index: Hashable {}

Tests/SwiftAlgorithmsTests/ChunkedTests.swift

@@ -73,7 +73,7 @@ final class ChunkedTests: XCTestCase {
   }
 
   func testChunkedLazy() {
-    XCTAssertLazy(fruits.lazy.chunked(by: { $0.first == $1.first }))
-    XCTAssertLazy(fruits.lazy.chunked(on: { $0.first }))
+    XCTAssertLazySequence(fruits.lazy.chunked(by: { $0.first == $1.first }))
+    XCTAssertLazySequence(fruits.lazy.chunked(on: { $0.first }))
   }
 }

Tests/SwiftAlgorithmsTests/CombinationsTests.swift

@@ -40,6 +40,6 @@ final class CombinationsTests: XCTestCase {
   }
 
   func testCombinationsLazy() {
-    XCTAssertLazy("ABC".lazy.combinations(ofCount: 1))
+    XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 1))
   }
 }

Tests/SwiftAlgorithmsTests/CycleTests.swift

@@ -41,6 +41,6 @@ final class CycleTests: XCTestCase {
   }
 
   func testCycleLazy() {
-    XCTAssertLazy((1...4).lazy.cycled())
+    XCTAssertLazySequence((1...4).lazy.cycled())
   }
 }

Tests/SwiftAlgorithmsTests/IndexedTests.swift

@@ -29,6 +29,6 @@ final class IndexedTests: XCTestCase {
   }
 
   func testIndexedLazy() {
-    XCTAssertLazy("ABCD".lazy.indexed())
+    XCTAssertLazyCollection("ABCD".lazy.indexed())
   }
 }

Tests/SwiftAlgorithmsTests/IntersperseTests.swift

@@ -57,4 +57,9 @@ final class IntersperseTests: XCTestCase {
     XCTAssertEqualSequences(reversed, "E-D-C-B-A")
     validateIndexTraversals(reversed)
   }
+
+  func testIntersperseLazy() {
+    XCTAssertLazySequence((1...).prefix(0).lazy.interspersed(with: 0))
+    XCTAssertLazyCollection("ABCDE".lazy.interspersed(with: "-"))
+  }
 }

Tests/SwiftAlgorithmsTests/PermutationsTests.swift

@@ -71,6 +71,6 @@ final class PermutationsTests: XCTestCase {
   }
 
   func testPermutationsLazy() {
-    XCTAssertLazy("ABCD".lazy.permutations(ofCount: 2))
+    XCTAssertLazySequence("ABCD".lazy.permutations(ofCount: 2))
   }
 }

Tests/SwiftAlgorithmsTests/SlidingWindowsTests.swift

@@ -106,4 +106,8 @@ final class SlidingWindowsTests: XCTestCase {
           + [.init(lowerBound: endIndex, upperBound: endIndex)]
       })
   }
+
+  func testWindowsLazy() {
+    XCTAssertLazyCollection([0, 1, 2, 3].lazy.slidingWindows(ofCount: 2))
+  }
 }

Tests/SwiftAlgorithmsTests/TestUtilities.swift

@@ -65,7 +65,8 @@ func XCTAssertEqualSequences<S1: Sequence, S2: Sequence>(
   try XCTAssert(expression1().elementsEqual(expression2(), by: areEquivalent), message(), file: file, line: line)
 }
 
-func XCTAssertLazy<S: LazySequenceProtocol>(_: S) {}
+func XCTAssertLazySequence<S: LazySequenceProtocol>(_: S) {}
+func XCTAssertLazyCollection<S: LazyCollectionProtocol>(_: S) {}
 
 /// Tests that all index traversal methods behave as expected.
 ///