---
title: "currentValueOf"
description: "Returns the current value of [local] at the position in the composition hierarchy of this
modifier's attached layout node.

Unlike [CompositionLocal.current], reads via this function are not automatically tracked by
Compose. Modifiers are not able to recompose in the same way that a Composable can, and therefore
can't receive updates arbitrarily for a CompositionLocal.

Because CompositionLocals may change arbitrarily, it is strongly recommended to ensure that the
composition local is observed instead of being read once. If you call [currentValueOf] inside of
a modifier callback like [LayoutModifierNode.measure] or [DrawModifierNode.draw], then Compose
will track the CompositionLocal read. This happens automatically, because these Compose UI phases
take place in a snapshot observer that tracks which states are read. If the value of the
CompositionLocal changes, and it was read inside of the measure or draw phase, then that phase
will automatically be invalidated.

For all other reads of a CompositionLocal, this function will **not** notify you when the value
of the local changes. [Modifier.Node] classes that also implement [ObserverModifierNode] may
observe CompositionLocals arbitrarily by performing the lookup in an [observeReads] block. To
continue observing values of the CompositionLocal, it must be read again in an [observeReads]
block during or after the [ObserverModifierNode.onObservedReadsChanged] callback is invoked. See
below for an example of how to implement this observation pattern.


This function will fail with an [IllegalStateException] if you attempt to read a CompositionLocal
before the node is [attached][Modifier.Node.onAttach] or after the node is
[detached][Modifier.Node.onDetach]."
type: "function"
---

<div class='type'>Function</div>


<a id='references'></a>
<div class='sourceset sourceset-common'>Common</div>


```kotlin
fun <T> CompositionLocalConsumerModifierNode.currentValueOf(local: CompositionLocal<T>): T
```


Returns the current value of `local` at the position in the composition hierarchy of this
modifier's attached layout node.

Unlike `CompositionLocal.current`, reads via this function are not automatically tracked by
Compose. Modifiers are not able to recompose in the same way that a Composable can, and therefore
can't receive updates arbitrarily for a CompositionLocal.

Because CompositionLocals may change arbitrarily, it is strongly recommended to ensure that the
composition local is observed instead of being read once. If you call `currentValueOf` inside of
a modifier callback like `LayoutModifierNode.measure` or `DrawModifierNode.draw`, then Compose
will track the CompositionLocal read. This happens automatically, because these Compose UI phases
take place in a snapshot observer that tracks which states are read. If the value of the
CompositionLocal changes, and it was read inside of the measure or draw phase, then that phase
will automatically be invalidated.

For all other reads of a CompositionLocal, this function will **not** notify you when the value
of the local changes. `Modifier.Node` classes that also implement `ObserverModifierNode` may
observe CompositionLocals arbitrarily by performing the lookup in an `observeReads` block. To
continue observing values of the CompositionLocal, it must be read again in an `observeReads`
block during or after the `ObserverModifierNode.onObservedReadsChanged` callback is invoked. See
below for an example of how to implement this observation pattern.


This function will fail with an `IllegalStateException` if you attempt to read a CompositionLocal
before the node is `attached` or after the node is
`detached`.

#### Parameters

| | |
| --- | --- |
| local | The CompositionLocal to get the current value of |


#### Returns

| | |
| --- | --- |
|  | The value provided by the nearest `CompositionLocalProvider` component that invokes, directly or indirectly, the composable function that this modifier is attached to. If `local` was never provided, its default value will be returned instead. |




## Code Examples
### CompositionLocalConsumingModifierObserverNodeSample
```kotlin
@Composable
fun CompositionLocalConsumingModifierObserverNodeSample() {
    val LocalValue = compositionLocalOf { "abc123" }
    class ValueObserverModifierNode :
        Modifier.Node(), CompositionLocalConsumerModifierNode, ObserverModifierNode {
        private var observedValue: String? = null
        override fun onAttach() {
            onObservedReadsChanged()
        }
        override fun onDetach() {
            observedValue = null
        }
        override fun onObservedReadsChanged() {
            observeReads {
                observedValue = currentValueOf(LocalValue)
                // Do something with the new value
            }
        }
    }
}
```