Added several cell extension methods. Removed RegularCellTests, extension tests are now run just once instead of for every "regular" cell implementation.

cell/src/commonMain/kotlin/world/phantasmal/cell/Cells.kt

@@ -1,6 +1,9 @@
+@file:JvmName("Cells")
+
 package world.phantasmal.cell
 
 import world.phantasmal.core.disposable.Disposable
+import kotlin.jvm.JvmName
 
 private val TRUE_CELL: Cell<Boolean> = ImmutableCell(true)
 private val FALSE_CELL: Cell<Boolean> = ImmutableCell(false)
@@ -8,6 +11,8 @@ private val NULL_CELL: Cell<Nothing?> = ImmutableCell(null)
 private val ZERO_INT_CELL: Cell<Int> = ImmutableCell(0)
 private val EMPTY_STRING_CELL: Cell<String> = ImmutableCell("")
 
+// Factory methods.
+
 /** Returns an immutable cell containing [value]. */
 fun <T> cell(value: T): Cell<T> = ImmutableCell(value)
 
@@ -38,6 +43,8 @@ fun <T> mutableCell(value: T): MutableCell<T> = SimpleCell(value)
 fun <T> mutableCell(getter: () -> T, setter: (T) -> Unit): MutableCell<T> =
     DelegatingCell(getter, setter)
 
+// Observation extensions.
+
 fun <T> Cell<T>.observe(observer: (T) -> Unit): Disposable =
     observeChange { observer(it.value) }
 
@@ -103,6 +110,8 @@ fun <T1, T2, T3, T4, T5> observeNow(
     return disposable
 }
 
+// Generic extensions.
+
 /**
  * Map a transformation function over this cell.
  *
@@ -189,18 +198,28 @@ infix fun <T> Cell<T>.ne(other: Cell<T>): Cell<Boolean> =
 fun <T> Cell<T?>.orElse(defaultValue: () -> T): Cell<T> =
     map { it ?: defaultValue() }
 
-infix fun <T : Comparable<T>> Cell<T>.gt(value: T): Cell<Boolean> =
-    map { it > value }
+// Comparable extensions.
 
 infix fun <T : Comparable<T>> Cell<T>.gt(other: Cell<T>): Cell<Boolean> =
     map(this, other) { a, b -> a > b }
 
-infix fun <T : Comparable<T>> Cell<T>.lt(value: T): Cell<Boolean> =
-    map { it < value }
+infix fun <T : Comparable<T>> Cell<T>.gt(value: T): Cell<Boolean> =
+    map { it > value }
+
+infix fun <T : Comparable<T>> T.gt(other: Cell<T>): Cell<Boolean> =
+    other.map { this > it }
 
 infix fun <T : Comparable<T>> Cell<T>.lt(other: Cell<T>): Cell<Boolean> =
     map(this, other) { a, b -> a < b }
 
+infix fun <T : Comparable<T>> Cell<T>.lt(value: T): Cell<Boolean> =
+    map { it < value }
+
+infix fun <T : Comparable<T>> T.lt(other: Cell<T>): Cell<Boolean> =
+    other.map { this < it }
+
+// Boolean extensions.
+
 infix fun Cell<Boolean>.and(other: Cell<Boolean>): Cell<Boolean> =
     map(this, other) { a, b -> a && b }
 
@@ -223,13 +242,15 @@ infix fun Cell<Boolean>.xor(other: Cell<Boolean>): Cell<Boolean> =
     // Use != because of https://youtrack.jetbrains.com/issue/KT-31277.
     map(this, other) { a, b -> a != b }
 
+infix fun Cell<Boolean>.xor(other: Boolean): Cell<Boolean> =
+    if (other) !this else this
+
+infix fun Boolean.xor(other: Cell<Boolean>): Cell<Boolean> =
+    if (this) !other else other
+
 operator fun Cell<Boolean>.not(): Cell<Boolean> = map { !it }
 
-operator fun Cell<Int>.plus(value: Int): Cell<Int> =
-    map { it + value }
-
-operator fun Cell<Int>.minus(value: Int): Cell<Int> =
-    map { it - value }
+// String extensions.
 
 fun Cell<String>.isEmpty(): Cell<Boolean> =
     map { it.isEmpty() }
@@ -243,6 +264,8 @@ fun Cell<String>.isBlank(): Cell<Boolean> =
 fun Cell<String>.isNotBlank(): Cell<Boolean> =
     map { it.isNotBlank() }
 
+// Other utilities.
+
 fun cellToString(cell: Cell<*>): String {
     val className = cell::class.simpleName
     val value = cell.value

cell/src/commonMain/kotlin/world/phantasmal/cell/DoubleCells.kt

@@ -0,0 +1,44 @@
+@file:JvmName("DoubleCells")
+
+package world.phantasmal.cell
+
+import kotlin.jvm.JvmName
+
+operator fun Cell<Double>.unaryMinus(): Cell<Double> =
+    map { -it }
+
+operator fun Cell<Double>.plus(other: Cell<Double>): Cell<Double> =
+    map(this, other) { a, b -> a + b }
+
+operator fun Cell<Double>.plus(other: Double): Cell<Double> =
+    map { it + other }
+
+operator fun Double.plus(other: Cell<Double>): Cell<Double> =
+    other.map { this + it }
+
+operator fun Cell<Double>.minus(other: Cell<Double>): Cell<Double> =
+    map(this, other) { a, b -> a - b }
+
+operator fun Cell<Double>.minus(other: Double): Cell<Double> =
+    map { it - other }
+
+operator fun Double.minus(other: Cell<Double>): Cell<Double> =
+    other.map { this - it }
+
+operator fun Cell<Double>.times(other: Cell<Double>): Cell<Double> =
+    map(this, other) { a, b -> a * b }
+
+operator fun Cell<Double>.times(other: Double): Cell<Double> =
+    map { it * other }
+
+operator fun Double.times(other: Cell<Double>): Cell<Double> =
+    other.map { this * it }
+
+operator fun Cell<Double>.div(other: Cell<Double>): Cell<Double> =
+    map(this, other) { a, b -> a / b }
+
+operator fun Cell<Double>.div(other: Double): Cell<Double> =
+    map { it / other }
+
+operator fun Double.div(other: Cell<Double>): Cell<Double> =
+    other.map { this / it }

cell/src/commonMain/kotlin/world/phantasmal/cell/IntCells.kt

@@ -0,0 +1,44 @@
+@file:JvmName("IntCells")
+
+package world.phantasmal.cell
+
+import kotlin.jvm.JvmName
+
+operator fun Cell<Int>.unaryMinus(): Cell<Int> =
+    map { -it }
+
+operator fun Cell<Int>.plus(other: Cell<Int>): Cell<Int> =
+    map(this, other) { a, b -> a + b }
+
+operator fun Cell<Int>.plus(other: Int): Cell<Int> =
+    map { it + other }
+
+operator fun Int.plus(other: Cell<Int>): Cell<Int> =
+    other.map { this + it }
+
+operator fun Cell<Int>.minus(other: Cell<Int>): Cell<Int> =
+    map(this, other) { a, b -> a - b }
+
+operator fun Cell<Int>.minus(other: Int): Cell<Int> =
+    map { it - other }
+
+operator fun Int.minus(other: Cell<Int>): Cell<Int> =
+    other.map { this - it }
+
+operator fun Cell<Int>.times(other: Cell<Int>): Cell<Int> =
+    map(this, other) { a, b -> a * b }
+
+operator fun Cell<Int>.times(other: Int): Cell<Int> =
+    map { it * other }
+
+operator fun Int.times(other: Cell<Int>): Cell<Int> =
+    other.map { this * it }
+
+operator fun Cell<Int>.div(other: Cell<Int>): Cell<Int> =
+    map(this, other) { a, b -> a / b }
+
+operator fun Cell<Int>.div(other: Int): Cell<Int> =
+    map { it / other }
+
+operator fun Int.div(other: Cell<Int>): Cell<Int> =
+    other.map { this / it }

cell/src/commonMain/kotlin/world/phantasmal/cell/list/ListCells.kt

@@ -1,8 +1,11 @@
+@file:JvmName("ListCells")
+
 package world.phantasmal.cell.list
 
 import world.phantasmal.cell.Cell
 import world.phantasmal.cell.DependentCell
 import world.phantasmal.cell.ImmutableCell
+import kotlin.jvm.JvmName
 
 private val EMPTY_LIST_CELL = ImmutableListCell<Nothing>(emptyList())
 

cell/src/commonTest/kotlin/world/phantasmal/cell/CellsTests.kt

@@ -0,0 +1,148 @@
+package world.phantasmal.cell
+
+import world.phantasmal.cell.test.CellTestSuite
+import kotlin.test.*
+
+class CellsTests : CellTestSuite {
+    @Test
+    fun cell_contains_the_given_value() = test {
+        val c: Cell<String> = cell("test_value")
+        assertEquals("test_value", c.value)
+    }
+
+    @Test
+    fun trueCell_is_always_true() = test {
+        val c: Cell<Boolean> = trueCell()
+        assertEquals(true, c.value)
+    }
+
+    @Test
+    fun falseCell_is_always_false() = test {
+        val c: Cell<Boolean> = falseCell()
+        assertEquals(false, c.value)
+    }
+
+    @Test
+    fun nullCell_is_always_null() = test {
+        val c: Cell<Nothing?> = nullCell()
+        assertNull(c.value)
+    }
+
+    @Test
+    fun zeroIntCell_is_always_zero() = test {
+        val c: Cell<Int> = zeroIntCell()
+        assertEquals(0, c.value)
+    }
+
+    @Test
+    fun emptyStringCell_is_always_empty() = test {
+        val c: Cell<String> = emptyStringCell()
+        assertEquals("", c.value)
+    }
+
+    @Test
+    fun mutableCell_contains_the_given_value() = test {
+        val c: MutableCell<String> = mutableCell("test_value")
+        assertEquals("test_value", c.value)
+    }
+
+    @Test
+    fun isNull() = test {
+        for (value in arrayOf(Any(), null)) {
+            val c = cell(value).isNull()
+
+            assertEquals(value == null, c.value)
+        }
+    }
+
+    @Test
+    fun isNotNull() = test {
+        for (value in arrayOf(Any(), null)) {
+            val c = cell(value).isNotNull()
+
+            assertEquals(value != null, c.value)
+        }
+    }
+
+    @Test
+    fun equality_infix_functions() = test {
+        val a = cell("equal")
+        val b = cell("equal")
+        val c = cell("NOT equal")
+
+        assertTrue((a eq b).value)
+        assertTrue((a eq "equal").value)
+        assertFalse((a eq c).value)
+        assertFalse((a eq "NOT equal").value)
+
+        assertFalse((a ne b).value)
+        assertFalse((a ne "equal").value)
+        assertTrue((a ne c).value)
+        assertTrue((a ne "NOT equal").value)
+    }
+
+    @Test
+    fun orElse() = test {
+        for (value in arrayOf("value", null)) {
+            val c: Cell<String?> = cell(value)
+            val coe: Cell<String> = c.orElse { "default" }
+
+            assertEquals(value ?: "default", coe.value)
+        }
+    }
+
+    @Test
+    fun comparable_extensions() = test {
+        val a = cell(1)
+        val b = cell(2)
+
+        assertFalse((a gt b).value)
+        assertFalse((a gt 2).value)
+        assertFalse((1 gt b).value)
+
+        assertTrue((a lt b).value)
+        assertTrue((a lt 2).value)
+        assertTrue((1 lt b).value)
+    }
+
+    @Test
+    fun boolean_extensions() = test {
+        for (a in arrayOf(false, true)) {
+            val aCell = cell(a)
+
+            assertEquals(!a, (!aCell).value)
+
+            for (b in arrayOf(false, true)) {
+                val bCell = cell(b)
+
+                assertEquals(a && b, (aCell and bCell).value)
+                assertEquals(a && b, (aCell and b).value)
+                assertEquals(a && b, (a and bCell).value)
+
+                assertEquals(a || b, (aCell or bCell).value)
+                assertEquals(a || b, (aCell or b).value)
+                assertEquals(a || b, (a or bCell).value)
+
+                // Use != because of https://youtrack.jetbrains.com/issue/KT-31277.
+                assertEquals(a != b, (aCell xor bCell).value)
+                assertEquals(a != b, (aCell xor b).value)
+                assertEquals(a != b, (a xor bCell).value)
+            }
+        }
+    }
+
+    @Test
+    fun string_extensions() = test {
+        for (string in arrayOf("", "  ", "\t\t", "non-empty-non-blank")) {
+            val stringCell = cell(string)
+
+            assertEquals(string.isEmpty(), stringCell.isEmpty().value)
+
+            assertEquals(string.isNotEmpty(), stringCell.isNotEmpty().value)
+
+            assertEquals(string.isBlank(), stringCell.isBlank().value)
+
+            assertEquals(string.isNotBlank(), stringCell.isNotBlank().value)
+        }
+    }
+}

cell/src/commonTest/kotlin/world/phantasmal/cell/DelegatingCellTests.kt

@@ -1,7 +1,7 @@
 package world.phantasmal.cell
 
 @Suppress("unused")
-class DelegatingCellTests : RegularCellTests, MutableCellTests<Int> {
+class DelegatingCellTests : MutableCellTests<Int> {
     override fun createProvider() = object : MutableCellTests.Provider<Int> {
         private var v = 17
 
@@ -13,9 +13,4 @@ class DelegatingCellTests : RegularCellTests, MutableCellTests<Int> {
 
         override fun createValue(): Int = v + 1
     }
-
-    override fun <T> createWithValue(value: T): Cell<T> {
-        var v = value
-        return DelegatingCell({ v }, { v = it })
-    }
 }

cell/src/commonTest/kotlin/world/phantasmal/cell/DependentCellTests.kt

@@ -1,14 +1,9 @@
 package world.phantasmal.cell
 
 @Suppress("unused")
-class DependentCellTests : RegularCellTests, CellWithDependenciesTests {
+class DependentCellTests : CellWithDependenciesTests {
     override fun createProvider() = Provider()
 
-    override fun <T> createWithValue(value: T): Cell<T> {
-        val dependency = SimpleCell(value)
-        return DependentCell(dependency) { dependency.value }
-    }
-
     override fun createWithDependencies(
         dependency1: Cell<Int>,
         dependency2: Cell<Int>,

cell/src/commonTest/kotlin/world/phantasmal/cell/DoubleCellsTests.kt

@@ -0,0 +1,36 @@
+package world.phantasmal.cell
+
+import world.phantasmal.cell.test.CellTestSuite
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class DoubleCellsTests : CellTestSuite {
+    @Test
+    fun extensions() = test {
+        for (a in arrayOf(-5.0, -2.0, 0.0, 2.0, 5.0)) {
+            val aCell = cell(a)
+
+            assertEquals(-a, (-aCell).value)
+
+            for (b in arrayOf(-5.4, -3.2, 1.138724, 2.076283, 500.0)) {
+                val bCell = cell(b)
+
+                assertEquals(a + b, (aCell + bCell).value)
+                assertEquals(a + b, (aCell + b).value)
+                assertEquals(a + b, (a + bCell).value)
+
+                assertEquals(a - b, (aCell - bCell).value)
+                assertEquals(a - b, (aCell - b).value)
+                assertEquals(a - b, (a - bCell).value)
+
+                assertEquals(a * b, (aCell * bCell).value)
+                assertEquals(a * b, (aCell * b).value)
+                assertEquals(a * b, (a * bCell).value)
+
+                assertEquals(a / b, (aCell / bCell).value)
+                assertEquals(a / b, (aCell / b).value)
+                assertEquals(a / b, (a / bCell).value)
+            }
+        }
+    }
+}

cell/src/commonTest/kotlin/world/phantasmal/cell/FlatteningDependentCellDirectDependencyEmitsTests.kt

@@ -4,7 +4,7 @@ package world.phantasmal.cell
  * In these tests the direct dependency of the [FlatteningDependentCell] changes.
  */
 @Suppress("unused")
-class FlatteningDependentCellDirectDependencyEmitsTests : RegularCellTests {
+class FlatteningDependentCellDirectDependencyEmitsTests : CellTests {
     override fun createProvider() = object : CellTests.Provider {
         // The transitive dependency can't change.
         val transitiveDependency = ImmutableCell(5)
@@ -21,9 +21,4 @@ class FlatteningDependentCellDirectDependencyEmitsTests : RegularCellTests {
             directDependency.value = ImmutableCell(oldTransitiveDependency.value + 5)
         }
     }
-
-    override fun <T> createWithValue(value: T): Cell<T> {
-        val v = ImmutableCell(ImmutableCell(value))
-        return FlatteningDependentCell(v) { v.value }
-    }
 }

cell/src/commonTest/kotlin/world/phantasmal/cell/FlatteningDependentCellTransitiveDependencyEmitsTests.kt

@@ -4,17 +4,10 @@ package world.phantasmal.cell
  * In these tests the dependency of the [FlatteningDependentCell]'s direct dependency changes.
  */
 @Suppress("unused")
-class FlatteningDependentCellTransitiveDependencyEmitsTests :
-    RegularCellTests,
-    CellWithDependenciesTests {
+class FlatteningDependentCellTransitiveDependencyEmitsTests : CellWithDependenciesTests {
 
     override fun createProvider() = Provider()
 
-    override fun <T> createWithValue(value: T): Cell<T> {
-        val dependency = ImmutableCell(ImmutableCell(value))
-        return FlatteningDependentCell(dependency) { dependency.value }
-    }
-
     override fun createWithDependencies(
         dependency1: Cell<Int>,
         dependency2: Cell<Int>,

cell/src/commonTest/kotlin/world/phantasmal/cell/IntCellsTests.kt

@@ -0,0 +1,36 @@
+package world.phantasmal.cell
+
+import world.phantasmal.cell.test.CellTestSuite
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class IntCellsTests : CellTestSuite {
+    @Test
+    fun extensions() = test {
+        for (a in -5..5) {
+            val aCell = cell(a)
+
+            assertEquals(-a, (-aCell).value)
+
+            for (b in 1..5) {
+                val bCell = cell(b)
+
+                assertEquals(a + b, (aCell + bCell).value)
+                assertEquals(a + b, (aCell + b).value)
+                assertEquals(a + b, (a + bCell).value)
+
+                assertEquals(a - b, (aCell - bCell).value)
+                assertEquals(a - b, (aCell - b).value)
+                assertEquals(a - b, (a - bCell).value)
+
+                assertEquals(a * b, (aCell * bCell).value)
+                assertEquals(a * b, (aCell * b).value)
+                assertEquals(a * b, (a * bCell).value)
+
+                assertEquals(a / b, (aCell / bCell).value)
+                assertEquals(a / b, (aCell / b).value)
+                assertEquals(a / b, (a / bCell).value)
+            }
+        }
+    }
+}

cell/src/commonTest/kotlin/world/phantasmal/cell/RegularCellTests.kt

@@ -1,141 +0,0 @@
-package world.phantasmal.cell
-
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertFalse
-import kotlin.test.assertTrue
-
-/**
- * Test suite for all [Cell] implementations that aren't ListCells. There is a subclass of this
- * suite for every non-ListCell [Cell] implementation.
- */
-interface RegularCellTests : CellTests {
-    fun <T> createWithValue(value: T): Cell<T>
-
-    // TODO: Move this test to CellTests.
-    @Test
-    fun convenience_methods() = test {
-        listOf(Any(), null).forEach { any ->
-            val anyCell = createWithValue(any)
-
-            // Test the test setup first.
-            assertEquals(any, anyCell.value)
-
-            // Test `isNull`.
-            assertEquals(any == null, anyCell.isNull().value)
-
-            // Test `isNotNull`.
-            assertEquals(any != null, anyCell.isNotNull().value)
-        }
-    }
-
-    // TODO: Move this test to CellTests.
-    @Test
-    fun generic_extensions() = test {
-        listOf(Any(), null).forEach { any ->
-            val anyCell = createWithValue(any)
-
-            // Test the test setup first.
-            assertEquals(any, anyCell.value)
-
-            // Test `orElse`.
-            assertEquals(any ?: "default", anyCell.orElse { "default" }.value)
-        }
-
-        fun <T> testEqNe(a: T, b: T) {
-            val aCell = createWithValue(a)
-            val bCell = createWithValue(b)
-
-            // Test the test setup first.
-            assertEquals(a, aCell.value)
-            assertEquals(b, bCell.value)
-
-            // Test `eq`.
-            assertEquals(a == b, (aCell eq b).value)
-            assertEquals(a == b, (aCell eq bCell).value)
-
-            // Test `ne`.
-            assertEquals(a != b, (aCell ne b).value)
-            assertEquals(a != b, (aCell ne bCell).value)
-        }
-
-        testEqNe(null, null)
-        testEqNe(null, Unit)
-        testEqNe(Unit, Unit)
-        testEqNe(10, 10)
-        testEqNe(5, 99)
-        testEqNe("a", "a")
-        testEqNe("x", "y")
-    }
-
-    @Test
-    fun comparable_extensions() = test {
-        fun <T : Comparable<T>> comparable_tests(a: T, b: T) {
-            val aCell = createWithValue(a)
-            val bCell = createWithValue(b)
-
-            // Test the test setup first.
-            assertEquals(a, aCell.value)
-            assertEquals(b, bCell.value)
-
-            // Test `gt`.
-            assertEquals(a > b, (aCell gt b).value)
-            assertEquals(a > b, (aCell gt bCell).value)
-
-            // Test `lt`.
-            assertEquals(a < b, (aCell lt b).value)
-            assertEquals(a < b, (aCell lt bCell).value)
-        }
-
-        comparable_tests(10, 10)
-        comparable_tests(7.0, 5.0)
-        comparable_tests((5000).toShort(), (7000).toShort())
-    }
-
-    @Test
-    fun boolean_extensions() = test {
-        listOf(true, false).forEach { bool ->
-            val boolCell = createWithValue(bool)
-
-            // Test the test setup first.
-            assertEquals(bool, boolCell.value)
-
-            // Test `and`.
-            assertEquals(bool, (boolCell and trueCell()).value)
-            assertFalse((boolCell and falseCell()).value)
-
-            // Test `or`.
-            assertTrue((boolCell or trueCell()).value)
-            assertEquals(bool, (boolCell or falseCell()).value)
-
-            // Test `xor`.
-            assertEquals(!bool, (boolCell xor trueCell()).value)
-            assertEquals(bool, (boolCell xor falseCell()).value)
-
-            // Test `!` (unary not).
-            assertEquals(!bool, (!boolCell).value)
-        }
-    }
-
-    @Test
-    fun string_extensions() = test {
-        listOf("", "  ", "\t\t", "non-empty-non-blank").forEach { string ->
-            val stringCell = createWithValue(string)
-
-            // Test the test setup first.
-            assertEquals(string, stringCell.value)
-
-            // Test `isEmpty`.
-            assertEquals(string.isEmpty(), stringCell.isEmpty().value)
-
-            // Test `isNotEmpty`.
-            assertEquals(string.isNotEmpty(), stringCell.isNotEmpty().value)
-
-            // Test `isBlank`.
-            assertEquals(string.isBlank(), stringCell.isBlank().value)
-
-            // Test `isNotBlank`.
-            assertEquals(string.isNotBlank(), stringCell.isNotBlank().value)
-        }
-    }
-}

cell/src/commonTest/kotlin/world/phantasmal/cell/SimpleCellTests.kt

@@ -1,7 +1,7 @@
 package world.phantasmal.cell
 
 @Suppress("unused")
-class SimpleCellTests : RegularCellTests, MutableCellTests<Int> {
+class SimpleCellTests : MutableCellTests<Int> {
     override fun createProvider() = object : MutableCellTests.Provider<Int> {
         override val cell = SimpleCell(1)
 
@@ -11,6 +11,4 @@ class SimpleCellTests : RegularCellTests, MutableCellTests<Int> {
 
         override fun createValue(): Int = cell.value + 1
     }
-
-    override fun <T> createWithValue(value: T): Cell<T> = SimpleCell(value)
 }