Rename to chunks(ofCount:)

Author: LucianoPAlmeida

Guides/Chunked.md

@@ -6,7 +6,7 @@
 Break a collection into subsequences where consecutive elements pass a binary
 predicate, or where all elements in each chunk project to the same value. 
 
-Also, includes a `chunks(of size:)` that breaks a collection into subsequences 
+Also, includes a `chunks(ofCount:)` that breaks a collection into subsequences 
 of a given size.
 
 There are two variations of the `chunked` method: `chunked(by:)` and
@@ -29,21 +29,21 @@ let chunks = names.chunked(on: \.first!)
 // [["David"], ["Kyle", "Karoy"], ["Nate"]] 
 ```
 
-The `chunks(of:)` takes a `size` parameter (required to be > 0) and separates 
+The `chunks(ofCount:)` takes a `size` parameter (required to be > 0) and separates 
 the collection into `n` chunks of this given size. If the size parameter is 
 evenly divided by the count of the base `Collection` all the chunks will have 
 the count equals to size. Otherwise, the last chunk will contain the remaining elements.
 
 ```swift
 let names = ["David", "Kyle", "Karoy", "Nate"]
-let evenly = names.chunks(of: 2)
+let evenly = names.chunks(ofCount: 2)
 // [["David", "Kyle"], ["Karoy", "Nate"]] 
 
-let remaining = names.chunks(of: 3)
+let remaining = names.chunks(ofCount: 3)
 // [["David", "Kyle", "Karoy"], "Nate"]] 
 ```
 
-The `chunks(of:)` is the method of the [existing SE proposal][proposal]. 
+The `chunks(ofCount:)` is the method of the [existing SE proposal][proposal]. 
 Unlike the `split` family of methods, the entire collection is included in the
 chunked result — joining the resulting chunks recreates the original collection. 
 

Sources/Algorithms/Chunked.swift

@@ -266,16 +266,16 @@ public struct ChunkedCollection<Base: Collection> {
 
   public let base: Base
   @usableFromInline
-  internal let _size: Int
+  internal let _chunkCount: Int
 
   ///  Creates a view instance that presents the elements of `base`
   ///  in `SubSequence` chunks of the given size.
   ///
   /// - Complexity: O(1)
   @inlinable
-  internal init(_base: Base, _size: Int) {
+  internal init(_base: Base, _chunkCount: Int) {
     self.base = _base
-    self._size = _size
+    self._chunkCount = _chunkCount
   }
 }
 
@@ -299,7 +299,7 @@ extension ChunkedCollection: Collection {
   @inlinable
   public func index(after i: Index) -> Index {
     let baseIdx = base.index(
-      i.base, offsetBy: _size, limitedBy: base.endIndex)
+      i.base, offsetBy: _chunkCount, limitedBy: base.endIndex)
     return Index(_base: baseIdx ?? base.endIndex)
   }
 }
@@ -318,19 +318,19 @@ where Base: RandomAccessCollection {
   @inlinable
   public func index(before i: Index) -> Index {
     if i.base == base.endIndex {
-      let remainder = base.count%_size
+      let remainder = base.count%_chunkCount
       if remainder != 0 {
         return Index(_base: base.index(i.base, offsetBy: -remainder))
       }
     }
-    return Index(_base: base.index(i.base, offsetBy: -_size))
+    return Index(_base: base.index(i.base, offsetBy: -_chunkCount))
   }
 
   @inlinable
   public func distance(from start: Index, to end: Index) -> Int {
     let distance = base.distance(from: start.base, to: end.base)
     let (quotient, remainder) =
-      distance.quotientAndRemainder(dividingBy: _size)
+      distance.quotientAndRemainder(dividingBy: _chunkCount)
     return quotient + remainder
   }
 
@@ -340,14 +340,15 @@ where Base: RandomAccessCollection {
 
     let bound = n > 0 ? base.endIndex : base.startIndex
     return Index(_base:
-      base.index(i.base, offsetBy: n * _size, limitedBy: bound) ?? bound
+      base.index(i.base, offsetBy: n * _chunkCount, limitedBy: bound) ?? bound
     )
   }
 
   @inlinable
   public var count: Int {
-    return base.count.isMultiple(of: _size) ? base.count/_size
-                                            : base.count/_size + 1
+    return base.count
+      .isMultiple(of: _chunkCount) ? base.count/_chunkCount
+                                   : base.count/_chunkCount + 1
   }
 }
 
@@ -361,17 +362,17 @@ extension Collection {
   ///   Otherwise, the last chunk will contain the remaining elements.
   ///
   ///     let c = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-  ///     print(c.chunks(of: 5).map(Array.init))
+  ///     print(c.chunks(ofCount: 5).map(Array.init))
   ///     // [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]
   ///
-  ///     print(c.chunks(of: 3).map(Array.init))
+  ///     print(c.chunks(ofCount: 3).map(Array.init))
   ///     // [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]
   ///
   /// - Complexity: O(1)
   @inlinable
-  public func chunks(of size: Int) -> ChunkedCollection<Self> {
-    assert(size > 0, " Cannot chunk with size <= 0!")
-    return ChunkedCollection(_base: self, _size: size)
+  public func chunks(ofCount count: Int) -> ChunkedCollection<Self> {
+    assert(count > 0, " Cannot chunk with size <= 0!")
+    return ChunkedCollection(_base: self, _chunkCount: count)
   }
 }
 

Tests/SwiftAlgorithmsTests/ChunkedTests.swift

@@ -79,56 +79,56 @@ final class ChunkedTests: XCTestCase {
 
 
   //===----------------------------------------------------------------------===//
-  // Tests for `chunks(of:)`
+  // Tests for `chunks(ofCount:)`
   //===----------------------------------------------------------------------===//
   func testChunksOfSize() {
-    XCTAssertEqualSequences([Int]().chunks(of: 1), [])
-    XCTAssertEqualSequences([Int]().chunks(of: 5), [])
+    XCTAssertEqualSequences([Int]().chunks(ofCount: 1), [])
+    XCTAssertEqualSequences([Int]().chunks(ofCount: 5), [])
 
     let collection = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-    XCTAssertEqualSequences(collection.chunks(of: 1),
+    XCTAssertEqualSequences(collection.chunks(ofCount: 1),
                             [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]])
-    XCTAssertEqualSequences(collection.chunks(of: 3),
+    XCTAssertEqualSequences(collection.chunks(ofCount: 3),
                             [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]])
-    XCTAssertEqualSequences(collection.chunks(of: 5),
+    XCTAssertEqualSequences(collection.chunks(ofCount: 5),
                             [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
-    XCTAssertEqualSequences(collection.chunks(of: 11),
+    XCTAssertEqualSequences(collection.chunks(ofCount: 11),
                             [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]])
   }
 
   func testChunksOfSizeBidirectional() {
     let collection = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
-    XCTAssertEqualSequences(collection.chunks(of: 1).reversed(),
+    XCTAssertEqualSequences(collection.chunks(ofCount: 1).reversed(),
                             [[10], [9], [8], [7], [6], [5], [4], [3], [2], [1]])
-    XCTAssertEqualSequences(collection.chunks(of: 3).reversed(),
+    XCTAssertEqualSequences(collection.chunks(ofCount: 3).reversed(),
                             [[10], [7, 8, 9], [4, 5, 6], [1, 2, 3]])
-    XCTAssertEqualSequences(collection.chunks(of: 5).reversed(),
+    XCTAssertEqualSequences(collection.chunks(ofCount: 5).reversed(),
                             [[6, 7, 8, 9, 10], [1, 2, 3, 4, 5]])
-    XCTAssertEqualSequences(collection.chunks(of: 11).reversed(),
+    XCTAssertEqualSequences(collection.chunks(ofCount: 11).reversed(),
                             [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]])
   }
 
   func testChunksOfSizeCount() {
-    XCTAssertEqual([Int]().chunks(of: 1).count, 0)
-    XCTAssertEqual([Int]().chunks(of: 5).count, 0)
+    XCTAssertEqual([Int]().chunks(ofCount: 1).count, 0)
+    XCTAssertEqual([Int]().chunks(ofCount: 5).count, 0)
 
     let collection = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-    XCTAssertEqual(collection.chunks(of: 1).count, 10)
-    XCTAssertEqual(collection.chunks(of: 3).count, 4)
-    XCTAssertEqual(collection.chunks(of: 5).count, 2)
-    XCTAssertEqual(collection.chunks(of: 11).count, 1)
+    XCTAssertEqual(collection.chunks(ofCount: 1).count, 10)
+    XCTAssertEqual(collection.chunks(ofCount: 3).count, 4)
+    XCTAssertEqual(collection.chunks(ofCount: 5).count, 2)
+    XCTAssertEqual(collection.chunks(ofCount: 11).count, 1)
   }
 
   func testChunksOfSizeDistance() {
-    let emptyChunks = [Int]().chunks(of: 1)
+    let emptyChunks = [Int]().chunks(ofCount: 1)
 
     XCTAssertEqual(
       emptyChunks.distance(from: emptyChunks.startIndex,
                            to: emptyChunks.endIndex), 0)
 
     let collection = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-    let chunks = collection.chunks(of: 3)
+    let chunks = collection.chunks(ofCount: 3)
 
     XCTAssertEqual(
       chunks.distance(from: chunks.startIndex, to: chunks.endIndex), 4)
@@ -146,7 +146,7 @@ final class ChunkedTests: XCTestCase {
   }
 
   func testChunksOfSizeOffset() {
-    let emptyChunks = [Int]().chunks(of: 1)
+    let emptyChunks = [Int]().chunks(ofCount: 1)
 
     XCTAssertEqual(
       emptyChunks.index(emptyChunks.startIndex, offsetBy: 1),
@@ -156,7 +156,7 @@ final class ChunkedTests: XCTestCase {
       emptyChunks.endIndex)
 
     let collection = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-    let chunks = collection.chunks(of: 3)
+    let chunks = collection.chunks(ofCount: 3)
 
     XCTAssertEqual(chunks.index(chunks.startIndex, offsetBy: 1),
                    chunks.index(after: chunks.startIndex))