Add conformances to LazySequenceProtocol and LazyCollectionProtocol (#47)

danielctull · web-flow · commit 93c8724c7248 · 2020-12-01T15:47:13.000-06:00
* 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
diff --git a/Guides/Indexed.md b/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.
 
diff --git a/Guides/Intersperse.md b/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
 
diff --git a/Guides/SlidingWindows.md b/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
 
diff --git a/Sources/Algorithms/Indexed.swift b/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 {}
 
diff --git a/Sources/Algorithms/Intersperse.swift b/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
diff --git a/Sources/Algorithms/SlidingWindows.swift b/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 {}
diff --git a/Tests/SwiftAlgorithmsTests/ChunkedTests.swift b/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 }))
   }
 }
diff --git a/Tests/SwiftAlgorithmsTests/CombinationsTests.swift b/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))
   }
 }
diff --git a/Tests/SwiftAlgorithmsTests/CycleTests.swift b/Tests/SwiftAlgorithmsTests/CycleTests.swift
@@ -41,6 +41,6 @@ final class CycleTests: XCTestCase {
   }
   
   func testCycleLazy() {
-    XCTAssertLazy((1...4).lazy.cycled())
+    XCTAssertLazySequence((1...4).lazy.cycled())
   }
 }
diff --git a/Tests/SwiftAlgorithmsTests/IndexedTests.swift b/Tests/SwiftAlgorithmsTests/IndexedTests.swift
@@ -29,6 +29,6 @@ final class IndexedTests: XCTestCase {
   }
   
   func testIndexedLazy() {
-    XCTAssertLazy("ABCD".lazy.indexed())
+    XCTAssertLazyCollection("ABCD".lazy.indexed())
   }
 }
diff --git a/Tests/SwiftAlgorithmsTests/IntersperseTests.swift b/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: "-"))
+  }
 }
diff --git a/Tests/SwiftAlgorithmsTests/PermutationsTests.swift b/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))
   }
 }
diff --git a/Tests/SwiftAlgorithmsTests/SlidingWindowsTests.swift b/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))
+  }
 }
diff --git a/Tests/SwiftAlgorithmsTests/TestUtilities.swift b/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.
 ///

Original file line number	Diff line number	Diff line change
`@@ -299,6 +299,8 @@ extension SlidingWindows: BidirectionalCollection where Base: BidirectionalColle`
`299`	`299`	`}`
`300`	`300`	`}`
`301`	`301`
	`302`	`+extension SlidingWindows: LazySequenceProtocol where Base: LazySequenceProtocol {}`
	`303`	`+extension SlidingWindows: LazyCollectionProtocol where Base: LazyCollectionProtocol {}`
`302`	`304`	`extension SlidingWindows: RandomAccessCollection where Base: RandomAccessCollection {}`
`303`	`305`	`extension SlidingWindows: Equatable where Base: Equatable {}`
`304`	`306`	`extension SlidingWindows: Hashable where Base: Hashable, Base.Index: Hashable {}`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ final class ChunkedTests: XCTestCase {`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`func testChunkedLazy() {`
`76`		`- XCTAssertLazy(fruits.lazy.chunked(by: { $0.first == $1.first }))`
`77`		`- XCTAssertLazy(fruits.lazy.chunked(on: { $0.first }))`
	`76`	`+ XCTAssertLazySequence(fruits.lazy.chunked(by: { $0.first == $1.first }))`
	`77`	`+ XCTAssertLazySequence(fruits.lazy.chunked(on: { $0.first }))`
`78`	`78`	`}`
`79`	`79`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,6 +40,6 @@ final class CombinationsTests: XCTestCase {`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`func testCombinationsLazy() {`
`43`		`- XCTAssertLazy("ABC".lazy.combinations(ofCount: 1))`
	`43`	`+ XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 1))`
`44`	`44`	`}`
`45`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,6 +41,6 @@ final class CycleTests: XCTestCase {`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`func testCycleLazy() {`
`44`		`- XCTAssertLazy((1...4).lazy.cycled())`
	`44`	`+ XCTAssertLazySequence((1...4).lazy.cycled())`
`45`	`45`	`}`
`46`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,6 @@ final class IndexedTests: XCTestCase {`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`func testIndexedLazy() {`
`32`		`- XCTAssertLazy("ABCD".lazy.indexed())`
	`32`	`+ XCTAssertLazyCollection("ABCD".lazy.indexed())`
`33`	`33`	`}`
`34`	`34`	`}`