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