arrow-fx-stm/arrow.fx.stm

Package-level declarations

Types

interface STM

Software transactional memory, or STM, is an abstraction for concurrent state modification. With STM one can write code that concurrently accesses state and that can easily be composed without exposing details of how it ensures safety guarantees. Programs running within an STM transaction will neither deadlock nor have race-conditions.

data class TArray<A>

A TArray is an array of transactional variables.

data class TMap<K, V>

A TMap is a concurrent transactional implementation of a key value hashmap.

data class TMVar<A>

A TMVar is a mutable reference that can either be empty or hold a value.

data class TQueue<A>

A TQueue is a transactional unbounded queue which can be written to and read from concurrently.

data class TSemaphore

TSemaphore is the transactional Semaphore.

data class TSet<A>

A TSet is a concurrent transactional implementation of a hashset.

class TVar<A>

A TVar is a mutable reference that can only be (safely) accessed inside a STM transaction.

Functions

suspend fun <A> atomically(f: STM.() -> A): A

Run a transaction to completion.

fun STM.check(b: Boolean)

Retry if b is false otherwise does nothing.

fun <A> STM.newEmptyTMVar(): TMVar<A>

fun <A> STM.newTArray(vararg arr: A): TArray<A>

fun <A> STM.newTArray(xs: Iterable<A>): TArray<A>

fun <A> STM.newTArray(size: Int, a: A): TArray<A>

fun <A> STM.newTArray(size: Int, f: (Int) -> A): TArray<A>

fun <K, V> STM.newTMap(): TMap<K, V>

fun <K, V> STM.newTMap(fn: (K) -> Int): TMap<K, V>

fun <A> STM.newTMVar(a: A): TMVar<A>

fun <A> STM.newTQueue(): TQueue<A>

fun STM.newTSem(initial: Int): TSemaphore

fun <A> STM.newTSet(): TSet<A>

fun <A> STM.newTSet(fn: (A) -> Int): TSet<A>

inline fun <A> stm(noinline f: STM.() -> A): STM.() -> A

Helper to create stm blocks that can be run with STM.orElse