Rename AsyncLazySequence to AsyncSyncSequence per review feedback (#246)

phausler · web-flow · commit a07a3f41b516 · 2023-01-10T15:36:42.000-08:00
* Rename AsyncLazySequence to AsyncSyncSequence per review feedback

* Rename and number the async proposal
diff --git a/0009-async.md b/0009-async.md
@@ -1,16 +1,16 @@
-# AsyncLazySequence
+# AsyncSyncSequence
 
 * Proposal: [NNNN](NNNN-lazy.md)
 * Authors: [Philippe Hausler](https://github.com/phausler)
 * Status: **Implemented**
 
 * Implementation: 
-  [Source](https://github.com/apple/swift-async-algorithms/blob/main/Sources/AsyncAlgorithms/AsyncLazySequence.swift) | 
+  [Source](https://github.com/apple/swift-async-algorithms/blob/main/Sources/AsyncAlgorithms/AsyncSyncSequence.swift) | 
   [Tests](https://github.com/apple/swift-async-algorithms/blob/main/Tests/AsyncAlgorithmsTests/TestLazy.swift)
   
 ## Introduction
 
-`AsyncLazySequence` converts a non-asynchronous sequence into an asynchronous one. 
+`AsyncSyncSequence` converts a non-asynchronous sequence into an asynchronous one. 
 
 This operation is available for all `Sequence` types. 
 
@@ -22,19 +22,19 @@ let characters = "abcde".async
 This transformation can be useful to test operations specifically available on `AsyncSequence` but also is useful 
 to combine with other `AsyncSequence` types to provide well known sources of data. 
 
-The `.async` property returns an `AsyncLazySequence` that is generic upon the base `Sequence` it was constructed from.
+The `.async` property returns an `AsyncSyncSequence` that is generic upon the base `Sequence` it was constructed from.
 
 ```swift
 extension Sequence {
-  public var async: AsyncLazySequence<Self> { get }
+  public var async: AsyncSyncSequence<Self> { get }
 }
 
-public struct AsyncLazySequence<Base: Sequence>: AsyncSequence {
+public struct AsyncSyncSequence<Base: Sequence>: AsyncSequence {
   ...
 }
 
-extension AsyncLazySequence: Sendable where Base: Sendable { }
-extension AsyncLazySequence.Iterator: Sendable where Base.Iterator: Sendable { }
+extension AsyncSyncSequence: Sendable where Base: Sendable { }
+extension AsyncSyncSequence.Iterator: Sendable where Base.Iterator: Sendable { }
 ```
 
 ### Naming
@@ -45,4 +45,4 @@ succinct name in inspiration from `.lazy`, and the type is named in reference to
 
 ## Effect on API resilience
 
-`AsyncLazySequence` has a trivial implementation and is marked as `@frozen` and `@inlinable`. This removes the ability of this type and functions to be ABI resilient boundaries at the benefit of being highly optimizable.
+`AsyncSyncSequence` has a trivial implementation and is marked as `@frozen` and `@inlinable`. This removes the ability of this type and functions to be ABI resilient boundaries at the benefit of being highly optimizable.
diff --git a/Sources/AsyncAlgorithms/AsyncAlgorithms.docc/Guides/Effects.md b/Sources/AsyncAlgorithms/AsyncAlgorithms.docc/Guides/Effects.md
@@ -34,8 +34,8 @@
 | `AsyncInterspersedSequence.Iterator`                | rethrows     | Not Sendable|
 | `AsyncJoinedSequence`                               | rethrows     | Conditional |
 | `AsyncJoinedSequence.Iterator`                      | rethrows     | Not Sendable|
-| `AsyncLazySequence`                                 | non-throwing | Conditional |
-| `AsyncLazySequence.Iterator`                        | non-throwing | Not Sendable|
+| `AsyncSyncSequence`                                 | non-throwing | Conditional |
+| `AsyncSyncSequence.Iterator`                        | non-throwing | Not Sendable|
 | `AsyncLimitBuffer`                                  | non-throwing | Sendable    |
 | `AsyncMerge2Sequence`                               | rethrows     | Sendable    |
 | `AsyncMerge2Sequence.Iterator`                      | rethrows     | Not Sendable|
diff --git a/Sources/AsyncAlgorithms/AsyncAlgorithms.docc/Guides/Lazy.md b/Sources/AsyncAlgorithms/AsyncAlgorithms.docc/Guides/Lazy.md
@@ -1,6 +1,6 @@
-# AsyncLazySequence
+# AsyncSyncSequence
 
-[[Source](https://github.com/apple/swift-async-algorithms/blob/main/Sources/AsyncAlgorithms/AsyncLazySequence.swift) | 
+[[Source](https://github.com/apple/swift-async-algorithms/blob/main/Sources/AsyncAlgorithms/AsyncSyncSequence.swift) | 
 [Tests](https://github.com/apple/swift-async-algorithms/blob/main/Tests/AsyncAlgorithmsTests/TestLazy.swift)]
 
 Converts a non-asynchronous sequence into an asynchronous one. 
@@ -17,19 +17,19 @@ to combine with other `AsyncSequence` types to provide well known sources of dat
 
 ## Detailed Design
 
-The `.async` property returns an `AsyncLazySequence` that is generic upon the base `Sequence` it was constructed from.
+The `.async` property returns an `AsyncSyncSequence` that is generic upon the base `Sequence` it was constructed from.
 
 ```swift
 extension Sequence {
-  public var async: AsyncLazySequence<Self> { get }
+  public var async: AsyncSyncSequence<Self> { get }
 }
 
-public struct AsyncLazySequence<Base: Sequence>: AsyncSequence {
+public struct AsyncSyncSequence<Base: Sequence>: AsyncSequence {
   ...
 }
 
-extension AsyncLazySequence: Sendable where Base: Sendable { }
-extension AsyncLazySequence.Iterator: Sendable where Base.Iterator: Sendable { }
+extension AsyncSyncSequence: Sendable where Base: Sendable { }
+extension AsyncSyncSequence.Iterator: Sendable where Base.Iterator: Sendable { }
 ```
 
 ### Naming
diff --git a/Sources/AsyncAlgorithms/AsyncChunksOfCountOrSignalSequence.swift b/Sources/AsyncAlgorithms/AsyncChunksOfCountOrSignalSequence.swift
@@ -70,7 +70,7 @@ public struct AsyncChunksOfCountOrSignalSequence<Base: AsyncSequence, Collected:
   public struct Iterator: AsyncIteratorProtocol {
     typealias EitherMappedBase = AsyncMapSequence<Base, Either>
     typealias EitherMappedSignal = AsyncMapSequence<Signal, Either>
-    typealias ChainedBase = AsyncChain2Sequence<EitherMappedBase, AsyncLazySequence<[Either]>>
+    typealias ChainedBase = AsyncChain2Sequence<EitherMappedBase, AsyncSyncSequence<[Either]>>
     typealias Merged = AsyncMerge2Sequence<ChainedBase, EitherMappedSignal>
     
     let count: Int?
diff --git a/Sources/AsyncAlgorithms/AsyncSyncSequence.swift b/Sources/AsyncAlgorithms/AsyncSyncSequence.swift
@@ -14,8 +14,8 @@ extension Sequence {
   /// but on which operations, such as `map` and `filter`, are
   /// implemented asynchronously.
   @inlinable
-  public var async: AsyncLazySequence<Self> {
-    AsyncLazySequence(self)
+  public var async: AsyncSyncSequence<Self> {
+    AsyncSyncSequence(self)
   }
 }
 
@@ -28,7 +28,7 @@ extension Sequence {
 /// This functions similarly to `LazySequence` by accessing elements sequentially
 /// in the iterator's `next()` method.
 @frozen
-public struct AsyncLazySequence<Base: Sequence>: AsyncSequence {
+public struct AsyncSyncSequence<Base: Sequence>: AsyncSequence {
   public typealias Element = Base.Element
   
   @frozen
@@ -66,4 +66,4 @@ public struct AsyncLazySequence<Base: Sequence>: AsyncSequence {
   }
 }
 
-extension AsyncLazySequence: Sendable where Base: Sendable { }
+extension AsyncSyncSequence: Sendable where Base: Sendable { }
diff --git a/Tests/AsyncAlgorithmsTests/TestJoin.swift b/Tests/AsyncAlgorithmsTests/TestJoin.swift
@@ -13,16 +13,16 @@ import XCTest
 import AsyncAlgorithms
 
 extension Sequence where Element: Sequence, Element.Element: Equatable & Sendable {
-  func nestedAsync(throwsOn bad: Element.Element) -> AsyncLazySequence<[AsyncThrowingMapSequence<AsyncLazySequence<Element>,Element.Element>]> {
-    let array: [AsyncThrowingMapSequence<AsyncLazySequence<Element>,Element.Element>] = self.map { $0.async }.map {
+  func nestedAsync(throwsOn bad: Element.Element) -> AsyncSyncSequence<[AsyncThrowingMapSequence<AsyncSyncSequence<Element>,Element.Element>]> {
+    let array: [AsyncThrowingMapSequence<AsyncSyncSequence<Element>,Element.Element>] = self.map { $0.async }.map {
       $0.map { try throwOn(bad, $0) }
     }
     return array.async
   }
 }
 
 extension Sequence where Element: Sequence, Element.Element: Sendable {
-  var nestedAsync : AsyncLazySequence<[AsyncLazySequence<Element>]> {
+  var nestedAsync : AsyncSyncSequence<[AsyncSyncSequence<Element>]> {
     return self.map { $0.async }.async
   }
 }
@@ -55,7 +55,7 @@ final class TestJoinedBySeparator: XCTestCase {
   }
 
   func test_join_empty() async {
-    let sequences = [AsyncLazySequence<[Int]>]().async
+    let sequences = [AsyncSyncSequence<[Int]>]().async
     var iterator = sequences.joined(separator: [-1, -2, -3].async).makeAsyncIterator()
     let expected = [Int]()
     var actual = [Int]()
@@ -105,7 +105,7 @@ final class TestJoinedBySeparator: XCTestCase {
   }
 
   func test_cancellation() async {
-    let source : AsyncLazySequence<[AsyncLazySequence<Indefinite<String>>]> = [Indefinite(value: "test").async].async
+    let source : AsyncSyncSequence<[AsyncSyncSequence<Indefinite<String>>]> = [Indefinite(value: "test").async].async
     let sequence = source.joined(separator: ["past indefinite"].async)
     let finished = expectation(description: "finished")
     let iterated = expectation(description: "iterated")
@@ -158,7 +158,7 @@ final class TestJoined: XCTestCase {
   }
 
   func test_join_empty() async {
-    let sequences = [AsyncLazySequence<[Int]>]().async
+    let sequences = [AsyncSyncSequence<[Int]>]().async
     var iterator = sequences.joined().makeAsyncIterator()
     let expected = [Int]()
     var actual = [Int]()
@@ -189,7 +189,7 @@ final class TestJoined: XCTestCase {
   }
 
   func test_cancellation() async {
-    let source : AsyncLazySequence<[AsyncLazySequence<Indefinite<String>>]> = [Indefinite(value: "test").async].async
+    let source : AsyncSyncSequence<[AsyncSyncSequence<Indefinite<String>>]> = [Indefinite(value: "test").async].async
     let sequence = source.joined()
     let finished = expectation(description: "finished")
     let iterated = expectation(description: "iterated")

Original file line number	Diff line number	Diff line change
`@@ -14,8 +14,8 @@ extension Sequence {`
`14`	`14`	/// but on which operations, such as `map` and `filter`, are
`15`	`15`	`/// implemented asynchronously.`
`16`	`16`	`@inlinable`
`17`		`- public var async: AsyncLazySequence<Self> {`
`18`		`- AsyncLazySequence(self)`
	`17`	`+ public var async: AsyncSyncSequence<Self> {`
	`18`	`+ AsyncSyncSequence(self)`
`19`	`19`	`}`
`20`	`20`	`}`
`21`	`21`
`@@ -28,7 +28,7 @@ extension Sequence {`
`28`	`28`	/// This functions similarly to `LazySequence` by accessing elements sequentially
`29`	`29`	/// in the iterator's `next()` method.
`30`	`30`	`@frozen`
`31`		`-public struct AsyncLazySequence<Base: Sequence>: AsyncSequence {`
	`31`	`+public struct AsyncSyncSequence<Base: Sequence>: AsyncSequence {`
`32`	`32`	`public typealias Element = Base.Element`
`33`	`33`
`34`	`34`	`@frozen`
`@@ -66,4 +66,4 @@ public struct AsyncLazySequence<Base: Sequence>: AsyncSequence {`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`
`69`		`-extension AsyncLazySequence: Sendable where Base: Sendable { }`
	`69`	`+extension AsyncSyncSequence: Sendable where Base: Sendable { }`
Original file line number	Diff line number	Diff line change
`@@ -13,16 +13,16 @@ import XCTest`
`13`	`13`	`import AsyncAlgorithms`
`14`	`14`
`15`	`15`	`extension Sequence where Element: Sequence, Element.Element: Equatable & Sendable {`
`16`		`- func nestedAsync(throwsOn bad: Element.Element) -> AsyncLazySequence<[AsyncThrowingMapSequence<AsyncLazySequence<Element>,Element.Element>]> {`
`17`		`- let array: [AsyncThrowingMapSequence<AsyncLazySequence<Element>,Element.Element>] = self.map { $0.async }.map {`
	`16`	`+ func nestedAsync(throwsOn bad: Element.Element) -> AsyncSyncSequence<[AsyncThrowingMapSequence<AsyncSyncSequence<Element>,Element.Element>]> {`
	`17`	`+ let array: [AsyncThrowingMapSequence<AsyncSyncSequence<Element>,Element.Element>] = self.map { $0.async }.map {`
`18`	`18`	`$0.map { try throwOn(bad, $0) }`
`19`	`19`	`}`
`20`	`20`	`return array.async`
`21`	`21`	`}`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`extension Sequence where Element: Sequence, Element.Element: Sendable {`
`25`		`- var nestedAsync : AsyncLazySequence<[AsyncLazySequence<Element>]> {`
	`25`	`+ var nestedAsync : AsyncSyncSequence<[AsyncSyncSequence<Element>]> {`
`26`	`26`	`return self.map { $0.async }.async`
`27`	`27`	`}`
`28`	`28`	`}`
`@@ -55,7 +55,7 @@ final class TestJoinedBySeparator: XCTestCase {`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`func test_join_empty() async {`
`58`		`- let sequences = [AsyncLazySequence<[Int]>]().async`
	`58`	`+ let sequences = [AsyncSyncSequence<[Int]>]().async`
`59`	`59`	`var iterator = sequences.joined(separator: [-1, -2, -3].async).makeAsyncIterator()`
`60`	`60`	`let expected = [Int]()`
`61`	`61`	`var actual = [Int]()`
`@@ -105,7 +105,7 @@ final class TestJoinedBySeparator: XCTestCase {`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`func test_cancellation() async {`
`108`		`- let source : AsyncLazySequence<[AsyncLazySequence<Indefinite<String>>]> = [Indefinite(value: "test").async].async`
	`108`	`+ let source : AsyncSyncSequence<[AsyncSyncSequence<Indefinite<String>>]> = [Indefinite(value: "test").async].async`
`109`	`109`	`let sequence = source.joined(separator: ["past indefinite"].async)`
`110`	`110`	`let finished = expectation(description: "finished")`
`111`	`111`	`let iterated = expectation(description: "iterated")`
`@@ -158,7 +158,7 @@ final class TestJoined: XCTestCase {`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`func test_join_empty() async {`
`161`		`- let sequences = [AsyncLazySequence<[Int]>]().async`
	`161`	`+ let sequences = [AsyncSyncSequence<[Int]>]().async`
`162`	`162`	`var iterator = sequences.joined().makeAsyncIterator()`
`163`	`163`	`let expected = [Int]()`
`164`	`164`	`var actual = [Int]()`
`@@ -189,7 +189,7 @@ final class TestJoined: XCTestCase {`
`189`	`189`	`}`
`190`	`190`
`191`	`191`	`func test_cancellation() async {`
`192`		`- let source : AsyncLazySequence<[AsyncLazySequence<Indefinite<String>>]> = [Indefinite(value: "test").async].async`
	`192`	`+ let source : AsyncSyncSequence<[AsyncSyncSequence<Indefinite<String>>]> = [Indefinite(value: "test").async].async`
`193`	`193`	`let sequence = source.joined()`
`194`	`194`	`let finished = expectation(description: "finished")`
`195`	`195`	`let iterated = expectation(description: "iterated")`