Update Swift tools version to 6.0, refactor bounds checking methods, and enhance documentation for grid index neighbors.

Author: Oleksii Oliinyk

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.6
+// swift-tools-version:6.0
 import PackageDescription
 
 let package = Package(
@@ -11,5 +11,5 @@ let package = Package(
         .target(name: "Match3Kit"),
         .testTarget(name: "Match3KitTests", dependencies: ["Match3Kit"])
     ],
-    swiftLanguageVersions: [.v5]
+    swiftLanguageModes: [.v6]
 )

Sources/Match3Kit/Controller.swift

@@ -49,8 +49,10 @@ public struct Pattern: Hashable {
 
         for i in columns {
             for j in rows {
-                let figureIndices = indices.lazy.map { Index(column: $0.column + i,
-                                                             row: $0.row + j) }
+                let figureIndices = indices.map {
+                    Index(column: $0.column + i,
+                          row: $0.row + j)
+                }
                 if containedIn.isSuperset(of: figureIndices) {
                     return Set(figureIndices)
                 }
@@ -213,7 +215,7 @@ public final class Controller<Filling: GridFilling, GeneratorType: Generator<Fil
     public func findPossibleSwap() -> (Index, Index)? {
         for index in grid.allIndices() {
             for neighbour in index.neighbors
-                where grid.size.isOnBounds(neighbour) && hasMatchesExcanging(index, and: neighbour) {
+                where grid.size.isInBounds(neighbour) && hasMatchesExcanging(index, and: neighbour) {
                     return (index, neighbour)
             }
         }

Sources/Match3Kit/Grid.swift

@@ -34,8 +34,12 @@ public struct Size: Hashable, Codable {
         self.rows = rows
     }
 
+    /// Checks if an index is within the bounds of the grid.
+    ///
+    /// - Parameter index: The index to check.
+    /// - Returns: `true` if the index is within the bounds of the grid, `false` otherwise.
     @inlinable
-    public func isOnBounds(_ index: Index) -> Bool {
+    public func isInBounds(_ index: Index) -> Bool {
         index.column > leftBound && index.column < rightBound &&
             index.row > lowerBound && index.row < upperBound
     }
@@ -106,13 +110,35 @@ public struct Index: Hashable, Codable, CustomStringConvertible {
         Index(column: column - 1, row: row)
     }
 
+    /// Returns an array of immediate neighbors of the current index.
+    ///
+    /// The neighbors are the indices immediately adjacent to the current index,
+    /// including the upper, lower, right, and left neighbors.
+    ///
+    /// Example usage:
+    /// ```
+    /// let index = Index(column: 2, row: 2)
+    /// let neighbors = index.neighbors
+    /// print(neighbors) // Prints: "[Index(column: 1, row: 2), Index(column: 3, row: 2), Index(column: 2, row: 1), Index(column: 2, row: 3)]"
+    /// ```
     @inlinable
     public var neighbors: [Index] {
         [left, upper, right, lower]
     }
 
+    /// Returns an array of diagonal neighbors of the current index.
+    ///
+    /// The diagonal neighbors are the indices diagonally adjacent to the current index,
+    /// including the upper-left, upper-right, lower-left, and lower-right neighbors.
+    ///
+    /// Example usage:
+    /// ```
+    /// let index = Index(column: 2, row: 2)
+    /// let diagonalNeighbors = index.diagonalNeighbors
+    /// print(diagonalNeighbors) // Prints: "[Index(column: 1, row: 1), Index(column: 3, row: 3), Index(column: 1, row: 3), Index(column: 3, row: 1)]"
+    /// ```
     @inlinable
-    public var crossNeighbors: [Index] {
+    public var diagonalNeighbors: [Index] {
         [Index(column: column - 1, row: row - 1),
          Index(column: column + 1, row: row + 1),
          Index(column: column - 1, row: row + 1),
@@ -255,10 +281,10 @@ public struct Grid<Filling>: Codable where Filling: GridFilling {
         columns[index.column][index.row] = cell
     }
 
-    public mutating func remove(cells indicies: Set<Index>) -> Set<Index> {
-        let cells = indicies.map(cell(at:))
+    public mutating func remove(cells indices: Set<Index>) -> Set<Index> {
+        let cells = indices.map(cell(at:))
         var removedIndices = Set<Index>()
-        removedIndices.reserveCapacity(indicies.count)
+        removedIndices.reserveCapacity(indices.count)
         for i in columns.indices {
             let start = columns[i].stablePartition { cells.contains($0) }
             let columnIndices = columns[i][start...].indices.map { Index(column: i, row: $0) }

Sources/Match3Kit/Matcher.swift

@@ -101,7 +101,7 @@ open class Matcher<Filling: GridFilling> {
         sequence: some Sequence<Index>
     ) -> [Index] {
         sequence.prefix {
-            grid.size.isOnBounds($0) && match(cell: grid.cell(at: $0), with: cell)
+            grid.size.isInBounds($0) && match(cell: grid.cell(at: $0), with: cell)
         }
     }
 }

Tests/Match3KitTests/GridTests.swift

@@ -28,18 +28,18 @@ final class SizeTests: XCTestCase {
     func testIsOnBounds() {
         let size = Size(columns: 5, rows: 10)
         // Testing within bounds
-        XCTAssertTrue(size.isOnBounds(Index(column: 0, row: 0)))
-        XCTAssertTrue(size.isOnBounds(Index(column: 4, row: 9)))
+        XCTAssertTrue(size.isInBounds(Index(column: 0, row: 0)))
+        XCTAssertTrue(size.isInBounds(Index(column: 4, row: 9)))
         // Testing at bounds
-        XCTAssertFalse(size.isOnBounds(Index(column: -1, row: 0)))
-        XCTAssertFalse(size.isOnBounds(Index(column: 5, row: 0)))
-        XCTAssertFalse(size.isOnBounds(Index(column: 0, row: -1)))
-        XCTAssertFalse(size.isOnBounds(Index(column: 0, row: 10)))
+        XCTAssertFalse(size.isInBounds(Index(column: -1, row: 0)))
+        XCTAssertFalse(size.isInBounds(Index(column: 5, row: 0)))
+        XCTAssertFalse(size.isInBounds(Index(column: 0, row: -1)))
+        XCTAssertFalse(size.isInBounds(Index(column: 0, row: 10)))
         // Testing out of bounds
-        XCTAssertFalse(size.isOnBounds(Index(column: -2, row: 0)))
-        XCTAssertFalse(size.isOnBounds(Index(column: 6, row: 0)))
-        XCTAssertFalse(size.isOnBounds(Index(column: 0, row: -2)))
-        XCTAssertFalse(size.isOnBounds(Index(column: 0, row: 11)))
+        XCTAssertFalse(size.isInBounds(Index(column: -2, row: 0)))
+        XCTAssertFalse(size.isInBounds(Index(column: 6, row: 0)))
+        XCTAssertFalse(size.isInBounds(Index(column: 0, row: -2)))
+        XCTAssertFalse(size.isInBounds(Index(column: 0, row: 11)))
     }
 }
 
@@ -67,7 +67,7 @@ final class IndexTests: XCTestCase {
 
     func testCrossNeighbors() {
         let index = Index(column: 5, row: 10)
-        XCTAssertEqual(index.crossNeighbors, [
+        XCTAssertEqual(index.diagonalNeighbors, [
             Index(column: 4, row: 9),
             Index(column: 6, row: 11),
             Index(column: 4, row: 11),