feat: Add partition() and contains() collection operators (#39)

Author: mrmans0n

asyncresult/src/commonMain/kotlin/io/nlopez/asyncresult/AsyncResult.contains.kt

@@ -0,0 +1,8 @@
+// Copyright 2026 Nacho Lopez
+// SPDX-License-Identifier: MIT
+@file:Suppress("NOTHING_TO_INLINE")
+
+package io.nlopez.asyncresult
+
+/** Returns true if this [AsyncResult] is a [Success] containing the given [value]. */
+public inline fun <T> AsyncResult<T>.contains(value: T): Boolean = isSuccessAnd { it == value }

asyncresult/src/commonMain/kotlin/io/nlopez/asyncresult/AsyncResult.iterable.kt

@@ -193,3 +193,36 @@ public inline fun <T> List<AsyncResult<T>>.sequence(): AsyncResult<List<T>> = co
  * @return A single [AsyncResult] containing the list of all success values, or the first error
  */
 public fun <T> Sequence<AsyncResult<T>>.combine(): AsyncResult<List<T>> = toList().combine()
+
+/**
+ * Partitions a collection of [AsyncResult] items into successful values and errors.
+ *
+ * Incomplete items ([Loading] and [NotStarted]) are ignored.
+ *
+ * @return A [Pair] where the first element is a list of success values and the second is a list of
+ *   errors
+ */
+public inline fun <T> Iterable<AsyncResult<T>>.partition(): Pair<List<T>, List<Error>> =
+    successes() to errors()
+
+/**
+ * Partitions a sequence of [AsyncResult] items into successful values and errors.
+ *
+ * Incomplete items ([Loading] and [NotStarted]) are ignored.
+ *
+ * @return A [Pair] where the first element is a list of success values and the second is a list of
+ *   errors
+ */
+public inline fun <T> Sequence<AsyncResult<T>>.partition(): Pair<List<T>, List<Error>> =
+    successes() to errors()
+
+/**
+ * Partitions an array of [AsyncResult] items into successful values and errors.
+ *
+ * Incomplete items ([Loading] and [NotStarted]) are ignored.
+ *
+ * @return A [Pair] where the first element is a list of success values and the second is a list of
+ *   errors
+ */
+public inline fun <T> Array<out AsyncResult<T>>.partition(): Pair<List<T>, List<Error>> =
+    successes() to errors()

asyncresult/src/commonTest/kotlin/io/nlopez/asyncresult/AsyncResultContainsTest.kt

@@ -0,0 +1,47 @@
+// Copyright 2026 Nacho Lopez
+// SPDX-License-Identifier: MIT
+package io.nlopez.asyncresult
+
+import assertk.assertThat
+import assertk.assertions.isFalse
+import assertk.assertions.isTrue
+import kotlin.test.Test
+
+class AsyncResultContainsTest {
+  @Test
+  fun `contains returns true for Success with matching value`() {
+    val result: AsyncResult<Int> = Success(42)
+    assertThat(result.contains(42)).isTrue()
+  }
+
+  @Test
+  fun `contains returns false for Success with different value`() {
+    val result: AsyncResult<Int> = Success(42)
+    assertThat(result.contains(99)).isFalse()
+  }
+
+  @Test
+  fun `contains returns false for Error`() {
+    val result: AsyncResult<Int> = Error()
+    assertThat(result.contains(42)).isFalse()
+  }
+
+  @Test
+  fun `contains returns false for Loading`() {
+    val result: AsyncResult<Int> = Loading
+    assertThat(result.contains(42)).isFalse()
+  }
+
+  @Test
+  fun `contains returns false for NotStarted`() {
+    val result: AsyncResult<Int> = NotStarted
+    assertThat(result.contains(42)).isFalse()
+  }
+
+  @Test
+  fun `contains works with nullable values`() {
+    val result: AsyncResult<Int?> = Success(null)
+    assertThat(result.contains(null)).isTrue()
+    assertThat(result.contains(42)).isFalse()
+  }
+}

asyncresult/src/commonTest/kotlin/io/nlopez/asyncresult/AsyncResultPartitionTest.kt

@@ -0,0 +1,58 @@
+// Copyright 2026 Nacho Lopez
+// SPDX-License-Identifier: MIT
+package io.nlopez.asyncresult
+
+import assertk.assertThat
+import assertk.assertions.containsExactly
+import assertk.assertions.isEmpty
+import kotlin.test.Test
+
+class AsyncResultPartitionTest {
+  @Test
+  fun `partition separates successes and errors`() {
+    val error = Error()
+    val items: List<AsyncResult<Int>> = listOf(Success(1), error, Success(3))
+    val (successes, errors) = items.partition()
+
+    assertThat(successes).containsExactly(1, 3)
+    assertThat(errors).containsExactly(error)
+  }
+
+  @Test
+  fun `partition ignores Loading and NotStarted`() {
+    val items: List<AsyncResult<Int>> = listOf(Success(1), Loading, NotStarted, Success(2))
+    val (successes, errors) = items.partition()
+
+    assertThat(successes).containsExactly(1, 2)
+    assertThat(errors).isEmpty()
+  }
+
+  @Test
+  fun `partition on empty list returns empty pairs`() {
+    val items: List<AsyncResult<Int>> = emptyList()
+    val (successes, errors) = items.partition()
+
+    assertThat(successes).isEmpty()
+    assertThat(errors).isEmpty()
+  }
+
+  @Test
+  fun `partition works on sequences`() {
+    val error = Error()
+    val items = sequenceOf<AsyncResult<Int>>(Success(1), error, Loading)
+    val (successes, errors) = items.partition()
+
+    assertThat(successes).containsExactly(1)
+    assertThat(errors).containsExactly(error)
+  }
+
+  @Test
+  fun `partition works on arrays`() {
+    val error = Error()
+    val items: Array<AsyncResult<Int>> = arrayOf(Success(1), error, Success(3))
+    val (successes, errors) = items.partition()
+
+    assertThat(successes).containsExactly(1, 3)
+    assertThat(errors).containsExactly(error)
+  }
+}