Unify naming of chunks a bit more (apple#74)

phausler · web-flow · commit f0f348a680ab · 2022-03-14T11:47:07.000-07:00
diff --git a/Sources/AsyncAlgorithms/AsyncChunkedByGroupSequence.swift b/Sources/AsyncAlgorithms/AsyncChunkedByGroupSequence.swift
@@ -10,17 +10,15 @@
 //===----------------------------------------------------------------------===//
 
 extension AsyncSequence {
-
   @inlinable
-  public func chunked<Collected: RangeReplaceableCollection>(by belongInSameGroup: @escaping @Sendable (Element, Element) -> Bool, into: Collected.Type) -> AsyncChunkedByGroupSequence<Self, Collected> where Collected.Element == Element {
+  public func chunked<Collected: RangeReplaceableCollection>(into: Collected.Type, by belongInSameGroup: @escaping @Sendable (Element, Element) -> Bool) -> AsyncChunkedByGroupSequence<Self, Collected> where Collected.Element == Element {
     AsyncChunkedByGroupSequence(self, grouping: belongInSameGroup)
   }
 
   @inlinable
   public func chunked(by belongInSameGroup: @escaping @Sendable (Element, Element) -> Bool) -> AsyncChunkedByGroupSequence<Self, [Element]> {
-    chunked(by: belongInSameGroup, into: [Element].self)
+    chunked(into: [Element].self, by: belongInSameGroup)
   }
-
 }
 
 public struct AsyncChunkedByGroupSequence<Base: AsyncSequence, Collected: RangeReplaceableCollection>: AsyncSequence where Collected.Element == Base.Element {
diff --git a/Sources/AsyncAlgorithms/AsyncChunkedOnProjectionSequence.swift b/Sources/AsyncAlgorithms/AsyncChunkedOnProjectionSequence.swift
@@ -10,17 +10,15 @@
 //===----------------------------------------------------------------------===//
 
 extension AsyncSequence {
-
   @inlinable
-  public func chunked<Subject : Equatable, Collected: RangeReplaceableCollection>(on projection: @escaping @Sendable (Element) -> Subject, into: Collected.Type) -> AsyncChunkedOnProjectionSequence<Self, Subject, Collected> {
+  public func chunked<Subject : Equatable, Collected: RangeReplaceableCollection>(into: Collected.Type, on projection: @escaping @Sendable (Element) -> Subject) -> AsyncChunkedOnProjectionSequence<Self, Subject, Collected> {
     AsyncChunkedOnProjectionSequence(self, projection: projection)
   }
 
   @inlinable
   public func chunked<Subject : Equatable>(on projection: @escaping @Sendable (Element) -> Subject) -> AsyncChunkedOnProjectionSequence<Self, Subject, [Element]> {
-    chunked(on: projection, into: [Element].self)
+    chunked(into: [Element].self, on: projection)
   }
-
 }
 
 public struct AsyncChunkedOnProjectionSequence<Base: AsyncSequence, Subject: Equatable, Collected: RangeReplaceableCollection>: AsyncSequence where Collected.Element == Base.Element {
diff --git a/Sources/AsyncAlgorithms/AsyncChunksOfCountOrSignalSequence.swift b/Sources/AsyncAlgorithms/AsyncChunksOfCountOrSignalSequence.swift
@@ -10,42 +10,40 @@
 //===----------------------------------------------------------------------===//
 
 extension AsyncSequence {
-
-  public func chunks<Signal, Collected: RangeReplaceableCollection>(ofCount count: Int, or signal: Signal, into: Collected.Type) -> AsyncChunksOfCountAndSignalSequence<Self, Collected, Signal> where Collected.Element == Element {
-    AsyncChunksOfCountAndSignalSequence(self, count: count, signal: signal)
+  public func chunks<Signal, Collected: RangeReplaceableCollection>(ofCount count: Int, or signal: Signal, into: Collected.Type) -> AsyncChunksOfCountOrSignalSequence<Self, Collected, Signal> where Collected.Element == Element {
+    AsyncChunksOfCountOrSignalSequence(self, count: count, signal: signal)
   }
 
-  public func chunks<Signal>(ofCount count: Int, or signal: Signal) -> AsyncChunksOfCountAndSignalSequence<Self, [Element], Signal> {
+  public func chunks<Signal>(ofCount count: Int, or signal: Signal) -> AsyncChunksOfCountOrSignalSequence<Self, [Element], Signal> {
     chunks(ofCount: count, or: signal, into: [Element].self)
   }
 
-  public func chunked<Signal, Collected: RangeReplaceableCollection>(by signal: Signal, into: Collected.Type) -> AsyncChunksOfCountAndSignalSequence<Self, Collected, Signal> where Collected.Element == Element {
-    AsyncChunksOfCountAndSignalSequence(self, count: nil, signal: signal)
+  public func chunked<Signal, Collected: RangeReplaceableCollection>(by signal: Signal, into: Collected.Type) -> AsyncChunksOfCountOrSignalSequence<Self, Collected, Signal> where Collected.Element == Element {
+    AsyncChunksOfCountOrSignalSequence(self, count: nil, signal: signal)
   }
 
-  public func chunked<Signal>(bySignal signal: Signal) -> AsyncChunksOfCountAndSignalSequence<Self, [Element], Signal> {
+  public func chunked<Signal>(by signal: Signal) -> AsyncChunksOfCountOrSignalSequence<Self, [Element], Signal> {
     chunked(by: signal, into: [Element].self)
   }
 
-  public func chunks<C: Clock, Collected: RangeReplaceableCollection>(ofCount count: Int, or timer: AsyncTimerSequence<C>, into: Collected.Type) -> AsyncChunksOfCountAndSignalSequence<Self, Collected, AsyncTimerSequence<C>> where Collected.Element == Element {
-    AsyncChunksOfCountAndSignalSequence(self, count: count, signal: timer)
+  public func chunks<C: Clock, Collected: RangeReplaceableCollection>(ofCount count: Int, or timer: AsyncTimerSequence<C>, into: Collected.Type) -> AsyncChunksOfCountOrSignalSequence<Self, Collected, AsyncTimerSequence<C>> where Collected.Element == Element {
+    AsyncChunksOfCountOrSignalSequence(self, count: count, signal: timer)
   }
 
-  public func chunks<C: Clock>(ofCount count: Int, or timer: AsyncTimerSequence<C>) -> AsyncChunksOfCountAndSignalSequence<Self, [Element], AsyncTimerSequence<C>> {
+  public func chunks<C: Clock>(ofCount count: Int, or timer: AsyncTimerSequence<C>) -> AsyncChunksOfCountOrSignalSequence<Self, [Element], AsyncTimerSequence<C>> {
     chunks(ofCount: count, or: timer, into: [Element].self)
   }
 
-  public func chunked<C: Clock, Collected: RangeReplaceableCollection>(by timer: AsyncTimerSequence<C>, into: Collected.Type) -> AsyncChunksOfCountAndSignalSequence<Self, Collected, AsyncTimerSequence<C>> where Collected.Element == Element {
-    AsyncChunksOfCountAndSignalSequence(self, count: nil, signal: timer)
+  public func chunked<C: Clock, Collected: RangeReplaceableCollection>(by timer: AsyncTimerSequence<C>, into: Collected.Type) -> AsyncChunksOfCountOrSignalSequence<Self, Collected, AsyncTimerSequence<C>> where Collected.Element == Element {
+    AsyncChunksOfCountOrSignalSequence(self, count: nil, signal: timer)
   }
 
-  public func chunked<C: Clock>(by timer: AsyncTimerSequence<C>) -> AsyncChunksOfCountAndSignalSequence<Self, [Element], AsyncTimerSequence<C>> {
+  public func chunked<C: Clock>(by timer: AsyncTimerSequence<C>) -> AsyncChunksOfCountOrSignalSequence<Self, [Element], AsyncTimerSequence<C>> {
     chunked(by: timer, into: [Element].self)
   }
-
 }
 
-public struct AsyncChunksOfCountAndSignalSequence<Base: AsyncSequence, Collected: RangeReplaceableCollection, Signal: AsyncSequence>: AsyncSequence, Sendable where Collected.Element == Base.Element, Base: Sendable, Signal: Sendable, Base.AsyncIterator: Sendable, Signal.AsyncIterator: Sendable, Base.Element: Sendable, Signal.Element: Sendable {
+public struct AsyncChunksOfCountOrSignalSequence<Base: AsyncSequence, Collected: RangeReplaceableCollection, Signal: AsyncSequence>: AsyncSequence, Sendable where Collected.Element == Base.Element, Base: Sendable, Signal: Sendable, Base.AsyncIterator: Sendable, Signal.AsyncIterator: Sendable, Base.Element: Sendable, Signal.Element: Sendable {
 
   public typealias Element = Collected
 
diff --git a/Sources/AsyncAlgorithms/AsyncChunksOfCountSequence.swift b/Sources/AsyncAlgorithms/AsyncChunksOfCountSequence.swift
@@ -10,7 +10,6 @@
 //===----------------------------------------------------------------------===//
 
 extension AsyncSequence {
-
   @inlinable
   public func chunks<Collected: RangeReplaceableCollection>(ofCount count: Int, into: Collected.Type) -> AsyncChunksOfCountSequence<Self, Collected> where Collected.Element == Element {
     AsyncChunksOfCountSequence(self, count: count)
@@ -20,7 +19,6 @@ extension AsyncSequence {
   public func chunks(ofCount count: Int) -> AsyncChunksOfCountSequence<Self, [Element]> {
     chunks(ofCount: count, into: [Element].self)
   }
-
 }
 
 public struct AsyncChunksOfCountSequence<Base: AsyncSequence, Collected: RangeReplaceableCollection>: AsyncSequence where Collected.Element == Base.Element {
diff --git a/Tests/AsyncAlgorithmsTests/TestChunk.swift b/Tests/AsyncAlgorithmsTests/TestChunk.swift
@@ -27,7 +27,7 @@ final class TestChunk: XCTestCase {
     validate {
       "ABC-    DEF-    GHI-     |"
       "---X    ---X    ---X    |"
-      $0.inputs[0].chunked(bySignal: $0.inputs[1]).map(concatCharacters)
+      $0.inputs[0].chunked(by: $0.inputs[1]).map(concatCharacters)
       "---'ABC'---'DEF'---'GHI'|"
     }
   }
@@ -36,7 +36,7 @@ final class TestChunk: XCTestCase {
     validate {
       "AB-   A-ABCDEFGH-         |"
       "--X   -X--------X         |"
-      $0.inputs[0].chunked(bySignal: $0.inputs[1]).map(concatCharacters)
+      $0.inputs[0].chunked(by: $0.inputs[1]).map(concatCharacters)
       "--'AB'-A--------'ABCDEFGH'|"
     }
   }
@@ -45,7 +45,7 @@ final class TestChunk: XCTestCase {
     validate {
       "--1--|"
       "XX-XX|"
-      $0.inputs[0].chunked(bySignal: $0.inputs[1]).map(concatCharacters)
+      $0.inputs[0].chunked(by: $0.inputs[1]).map(concatCharacters)
       "---1-|"
     }
   }
@@ -54,7 +54,7 @@ final class TestChunk: XCTestCase {
     validate {
       "AB^"
       "---X|"
-      $0.inputs[0].chunked(bySignal: $0.inputs[1]).map(concatCharacters)
+      $0.inputs[0].chunked(by: $0.inputs[1]).map(concatCharacters)
       "--^"
     }
   }
@@ -63,7 +63,7 @@ final class TestChunk: XCTestCase {
     validate {
       "111-111|"
       "---X---|"
-      $0.inputs[0].chunked(bySignal: $0.inputs[1]).map(sumCharacters)
+      $0.inputs[0].chunked(by: $0.inputs[1]).map(sumCharacters)
       "---3---[3|]"
     }
   }

Original file line number	Diff line number	Diff line change
`@@ -10,17 +10,15 @@`
`10`	`10`	`//===----------------------------------------------------------------------===//`
`11`	`11`
`12`	`12`	`extension AsyncSequence {`
`13`		`-`
`14`	`13`	`@inlinable`
`15`		`- public func chunked<Collected: RangeReplaceableCollection>(by belongInSameGroup: @escaping @Sendable (Element, Element) -> Bool, into: Collected.Type) -> AsyncChunkedByGroupSequence<Self, Collected> where Collected.Element == Element {`
	`14`	`+ public func chunked<Collected: RangeReplaceableCollection>(into: Collected.Type, by belongInSameGroup: @escaping @Sendable (Element, Element) -> Bool) -> AsyncChunkedByGroupSequence<Self, Collected> where Collected.Element == Element {`
`16`	`15`	`AsyncChunkedByGroupSequence(self, grouping: belongInSameGroup)`
`17`	`16`	`}`
`18`	`17`
`19`	`18`	`@inlinable`
`20`	`19`	`public func chunked(by belongInSameGroup: @escaping @Sendable (Element, Element) -> Bool) -> AsyncChunkedByGroupSequence<Self, [Element]> {`
`21`		`- chunked(by: belongInSameGroup, into: [Element].self)`
	`20`	`+ chunked(into: [Element].self, by: belongInSameGroup)`
`22`	`21`	`}`
`23`		`-`
`24`	`22`	`}`
`25`	`23`
`26`	`24`	`public struct AsyncChunkedByGroupSequence<Base: AsyncSequence, Collected: RangeReplaceableCollection>: AsyncSequence where Collected.Element == Base.Element {`
Original file line number	Diff line number	Diff line change
`@@ -10,42 +10,40 @@`
`10`	`10`	`//===----------------------------------------------------------------------===//`
`11`	`11`
`12`	`12`	`extension AsyncSequence {`
`13`		`-`
`14`		`- public func chunks<Signal, Collected: RangeReplaceableCollection>(ofCount count: Int, or signal: Signal, into: Collected.Type) -> AsyncChunksOfCountAndSignalSequence<Self, Collected, Signal> where Collected.Element == Element {`
`15`		`- AsyncChunksOfCountAndSignalSequence(self, count: count, signal: signal)`
	`13`	`+ public func chunks<Signal, Collected: RangeReplaceableCollection>(ofCount count: Int, or signal: Signal, into: Collected.Type) -> AsyncChunksOfCountOrSignalSequence<Self, Collected, Signal> where Collected.Element == Element {`
	`14`	`+ AsyncChunksOfCountOrSignalSequence(self, count: count, signal: signal)`
`16`	`15`	`}`
`17`	`16`
`18`		`- public func chunks<Signal>(ofCount count: Int, or signal: Signal) -> AsyncChunksOfCountAndSignalSequence<Self, [Element], Signal> {`
	`17`	`+ public func chunks<Signal>(ofCount count: Int, or signal: Signal) -> AsyncChunksOfCountOrSignalSequence<Self, [Element], Signal> {`
`19`	`18`	`chunks(ofCount: count, or: signal, into: [Element].self)`
`20`	`19`	`}`
`21`	`20`
`22`		`- public func chunked<Signal, Collected: RangeReplaceableCollection>(by signal: Signal, into: Collected.Type) -> AsyncChunksOfCountAndSignalSequence<Self, Collected, Signal> where Collected.Element == Element {`
`23`		`- AsyncChunksOfCountAndSignalSequence(self, count: nil, signal: signal)`
	`21`	`+ public func chunked<Signal, Collected: RangeReplaceableCollection>(by signal: Signal, into: Collected.Type) -> AsyncChunksOfCountOrSignalSequence<Self, Collected, Signal> where Collected.Element == Element {`
	`22`	`+ AsyncChunksOfCountOrSignalSequence(self, count: nil, signal: signal)`
`24`	`23`	`}`
`25`	`24`
`26`		`- public func chunked<Signal>(bySignal signal: Signal) -> AsyncChunksOfCountAndSignalSequence<Self, [Element], Signal> {`
	`25`	`+ public func chunked<Signal>(by signal: Signal) -> AsyncChunksOfCountOrSignalSequence<Self, [Element], Signal> {`
`27`	`26`	`chunked(by: signal, into: [Element].self)`
`28`	`27`	`}`
`29`	`28`
`30`		`- public func chunks<C: Clock, Collected: RangeReplaceableCollection>(ofCount count: Int, or timer: AsyncTimerSequence<C>, into: Collected.Type) -> AsyncChunksOfCountAndSignalSequence<Self, Collected, AsyncTimerSequence<C>> where Collected.Element == Element {`
`31`		`- AsyncChunksOfCountAndSignalSequence(self, count: count, signal: timer)`
	`29`	`+ public func chunks<C: Clock, Collected: RangeReplaceableCollection>(ofCount count: Int, or timer: AsyncTimerSequence<C>, into: Collected.Type) -> AsyncChunksOfCountOrSignalSequence<Self, Collected, AsyncTimerSequence<C>> where Collected.Element == Element {`
	`30`	`+ AsyncChunksOfCountOrSignalSequence(self, count: count, signal: timer)`
`32`	`31`	`}`
`33`	`32`
`34`		`- public func chunks<C: Clock>(ofCount count: Int, or timer: AsyncTimerSequence<C>) -> AsyncChunksOfCountAndSignalSequence<Self, [Element], AsyncTimerSequence<C>> {`
	`33`	`+ public func chunks<C: Clock>(ofCount count: Int, or timer: AsyncTimerSequence<C>) -> AsyncChunksOfCountOrSignalSequence<Self, [Element], AsyncTimerSequence<C>> {`
`35`	`34`	`chunks(ofCount: count, or: timer, into: [Element].self)`
`36`	`35`	`}`
`37`	`36`
`38`		`- public func chunked<C: Clock, Collected: RangeReplaceableCollection>(by timer: AsyncTimerSequence<C>, into: Collected.Type) -> AsyncChunksOfCountAndSignalSequence<Self, Collected, AsyncTimerSequence<C>> where Collected.Element == Element {`
`39`		`- AsyncChunksOfCountAndSignalSequence(self, count: nil, signal: timer)`
	`37`	`+ public func chunked<C: Clock, Collected: RangeReplaceableCollection>(by timer: AsyncTimerSequence<C>, into: Collected.Type) -> AsyncChunksOfCountOrSignalSequence<Self, Collected, AsyncTimerSequence<C>> where Collected.Element == Element {`
	`38`	`+ AsyncChunksOfCountOrSignalSequence(self, count: nil, signal: timer)`
`40`	`39`	`}`
`41`	`40`
`42`		`- public func chunked<C: Clock>(by timer: AsyncTimerSequence<C>) -> AsyncChunksOfCountAndSignalSequence<Self, [Element], AsyncTimerSequence<C>> {`
	`41`	`+ public func chunked<C: Clock>(by timer: AsyncTimerSequence<C>) -> AsyncChunksOfCountOrSignalSequence<Self, [Element], AsyncTimerSequence<C>> {`
`43`	`42`	`chunked(by: timer, into: [Element].self)`
`44`	`43`	`}`
`45`		`-`
`46`	`44`	`}`
`47`	`45`
`48`		`-public struct AsyncChunksOfCountAndSignalSequence<Base: AsyncSequence, Collected: RangeReplaceableCollection, Signal: AsyncSequence>: AsyncSequence, Sendable where Collected.Element == Base.Element, Base: Sendable, Signal: Sendable, Base.AsyncIterator: Sendable, Signal.AsyncIterator: Sendable, Base.Element: Sendable, Signal.Element: Sendable {`
	`46`	`+public struct AsyncChunksOfCountOrSignalSequence<Base: AsyncSequence, Collected: RangeReplaceableCollection, Signal: AsyncSequence>: AsyncSequence, Sendable where Collected.Element == Base.Element, Base: Sendable, Signal: Sendable, Base.AsyncIterator: Sendable, Signal.AsyncIterator: Sendable, Base.Element: Sendable, Signal.Element: Sendable {`
`49`	`47`
`50`	`48`	`public typealias Element = Collected`
`51`	`49`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,6 @@`
`10`	`10`	`//===----------------------------------------------------------------------===//`
`11`	`11`
`12`	`12`	`extension AsyncSequence {`
`13`		`-`
`14`	`13`	`@inlinable`
`15`	`14`	`public func chunks<Collected: RangeReplaceableCollection>(ofCount count: Int, into: Collected.Type) -> AsyncChunksOfCountSequence<Self, Collected> where Collected.Element == Element {`
`16`	`15`	`AsyncChunksOfCountSequence(self, count: count)`
`@@ -20,7 +19,6 @@ extension AsyncSequence {`
`20`	`19`	`public func chunks(ofCount count: Int) -> AsyncChunksOfCountSequence<Self, [Element]> {`
`21`	`20`	`chunks(ofCount: count, into: [Element].self)`
`22`	`21`	`}`
`23`		`-`
`24`	`22`	`}`
`25`	`23`
`26`	`24`	`public struct AsyncChunksOfCountSequence<Base: AsyncSequence, Collected: RangeReplaceableCollection>: AsyncSequence where Collected.Element == Base.Element {`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ final class TestChunk: XCTestCase {`
`27`	`27`	`validate {`
`28`	`28`	`"ABC- DEF- GHI- \|"`
`29`	`29`	`"---X ---X ---X \|"`
`30`		`- $0.inputs[0].chunked(bySignal: $0.inputs[1]).map(concatCharacters)`
	`30`	`+ $0.inputs[0].chunked(by: $0.inputs[1]).map(concatCharacters)`
`31`	`31`	`"---'ABC'---'DEF'---'GHI'\|"`
`32`	`32`	`}`
`33`	`33`	`}`
`@@ -36,7 +36,7 @@ final class TestChunk: XCTestCase {`
`36`	`36`	`validate {`
`37`	`37`	`"AB- A-ABCDEFGH- \|"`
`38`	`38`	`"--X -X--------X \|"`
`39`		`- $0.inputs[0].chunked(bySignal: $0.inputs[1]).map(concatCharacters)`
	`39`	`+ $0.inputs[0].chunked(by: $0.inputs[1]).map(concatCharacters)`
`40`	`40`	`"--'AB'-A--------'ABCDEFGH'\|"`
`41`	`41`	`}`
`42`	`42`	`}`
`@@ -45,7 +45,7 @@ final class TestChunk: XCTestCase {`
`45`	`45`	`validate {`
`46`	`46`	`"--1--\|"`
`47`	`47`	`"XX-XX\|"`
`48`		`- $0.inputs[0].chunked(bySignal: $0.inputs[1]).map(concatCharacters)`
	`48`	`+ $0.inputs[0].chunked(by: $0.inputs[1]).map(concatCharacters)`
`49`	`49`	`"---1-\|"`
`50`	`50`	`}`
`51`	`51`	`}`
`@@ -54,7 +54,7 @@ final class TestChunk: XCTestCase {`
`54`	`54`	`validate {`
`55`	`55`	`"AB^"`
`56`	`56`	`"---X\|"`
`57`		`- $0.inputs[0].chunked(bySignal: $0.inputs[1]).map(concatCharacters)`
	`57`	`+ $0.inputs[0].chunked(by: $0.inputs[1]).map(concatCharacters)`
`58`	`58`	`"--^"`
`59`	`59`	`}`
`60`	`60`	`}`
`@@ -63,7 +63,7 @@ final class TestChunk: XCTestCase {`
`63`	`63`	`validate {`
`64`	`64`	`"111-111\|"`
`65`	`65`	`"---X---\|"`
`66`		`- $0.inputs[0].chunked(bySignal: $0.inputs[1]).map(sumCharacters)`
	`66`	`+ $0.inputs[0].chunked(by: $0.inputs[1]).map(sumCharacters)`
`67`	`67`	`"---3---[3\|]"`
`68`	`68`	`}`
`69`	`69`	`}`