StatefulValidation

Validation for values of type T where the form manager maintains a validation state of type TState for each managed value.

Stateful validations are useful when validations require an expensive computation over data and if it is possible to save the result of such expensive computation and tweak it as data changes instead of running the expensive computation all over again.

As an example, imagine that we have a list of people and that we want to validate that the average age of all people isn't over a certain age. Instead of iterating over the whole list every time a person is added or removed, we can use a stateful validation to save, as state, the sum of all ages, and simply tweak this sum as people are added or removed. Having access to the sum of all ages as state allows us to implement the validation function with a complexity of O(1) as opposed to O(N).

The following snippet implements the example above of making sure that the average age of all people doesn't surpass a dependency maxAvgAge:

object AvgAgeNotOverMax : StatefulValidation<List<Person>, Int>() {
    private val ValidationContext.maxAvgAge: Int by dependency("../maxAvgAge")

    override suspend fun ValidationContext.initState(value: List<Person>): Int =
        value.fold(0) { sum, person -> sum + person.age }

    private val ageObserver by observe<Int>("∗/age") { agesSum, event ->
        when (event) {
            is ValueEvent.Init<Int> -> agesSum + event.newValue
            is ValueEvent.Change<Int> -> agesSum + event.newValue - event.oldValue
            is ValueEvent.Destroy<Int> -> agesSum - event.oldValue
            else -> agesSum
        }
    }

    override fun ValidationContext.validateFromState(value: List<Person>, state: Int) = flow {
        val avgAge = state / value.size
        if (avgAge maxAvgAge) {
            emit(ValidationError("avgAgeOverMax"))
        }
    }
}

Inheritors