From 88fc9c2c3b64b8fedf02d8ebf78b56061a10a029 Mon Sep 17 00:00:00 2001 From: Unknown Date: Tue, 5 Sep 2017 15:26:53 -0400 Subject: [PATCH] Kotlin - React Complete --- kotlin/react/README.md | 22 +++ kotlin/react/src/main/kotlin/React.kt | 65 +++++++ kotlin/react/src/test/kotlin/ReactTest.kt | 209 ++++++++++++++++++++++ 3 files changed, 296 insertions(+) create mode 100644 kotlin/react/README.md create mode 100644 kotlin/react/src/main/kotlin/React.kt create mode 100644 kotlin/react/src/test/kotlin/ReactTest.kt diff --git a/kotlin/react/README.md b/kotlin/react/README.md new file mode 100644 index 0000000..62aac2d --- /dev/null +++ b/kotlin/react/README.md @@ -0,0 +1,22 @@ +# React + +Implement a basic reactive system. + +Reactive programming is a programming paradigm that focuses on how values +are computed in terms of each other to allow a change to one value to +automatically propagate to other values, like in a spreadsheet. + +Implement a basic reactive system with cells with settable values ("input" +cells) and cells with values computed in terms of other cells ("compute" +cells). Implement updates so that when an input value is changed, values +propagate to reach a new stable system state. + +In addition, compute cells should allow for registering change notification +callbacks. Call a cell’s callbacks when the cell’s value in a new stable +state has changed from the previous stable state. + + + + +## Submitting Incomplete Solutions +It's possible to submit an incomplete solution so you can see how others have completed the exercise. diff --git a/kotlin/react/src/main/kotlin/React.kt b/kotlin/react/src/main/kotlin/React.kt new file mode 100644 index 0000000..7e3be4b --- /dev/null +++ b/kotlin/react/src/main/kotlin/React.kt @@ -0,0 +1,65 @@ +class Reactor() { + abstract inner class Cell { + abstract val value: T + internal val dependents = mutableListOf() + } + + interface Subscription { + fun cancel() + } + + inner class InputCell(initialValue: T) : Cell() { + override var value: T = initialValue + set(newValue) { + field = newValue + dependents.forEach { it.propagate() } + dependents.forEach { it.fireCallbacks() } + } + } + + inner class ComputeCell private constructor(val newValue: () -> T) : Cell() { + override var value: T = newValue() + private set + + private var lastCallbackValue = value + private var callbacksIssued = 0 + private val activeCallbacks = mutableMapOf Any>() + + constructor(vararg cells: Cell, f: (List) -> T) : this({ f(cells.map { it.value }) }) { + for (cell in cells) { + cell.dependents.add(this) + } + } + + fun addCallback(f: (T) -> Any): Subscription { + val id = callbacksIssued + callbacksIssued++ + activeCallbacks[id] = f + return object : Subscription { + override fun cancel() { + activeCallbacks.remove(id) + } + } + } + + internal fun propagate() { + val nv = newValue() + if (nv == value) { + return + } + value = nv + dependents.forEach { it.propagate() } + } + + internal fun fireCallbacks() { + if (value == lastCallbackValue) { + return + } + lastCallbackValue = value + for (cb in activeCallbacks.values) { + cb(value) + } + dependents.forEach { it.fireCallbacks() } + } + } +} \ No newline at end of file diff --git a/kotlin/react/src/test/kotlin/ReactTest.kt b/kotlin/react/src/test/kotlin/ReactTest.kt new file mode 100644 index 0000000..a971348 --- /dev/null +++ b/kotlin/react/src/test/kotlin/ReactTest.kt @@ -0,0 +1,209 @@ +import org.junit.Test +import org.junit.Ignore +import org.junit.runner.RunWith +import org.junit.runners.Parameterized +import kotlin.test.assertEquals + +class ReactTest { + @Test + fun inputCellsHaveValue() { + val reactor = Reactor() + val input = reactor.InputCell(10) + assertEquals(10, input.value) + } + + @Test + fun inputCellsValueCanBeSet() { + val reactor = Reactor() + val input = reactor.InputCell(4) + input.value = 20 + assertEquals(20, input.value) + } + + @Test + fun computeCellsCalculateInitialValue() { + val reactor = Reactor() + val input = reactor.InputCell(1) + val output = reactor.ComputeCell(input) { it[0] + 1 } + assertEquals(2, output.value) + } + + @Test + fun computeCellsTakeInputsInTheRightOrder() { + val reactor = Reactor() + val one = reactor.InputCell(1) + val two = reactor.InputCell(2) + val output = reactor.ComputeCell(one, two) { (x, y) -> x + y * 10 } + assertEquals(21, output.value) + } + + @Test + fun computeCellsUpdateValueWhenDependenciesAreChanged() { + val reactor = Reactor() + val input = reactor.InputCell(1) + val output = reactor.ComputeCell(input) { it[0] + 1 } + input.value = 3 + assertEquals(4, output.value) + } + + @Test + fun computeCellsCanDependOnOtherComputeCells() { + val reactor = Reactor() + val input = reactor.InputCell(1) + val timesTwo = reactor.ComputeCell(input) { it[0] * 2 } + val timesThirty = reactor.ComputeCell(input) { it[0] * 30 } + val output = reactor.ComputeCell(timesTwo, timesThirty) { (x, y) -> x + y } + + assertEquals(32, output.value) + input.value = 3 + assertEquals(96, output.value) + } + + @Test + fun computeCellsFireCallbacks() { + val reactor = Reactor() + val input = reactor.InputCell(1) + val output = reactor.ComputeCell(input) { it[0] + 1 } + + val vals = mutableListOf() + output.addCallback { vals.add(it) } + + input.value = 3 + assertEquals(listOf(4), vals) + } + + @Test + fun callbacksOnlyFireOnChange() { + val reactor = Reactor() + val input = reactor.InputCell(1) + val output = reactor.ComputeCell(input) { if (it[0] < 3) 111 else 222 } + + val vals = mutableListOf() + output.addCallback { vals.add(it) } + + input.value = 2 + assertEquals(listOf(), vals) + + input.value = 4 + assertEquals(listOf(222), vals) + } + + @Test + fun callbacksCanBeAddedAndRemoved() { + val reactor = Reactor() + val input = reactor.InputCell(11) + val output = reactor.ComputeCell(input) { it[0] + 1 } + + val vals1 = mutableListOf() + val sub1 = output.addCallback { vals1.add(it) } + val vals2 = mutableListOf() + output.addCallback { vals2.add(it) } + + input.value = 31 + sub1.cancel() + + val vals3 = mutableListOf() + output.addCallback { vals3.add(it) } + + input.value = 41 + + assertEquals(listOf(32), vals1) + assertEquals(listOf(32, 42), vals2) + assertEquals(listOf(42), vals3) + } + + @Test + fun removingACallbackMultipleTimesDoesntInterfereWithOtherCallbacks() { + val reactor = Reactor() + val input = reactor.InputCell(1) + val output = reactor.ComputeCell(input) { it[0] + 1 } + + val vals1 = mutableListOf() + val sub1 = output.addCallback { vals1.add(it) } + val vals2 = mutableListOf() + output.addCallback { vals2.add(it) } + + for (i in 1..10) { + sub1.cancel() + } + + input.value = 2 + assertEquals(listOf(), vals1) + assertEquals(listOf(3), vals2) + } + + @Test + fun callbacksShouldOnlyBeCalledOnceEvenIfMultipleDependenciesChange() { + val reactor = Reactor() + val input = reactor.InputCell(1) + val plusOne = reactor.ComputeCell(input) { it[0] + 1 } + val minusOne1 = reactor.ComputeCell(input) { it[0] - 1 } + val minusOne2 = reactor.ComputeCell(minusOne1) { it[0] - 1 } + val output = reactor.ComputeCell(plusOne, minusOne2) { (x, y) -> x * y } + + val vals = mutableListOf() + output.addCallback { vals.add(it) } + + input.value = 4 + assertEquals(listOf(10), vals) + } + + @Test + fun callbacksShouldNotBeCalledIfDependenciesChangeButOutputValueDoesntChange() { + val reactor = Reactor() + val input = reactor.InputCell(1) + val plusOne = reactor.ComputeCell(input) { it[0] + 1 } + val minusOne = reactor.ComputeCell(input) { it[0] - 1 } + val alwaysTwo = reactor.ComputeCell(plusOne, minusOne) { (x, y) -> x - y } + + val vals = mutableListOf() + alwaysTwo.addCallback { vals.add(it) } + + for (i in 1..10) { + input.value = i + } + + assertEquals(listOf(), vals) + } +} + +@RunWith(Parameterized::class) +// This is a digital logic circuit called an adder: +// https://en.wikipedia.org/wiki/Adder_(electronics) +class ReactAdderTest(val input: Input, val expected: Expected) { + + companion object { + data class Input(val a: Boolean, val b: Boolean, val carryIn: Boolean) + data class Expected(val carryOut: Boolean, val sum: Boolean) + + @JvmStatic + @Parameterized.Parameters(name = "{index}: {0} = {1}") + fun data() = listOf( + arrayOf(Input(a=false, b=false, carryIn=false), Expected(carryOut=false, sum=false)), + arrayOf(Input(a=false, b=false, carryIn=true), Expected(carryOut=false, sum=true)), + arrayOf(Input(a=false, b=true, carryIn=false), Expected(carryOut=false, sum=true)), + arrayOf(Input(a=false, b=true, carryIn=true), Expected(carryOut=true, sum=false)), + arrayOf(Input(a=true, b=false, carryIn=false), Expected(carryOut=false, sum=true)), + arrayOf(Input(a=true, b=false, carryIn=true), Expected(carryOut=true, sum=false)), + arrayOf(Input(a=true, b=true, carryIn=false), Expected(carryOut=true, sum=false)), + arrayOf(Input(a=true, b=true, carryIn=true), Expected(carryOut=true, sum=true)) + ) + } + + @Test + fun test() { + val reactor = Reactor() + val a = reactor.InputCell(input.a) + val b = reactor.InputCell(input.b) + val carryIn = reactor.InputCell(input.carryIn) + + val aXorB = reactor.ComputeCell(a, b) { (x, y) -> x.xor(y) } + val sum = reactor.ComputeCell(aXorB, carryIn) { (x, y) -> x.xor(y) } + + val aXorBAndCin = reactor.ComputeCell(aXorB, carryIn) { (x, y) -> x && y } + val aAndB = reactor.ComputeCell(a, b) { (x, y) -> x && y } + val carryOut = reactor.ComputeCell(aXorBAndCin, aAndB) { (x, y) -> x || y } + + assertEquals(expected, Expected(sum=sum.value, carryOut=carryOut.value)) + } +}