Kotlin - React Complete
This commit is contained in:
Unknown
parent
11dbf563c2
commit
88fc9c2c3b
3 changed files with 296 additions and 0 deletions
22
kotlin/react/README.md
Normal file
22
kotlin/react/README.md
Normal file
|
|
@ -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.
|
||||||
65
kotlin/react/src/main/kotlin/React.kt
Normal file
65
kotlin/react/src/main/kotlin/React.kt
Normal file
|
|
@ -0,0 +1,65 @@
|
||||||
|
class Reactor<T>() {
|
||||||
|
abstract inner class Cell {
|
||||||
|
abstract val value: T
|
||||||
|
internal val dependents = mutableListOf<ComputeCell>()
|
||||||
|
}
|
||||||
|
|
||||||
|
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<Int, (T) -> Any>()
|
||||||
|
|
||||||
|
constructor(vararg cells: Cell, f: (List<T>) -> 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() }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
209
kotlin/react/src/test/kotlin/ReactTest.kt
Normal file
209
kotlin/react/src/test/kotlin/ReactTest.kt
Normal file
|
|
@ -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<Int>()
|
||||||
|
val input = reactor.InputCell(10)
|
||||||
|
assertEquals(10, input.value)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun inputCellsValueCanBeSet() {
|
||||||
|
val reactor = Reactor<Int>()
|
||||||
|
val input = reactor.InputCell(4)
|
||||||
|
input.value = 20
|
||||||
|
assertEquals(20, input.value)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun computeCellsCalculateInitialValue() {
|
||||||
|
val reactor = Reactor<Int>()
|
||||||
|
val input = reactor.InputCell(1)
|
||||||
|
val output = reactor.ComputeCell(input) { it[0] + 1 }
|
||||||
|
assertEquals(2, output.value)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun computeCellsTakeInputsInTheRightOrder() {
|
||||||
|
val reactor = Reactor<Int>()
|
||||||
|
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<Int>()
|
||||||
|
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<Int>()
|
||||||
|
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<Int>()
|
||||||
|
val input = reactor.InputCell(1)
|
||||||
|
val output = reactor.ComputeCell(input) { it[0] + 1 }
|
||||||
|
|
||||||
|
val vals = mutableListOf<Int>()
|
||||||
|
output.addCallback { vals.add(it) }
|
||||||
|
|
||||||
|
input.value = 3
|
||||||
|
assertEquals(listOf(4), vals)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun callbacksOnlyFireOnChange() {
|
||||||
|
val reactor = Reactor<Int>()
|
||||||
|
val input = reactor.InputCell(1)
|
||||||
|
val output = reactor.ComputeCell(input) { if (it[0] < 3) 111 else 222 }
|
||||||
|
|
||||||
|
val vals = mutableListOf<Int>()
|
||||||
|
output.addCallback { vals.add(it) }
|
||||||
|
|
||||||
|
input.value = 2
|
||||||
|
assertEquals(listOf<Int>(), vals)
|
||||||
|
|
||||||
|
input.value = 4
|
||||||
|
assertEquals(listOf(222), vals)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun callbacksCanBeAddedAndRemoved() {
|
||||||
|
val reactor = Reactor<Int>()
|
||||||
|
val input = reactor.InputCell(11)
|
||||||
|
val output = reactor.ComputeCell(input) { it[0] + 1 }
|
||||||
|
|
||||||
|
val vals1 = mutableListOf<Int>()
|
||||||
|
val sub1 = output.addCallback { vals1.add(it) }
|
||||||
|
val vals2 = mutableListOf<Int>()
|
||||||
|
output.addCallback { vals2.add(it) }
|
||||||
|
|
||||||
|
input.value = 31
|
||||||
|
sub1.cancel()
|
||||||
|
|
||||||
|
val vals3 = mutableListOf<Int>()
|
||||||
|
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<Int>()
|
||||||
|
val input = reactor.InputCell(1)
|
||||||
|
val output = reactor.ComputeCell(input) { it[0] + 1 }
|
||||||
|
|
||||||
|
val vals1 = mutableListOf<Int>()
|
||||||
|
val sub1 = output.addCallback { vals1.add(it) }
|
||||||
|
val vals2 = mutableListOf<Int>()
|
||||||
|
output.addCallback { vals2.add(it) }
|
||||||
|
|
||||||
|
for (i in 1..10) {
|
||||||
|
sub1.cancel()
|
||||||
|
}
|
||||||
|
|
||||||
|
input.value = 2
|
||||||
|
assertEquals(listOf<Int>(), vals1)
|
||||||
|
assertEquals(listOf(3), vals2)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun callbacksShouldOnlyBeCalledOnceEvenIfMultipleDependenciesChange() {
|
||||||
|
val reactor = Reactor<Int>()
|
||||||
|
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<Int>()
|
||||||
|
output.addCallback { vals.add(it) }
|
||||||
|
|
||||||
|
input.value = 4
|
||||||
|
assertEquals(listOf(10), vals)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun callbacksShouldNotBeCalledIfDependenciesChangeButOutputValueDoesntChange() {
|
||||||
|
val reactor = Reactor<Int>()
|
||||||
|
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<Int>()
|
||||||
|
alwaysTwo.addCallback { vals.add(it) }
|
||||||
|
|
||||||
|
for (i in 1..10) {
|
||||||
|
input.value = i
|
||||||
|
}
|
||||||
|
|
||||||
|
assertEquals(listOf<Int>(), 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<Boolean>()
|
||||||
|
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))
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
Add table
Reference in a new issue