> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Kotlin Observable Delegation Kotlin observable delegation is a property delegation mechanism provided by the standard library (`kotlin.properties.Delegates`) that intercepts property assignments to execute custom callback logic. It abstracts the boilerplate of custom setters by routing property mutations through a delegated `ReadWriteProperty` instance. The Kotlin standard library provides two primary functions for observable delegation: `Delegates.observable` and `Delegates.vetoable`. Both functions take an initial value and a handler lambda, returning an `ObservableProperty` that manages the property's backing field. ## `Delegates.observable` The `observable` function executes its callback **after** the assignment has been made to the backing field. **Syntax:** ```kotlin theme={"dark"} inline fun observable( initialValue: T, crossinline onChange: (property: KProperty<*>, oldValue: T, newValue: T) -> Unit ): ReadWriteProperty ``` **Implementation:** ```kotlin theme={"dark"} import kotlin.properties.Delegates class StateManager { var status: String by Delegates.observable("IDLE") { property, oldValue, newValue -> // This block executes immediately after the backing field is updated. println("${property.name} transitioned: $oldValue -> $newValue") } } ``` ## `Delegates.vetoable` The `vetoable` function executes its callback **before** the assignment is committed to the backing field. The lambda must return a `Boolean`. If the lambda evaluates to `true`, the mutation proceeds. If it evaluates to `false`, the assignment is intercepted and discarded, leaving the backing field unmodified. **Syntax:** ```kotlin theme={"dark"} inline fun vetoable( initialValue: T, crossinline onChange: (property: KProperty<*>, oldValue: T, newValue: T) -> Boolean ): ReadWriteProperty ``` **Implementation:** ```kotlin theme={"dark"} import kotlin.properties.Delegates class Configuration { var threshold: Int by Delegates.vetoable(10) { property, oldValue, newValue -> // The assignment only succeeds if this expression evaluates to true. newValue >= oldValue } } ``` ## Internal Mechanics When you use the `by` keyword with these delegates, the Kotlin compiler generates a hidden reference to the `ObservableProperty` object and routes all `getValue` and `setValue` calls through it. 1. **`KProperty<*>`:** The first parameter of the callback provides reflection-based metadata about the delegated property. It is most commonly used to access `property.name`. 2. **`ObservableProperty`:** Both `observable` and `vetoable` instantiate an anonymous subclass of `ObservableProperty`. * In `observable`, the subclass overrides the `afterChange` method. The base `setValue` implementation updates the internal value, then invokes `afterChange`. * In `vetoable`, the subclass overrides the `beforeChange` method. The base `setValue` implementation invokes `beforeChange`; it only updates the internal value if `beforeChange` returns `true`. 3. **Thread Safety:** Neither `Delegates.observable` nor `Delegates.vetoable` are inherently thread-safe. If the delegated property is mutated concurrently from multiple threads, the callbacks and the backing field updates are subject to race conditions unless externally synchronized.

Tired of Poor Kotlin Skills? Fix That With Deep Grasping! Learn More