TMap.ts overview
Since v2.0.0
Exports Grouped by Category
constructors
empty
Makes an empty TMap
.
Signature
declare const empty: <K, V>() => STM.STM<TMap<K, V>>
Since v2.0.0
fromIterable
Creates a new TMap
from an iterable collection of key/value pairs.
Signature
declare const fromIterable: <K, V>(iterable: Iterable<readonly [K, V]>) => STM.STM<TMap<K, V>>
Since v2.0.0
make
Makes a new TMap
that is initialized with specified values.
Signature
declare const make: <K, V>(...entries: Array<readonly [K, V]>) => STM.STM<TMap<K, V>>
Since v2.0.0
destructors
toArray
Collects all bindings into an Array
.
Signature
declare const toArray: <K, V>(self: TMap<K, V>) => STM.STM<Array<[K, V]>>
Since v2.0.0
toChunk
Collects all bindings into a Chunk
.
Signature
declare const toChunk: <K, V>(self: TMap<K, V>) => STM.STM<Chunk.Chunk<[K, V]>>
Since v2.0.0
toHashMap
Collects all bindings into a HashMap
.
Signature
declare const toHashMap: <K, V>(self: TMap<K, V>) => STM.STM<HashMap.HashMap<K, V>>
Since v2.0.0
toMap
Collects all bindings into a Map
.
Signature
declare const toMap: <K, V>(self: TMap<K, V>) => STM.STM<ReadonlyMap<K, V>>
Since v2.0.0
elements
find
Finds the key/value pair matching the specified predicate, and uses the provided function to extract a value out of it.
Signature
declare const find: {
<K, V, A>(pf: (key: K, value: V) => Option.Option<A>): (self: TMap<K, V>) => STM.STM<Option.Option<A>>
<K, V, A>(self: TMap<K, V>, pf: (key: K, value: V) => Option.Option<A>): STM.STM<Option.Option<A>>
}
Since v2.0.0
findAll
Finds all the key/value pairs matching the specified predicate, and uses the provided function to extract values out them.
Signature
declare const findAll: {
<K, V, A>(pf: (key: K, value: V) => Option.Option<A>): (self: TMap<K, V>) => STM.STM<Array<A>>
<K, V, A>(self: TMap<K, V>, pf: (key: K, value: V) => Option.Option<A>): STM.STM<Array<A>>
}
Since v2.0.0
findAllSTM
Finds all the key/value pairs matching the specified predicate, and uses the provided effectful function to extract values out of them..
Signature
declare const findAllSTM: {
<K, V, A, E, R>(
pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
): (self: TMap<K, V>) => STM.STM<Array<A>, E, R>
<K, V, A, E, R>(self: TMap<K, V>, pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>): STM.STM<Array<A>, E, R>
}
Since v2.0.0
findSTM
Finds the key/value pair matching the specified predicate, and uses the provided effectful function to extract a value out of it.
Signature
declare const findSTM: {
<K, V, A, E, R>(
f: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
): (self: TMap<K, V>) => STM.STM<Option.Option<A>, E, R>
<K, V, A, E, R>(
self: TMap<K, V>,
f: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
): STM.STM<Option.Option<A>, E, R>
}
Since v2.0.0
forEach
Atomically performs transactional-effect for each binding present in map.
Signature
declare const forEach: {
<K, V, X, E, R>(f: (key: K, value: V) => STM.STM<X, E, R>): (self: TMap<K, V>) => STM.STM<void, E, R>
<K, V, X, E, R>(self: TMap<K, V>, f: (key: K, value: V) => STM.STM<X, E, R>): STM.STM<void, E, R>
}
Since v2.0.0
get
Retrieves value associated with given key.
Signature
declare const get: {
<K>(key: K): <V>(self: TMap<K, V>) => STM.STM<Option.Option<V>>
<K, V>(self: TMap<K, V>, key: K): STM.STM<Option.Option<V>>
}
Since v2.0.0
getOrElse
Retrieves value associated with given key or default value, in case the key isn’t present.
Signature
declare const getOrElse: {
<K, V>(key: K, fallback: LazyArg<V>): (self: TMap<K, V>) => STM.STM<V>
<K, V>(self: TMap<K, V>, key: K, fallback: LazyArg<V>): STM.STM<V>
}
Since v2.0.0
has
Tests whether or not map contains a key.
Signature
declare const has: {
<K>(key: K): <V>(self: TMap<K, V>) => STM.STM<boolean>
<K, V>(self: TMap<K, V>, key: K): STM.STM<boolean>
}
Since v2.0.0
keys
Collects all keys stored in map.
Signature
declare const keys: <K, V>(self: TMap<K, V>) => STM.STM<Array<K>>
Since v2.0.0
values
Collects all values stored in map.
Signature
declare const values: <K, V>(self: TMap<K, V>) => STM.STM<Array<V>>
Since v2.0.0
folding
reduce
Atomically folds using a pure function.
Signature
declare const reduce: {
<Z, K, V>(zero: Z, f: (acc: Z, value: V, key: K) => Z): (self: TMap<K, V>) => STM.STM<Z>
<K, V, Z>(self: TMap<K, V>, zero: Z, f: (acc: Z, value: V, key: K) => Z): STM.STM<Z>
}
Since v2.0.0
reduceSTM
Atomically folds using a transactional function.
Signature
declare const reduceSTM: {
<Z, V, K, R, E>(zero: Z, f: (acc: Z, value: V, key: K) => STM.STM<Z, E, R>): (self: TMap<K, V>) => STM.STM<Z, E, R>
<Z, V, K, R, E>(self: TMap<K, V>, zero: Z, f: (acc: Z, value: V, key: K) => STM.STM<Z, E, R>): STM.STM<Z, E, R>
}
Since v2.0.0
getters
isEmpty
Tests if the map is empty or not.
Signature
declare const isEmpty: <K, V>(self: TMap<K, V>) => STM.STM<boolean>
Since v2.0.0
size
Returns the number of bindings.
Signature
declare const size: <K, V>(self: TMap<K, V>) => STM.STM<number>
Since v2.0.0
models
TMap (interface)
Transactional map implemented on top of TRef
and TArray
. Resolves conflicts via chaining.
Signature
export interface TMap<in out K, in out V> extends TMap.Variance<K, V> {}
Since v2.0.0
mutations
merge
If the key is not already associated with a value, stores the provided value, otherwise merge the existing value with the new one using function f
and store the result.
Signature
declare const merge: {
<K, V>(key: K, value: V, f: (x: V, y: V) => V): (self: TMap<K, V>) => STM.STM<V>
<K, V>(self: TMap<K, V>, key: K, value: V, f: (x: V, y: V) => V): STM.STM<V>
}
Since v2.0.0
remove
Removes binding for given key.
Signature
declare const remove: {
<K>(key: K): <V>(self: TMap<K, V>) => STM.STM<void>
<K, V>(self: TMap<K, V>, key: K): STM.STM<void>
}
Since v2.0.0
removeAll
Deletes all entries associated with the specified keys.
Signature
declare const removeAll: {
<K>(keys: Iterable<K>): <V>(self: TMap<K, V>) => STM.STM<void>
<K, V>(self: TMap<K, V>, keys: Iterable<K>): STM.STM<void>
}
Since v2.0.0
removeIf
Removes entries from a TMap
that satisfy the specified predicate and returns the removed entries (or void
if discard = true
).
Signature
declare const removeIf: {
<K, V>(
predicate: (key: K, value: V) => boolean,
options: { readonly discard: true }
): (self: TMap<K, V>) => STM.STM<void>
<K, V>(
predicate: (key: K, value: V) => boolean,
options?: { readonly discard: false }
): (self: TMap<K, V>) => STM.STM<Array<[K, V]>>
<K, V>(self: TMap<K, V>, predicate: (key: K, value: V) => boolean, options: { readonly discard: true }): STM.STM<void>
<K, V>(
self: TMap<K, V>,
predicate: (key: K, value: V) => boolean,
options?: { readonly discard: false }
): STM.STM<Array<[K, V]>>
}
Since v2.0.0
retainIf
Retains entries in a TMap
that satisfy the specified predicate and returns the removed entries (or void
if discard = true
).
Signature
declare const retainIf: {
<K, V>(
predicate: (key: K, value: V) => boolean,
options: { readonly discard: true }
): (self: TMap<K, V>) => STM.STM<void>
<K, V>(
predicate: (key: K, value: V) => boolean,
options?: { readonly discard: false }
): (self: TMap<K, V>) => STM.STM<Array<[K, V]>>
<K, V>(self: TMap<K, V>, predicate: (key: K, value: V) => boolean, options: { readonly discard: true }): STM.STM<void>
<K, V>(
self: TMap<K, V>,
predicate: (key: K, value: V) => boolean,
options?: { readonly discard: false }
): STM.STM<Array<[K, V]>>
}
Since v2.0.0
set
Stores new binding into the map.
Signature
declare const set: {
<K, V>(key: K, value: V): (self: TMap<K, V>) => STM.STM<void>
<K, V>(self: TMap<K, V>, key: K, value: V): STM.STM<void>
}
Since v2.0.0
setIfAbsent
Stores new binding in the map if it does not already exist.
Signature
declare const setIfAbsent: {
<K, V>(key: K, value: V): (self: TMap<K, V>) => STM.STM<void>
<K, V>(self: TMap<K, V>, key: K, value: V): STM.STM<void>
}
Since v2.0.0
takeFirst
Takes the first matching value, or retries until there is one.
Signature
declare const takeFirst: {
<K, V, A>(pf: (key: K, value: V) => Option.Option<A>): (self: TMap<K, V>) => STM.STM<A>
<K, V, A>(self: TMap<K, V>, pf: (key: K, value: V) => Option.Option<A>): STM.STM<A>
}
Since v2.0.0
takeFirstSTM
Takes the first matching value, or retries until there is one.
Signature
declare const takeFirstSTM: {
<K, V, A, E, R>(pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>): (self: TMap<K, V>) => STM.STM<A, E, R>
<K, V, A, E, R>(self: TMap<K, V>, pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>): STM.STM<A, E, R>
}
Since v2.0.0
takeSome
Takes all matching values, or retries until there is at least one.
Signature
declare const takeSome: {
<K, V, A>(pf: (key: K, value: V) => Option.Option<A>): (self: TMap<K, V>) => STM.STM<[A, ...Array<A>]>
<K, V, A>(self: TMap<K, V>, pf: (key: K, value: V) => Option.Option<A>): STM.STM<[A, ...Array<A>]>
}
Since v2.0.0
takeSomeSTM
Takes all matching values, or retries until there is at least one.
Signature
declare const takeSomeSTM: {
<K, V, A, E, R>(
pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
): (self: TMap<K, V>) => STM.STM<[A, ...Array<A>], E, R>
<K, V, A, E, R>(
self: TMap<K, V>,
pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
): STM.STM<[A, ...Array<A>], E, R>
}
Since v2.0.0
transform
Atomically updates all bindings using a pure function.
Signature
declare const transform: {
<K, V>(f: (key: K, value: V) => readonly [K, V]): (self: TMap<K, V>) => STM.STM<void>
<K, V>(self: TMap<K, V>, f: (key: K, value: V) => readonly [K, V]): STM.STM<void>
}
Since v2.0.0
transformSTM
Atomically updates all bindings using a transactional function.
Signature
declare const transformSTM: {
<K, V, R, E>(f: (key: K, value: V) => STM.STM<readonly [K, V], E, R>): (self: TMap<K, V>) => STM.STM<void, E, R>
<K, V, R, E>(self: TMap<K, V>, f: (key: K, value: V) => STM.STM<readonly [K, V], E, R>): STM.STM<void, E, R>
}
Since v2.0.0
transformValues
Atomically updates all values using a pure function.
Signature
declare const transformValues: {
<V>(f: (value: V) => V): <K>(self: TMap<K, V>) => STM.STM<void>
<K, V>(self: TMap<K, V>, f: (value: V) => V): STM.STM<void>
}
Since v2.0.0
transformValuesSTM
Atomically updates all values using a transactional function.
Signature
declare const transformValuesSTM: {
<V, R, E>(f: (value: V) => STM.STM<V, E, R>): <K>(self: TMap<K, V>) => STM.STM<void, E, R>
<K, V, R, E>(self: TMap<K, V>, f: (value: V) => STM.STM<V, E, R>): STM.STM<void, E, R>
}
Since v2.0.0
updateWith
Updates the mapping for the specified key with the specified function, which takes the current value of the key as an input, if it exists, and either returns Some
with a new value to indicate to update the value in the map or None
to remove the value from the map. Returns Some
with the updated value or None
if the value was removed from the map.
Signature
declare const updateWith: {
<K, V>(key: K, f: (value: Option.Option<V>) => Option.Option<V>): (self: TMap<K, V>) => STM.STM<Option.Option<V>>
<K, V>(self: TMap<K, V>, key: K, f: (value: Option.Option<V>) => Option.Option<V>): STM.STM<Option.Option<V>>
}
Since v2.0.0
symbols
TMapTypeId
Signature
declare const TMapTypeId: unique symbol
Since v2.0.0
TMapTypeId (type alias)
Signature
type TMapTypeId = typeof TMapTypeId
Since v2.0.0
utils
TMap (namespace)
Since v2.0.0
Variance (interface)
Signature
export interface Variance<in out K, in out V> {
readonly [TMapTypeId]: {
readonly _K: Types.Invariant<K>
readonly _V: Types.Invariant<V>
}
}
Since v2.0.0