arrow-fx-coroutines/arrow.fx.coroutines/Atomic

Atomic

interface Atomic<A>

An Atomic with an initial value of A.

Atomic wraps atomic, so that you can also use it on a top-level function or pass it around. In other languages this data type is also known as Ref, IORef or Concurrent safe Reference. So in case you don't need to pass around an atomic reference, or use it in top-level functions it's advised to use atomic from Atomic Fu directly.

import arrow.fx.coroutines.*

suspend fun main() {
  val count = Atomic(0)

  (0 until 20_000).parTraverse {
    count.update(Int::inc)
  }
  println(count.get())
}

Atomic also offers some other interesting operators such as modify, tryUpdate, access&lens.

Types

Companion

object Companion

Functions

access

abstract suspend fun access(): Pair<A, suspend (A) -> Boolean>

Obtains a snapshot of the current value, and a setter for updating it.

get

abstract suspend fun get(): A

Obtains the current value. Since AtomicRef is always guaranteed to have a value, the returned action completes immediately after being bound.

getAndSet

abstract suspend fun getAndSet(a: A): A

Replaces the current value with a, returning the old value.

getAndUpdate

abstract suspend fun getAndUpdate(f: (A) -> A): A

Modifies the current value using the supplied update function and returns the old value.

lens

open fun lens(get: (A) -> B, set: (A, B) -> A): Atomic

Creates an AtomicRef for B based on provided a get and set operation.

modify

abstract suspend fun modify(f: (A) -> Pair<A, B>): B

Modify allows to inspect the state A of the AtomicRef, update it and extract a different state B.

modifyGet

abstract suspend fun modifyGet(f: (A) -> Pair<A, B>): Pair<A, B>

ModifyGet allows to inspect state A, update it and extract a different state B. In contrast to modify, it returns a Pair of the updated state A and the extracted state B.