Add asyncCount and Grid2D count methods

Author: jsoberg

buildSrc/src/main/kotlin/Publishing.kt

@@ -1,5 +1,5 @@
 object Publishing {
     const val ArtifactId = "kotlin-aoc-utilities"
     const val GroupId = "com.github.jsoberg"
-    const val Version = "2025.1.1"
+    const val Version = "2025.2"
 }

src/main/kotlin/com/soberg/aoc/utlities/datastructures/Grid2D.kt

@@ -133,6 +133,17 @@ data class Grid2D<T>(
         }
     }
 
+    /** Traverses each location in the grid, counting the true results of [at]. */
+    inline fun count(at: (location: Location, element: T) -> Boolean): Int {
+        var total = 0
+        traverse { location ->
+            if (at(location, get(location))) {
+                total++
+            }
+        }
+        return total
+    }
+
     /** Traverses each location in the grid, summing the result of [at]. */
     @OptIn(ExperimentalTypeInference::class)
     @OverloadResolutionByLambdaReturnType

src/main/kotlin/com/soberg/aoc/utlities/extensions/AsyncCount.kt

@@ -0,0 +1,27 @@
+package com.soberg.aoc.utlities.extensions
+
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import java.util.concurrent.atomic.AtomicInteger
+
+inline fun <T> Iterable<T>.asyncCountBlocking(
+    dispatcher: CoroutineDispatcher = Dispatchers.Default,
+    crossinline selector: (T) -> Boolean,
+): Int = runBlocking(dispatcher) {
+    asyncCount(selector)
+}
+
+suspend inline fun <T> Iterable<T>.asyncCount(crossinline selector: (T) -> Boolean): Int {
+    val count = AtomicInteger()
+    coroutineScope {
+        forEach {
+            launch {
+                count.getAndAdd(if (selector(it)) 1 else 0)
+            }
+        }
+    }
+    return count.get()
+}

src/test/kotlin/com/soberg/aoc/utlities/datastructures/Grid2DTest.kt

@@ -202,7 +202,7 @@ class Grid2DTest {
     }
 
     @Test
-    fun `result in expected sum for sumOf Int`() {
+    fun `return expected sum for sumOf Int`() {
         val grid = listOf(
             listOf(1, 2, 3),
             listOf(4, 5, 6),
@@ -212,7 +212,7 @@ class Grid2DTest {
     }
 
     @Test
-    fun `result in expected sum for sumOf Long`() {
+    fun `return expected sum for sumOf Long`() {
         val grid = listOf(
             listOf(Int.MAX_VALUE.toLong() + 1, 2L),
             listOf(4L, 5L),
@@ -221,6 +221,16 @@ class Grid2DTest {
             .isEqualTo(Int.MAX_VALUE.toLong() + 1 + 2 + 4 + 5)
     }
 
+    @Test
+    fun `return expected count`() {
+        val grid = listOf(
+            listOf('A', 'T', 'P'),
+            listOf('P', 'P', 'A'),
+        ).toGrid2D()
+        assertThat(grid.count { _, element -> element == 'P' })
+            .isEqualTo(3)
+    }
+
     @Test
     fun `return expected set of neighbors`() {
         assertThat(testGrid.neighbors(Location(0, 0), MainDirections))

src/test/kotlin/com/soberg/aoc/utlities/extensions/AsyncCountTest.kt

@@ -0,0 +1,28 @@
+package com.soberg.aoc.utlities.extensions
+
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.Test
+
+class AsyncCountTest {
+    private val testData = listOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
+
+    @Test
+    fun `return count - blocking`() {
+        val underFive = testData.asyncCountBlocking {
+            it < 5
+        }
+
+        assertThat(underFive).isEqualTo(5)
+    }
+
+    @Test
+    fun `return count - coroutine`() = runTest {
+        val overFive = testData.asyncCount {
+            it > 5
+        }
+
+        assertThat(overFive).isEqualTo(4)
+    }
+}