TSet
Constructors
Signature
declare const empty: <A>() => STM.STM<TSet<A>>;fromIterable
Creates a new TSet from an iterable collection of values.
Signature
declare const fromIterable: <A>(iterable: Iterable<A>) => STM.STM<TSet<A>>;Makes a new TSet that is initialized with specified values.
Signature
declare const make: <Elements extends Array<any>>(
...elements: Elements
) => STM.STM<TSet<Elements[number]>>;Destructors
Collects all elements into a Array.
Signature
declare const toArray: <A>(self: TSet<A>) => STM.STM<Array<A>>;Collects all elements into a Chunk.
Signature
declare const toChunk: <A>(self: TSet<A>) => STM.STM<Chunk.Chunk<A>>;Collects all elements into a HashSet.
Signature
declare const toHashSet: <A>(self: TSet<A>) => STM.STM<HashSet.HashSet<A>>;toReadonlySet
Collects all elements into a ReadonlySet.
Signature
declare const toReadonlySet: <A>(self: TSet<A>) => STM.STM<ReadonlySet<A>>;Elements
Atomically performs transactional-effect for each element in set.
Signature
declare const forEach: {
<A, R, E>(f: (value: A) => STM<void, E, R>): (self: TSet<A>) => STM<void, E, R>;
<A, R, E>(self: TSet<A>, f: (value: A) => STM<void, E, R>): STM<void, E, R>;
};Tests whether or not set contains an element.
Signature
declare const has: {
<A>(value: A): (self: TSet<A>) => STM<boolean>;
<A>(self: TSet<A>, value: A): STM<boolean>;
};Folding
Atomically folds using a pure function.
Signature
declare const reduce: {
<Z, A>(zero: Z, f: (accumulator: Z, value: A) => Z): (self: TSet<A>) => STM<Z>;
<Z, A>(self: TSet<A>, zero: Z, f: (accumulator: Z, value: A) => Z): STM<Z>;
};Atomically folds using a transactional function.
Signature
declare const reduceSTM: {
<Z, A, R, E>(
zero: Z,
f: (accumulator: Z, value: A) => STM<Z, E, R>,
): (self: TSet<A>) => STM<Z, E, R>;
<Z, A, R, E>(self: TSet<A>, zero: Z, f: (accumulator: Z, value: A) => STM<Z, E, R>): STM<Z, E, R>;
};Getters
Models
Mutations
Stores new element in the set.
Signature
declare const add: {
<A>(value: A): (self: TSet<A>) => STM<void>;
<A>(self: TSet<A>, value: A): STM<void>;
};difference
Atomically transforms the set into the difference of itself and the provided set.
Signature
declare const difference: {
<A>(other: TSet<A>): (self: TSet<A>) => STM<void>;
<A>(self: TSet<A>, other: TSet<A>): STM<void>;
};intersection
Atomically transforms the set into the intersection of itself and the provided set.
Signature
declare const intersection: {
<A>(other: TSet<A>): (self: TSet<A>) => STM<void>;
<A>(self: TSet<A>, other: TSet<A>): STM<void>;
};Removes a single element from the set.
Signature
declare const remove: {
<A>(value: A): (self: TSet<A>) => STM<void>;
<A>(self: TSet<A>, value: A): STM<void>;
};Removes elements from the set.
Signature
declare const removeAll: {
<A>(iterable: Iterable<A>): (self: TSet<A>) => STM<void>;
<A>(self: TSet<A>, iterable: Iterable<A>): STM<void>;
};Removes entries from a TSet that satisfy the specified predicate and returns the removed entries (or void if discard = true).
Signature
declare const removeIf: {
<A>(
predicate: Predicate<A>,
options: {
readonly discard: true;
},
): (self: TSet<A>) => STM<void>;
<A>(
predicate: Predicate<A>,
options?: {
readonly discard: false;
},
): (self: TSet<A>) => STM<Array<A>>;
<A>(
self: TSet<A>,
predicate: Predicate<A>,
options: {
readonly discard: true;
},
): STM<void>;
<A>(
self: TSet<A>,
predicate: Predicate<A>,
options?: {
readonly discard: false;
},
): STM<Array<A>>;
};Retains entries in a TSet that satisfy the specified predicate and returns the removed entries (or void if discard = true).
Signature
declare const retainIf: {
<A>(
predicate: Predicate<A>,
options: {
readonly discard: true;
},
): (self: TSet<A>) => STM<void>;
<A>(
predicate: Predicate<A>,
options?: {
readonly discard: false;
},
): (self: TSet<A>) => STM<Array<A>>;
<A>(
self: TSet<A>,
predicate: Predicate<A>,
options: {
readonly discard: true;
},
): STM<void>;
<A>(
self: TSet<A>,
predicate: Predicate<A>,
options?: {
readonly discard: false;
},
): STM<Array<A>>;
};Takes the first matching value, or retries until there is one.
Signature
declare const takeFirst: {
<A, B>(pf: (a: A) => Option<B>): (self: TSet<A>) => STM<B>;
<A, B>(self: TSet<A>, pf: (a: A) => Option<B>): STM<B>;
};takeFirstSTM
Takes the first matching value, or retries until there is one.
Signature
declare const takeFirstSTM: {
<A, B, E, R>(pf: (a: A) => STM<B, Option<E>, R>): (self: TSet<A>) => STM<B, E, R>;
<A, B, E, R>(self: TSet<A>, pf: (a: A) => STM<B, Option<E>, R>): STM<B, E, R>;
};Takes all matching values, or retries until there is at least one.
Signature
declare const takeSome: {
<A, B>(pf: (a: A) => Option<B>): (self: TSet<A>) => STM<[B, ...Array<B>]>;
<A, B>(self: TSet<A>, pf: (a: A) => Option<B>): STM<[B, ...Array<B>]>;
};takeSomeSTM
Takes all matching values, or retries until there is at least one.
Signature
declare const takeSomeSTM: {
<A, B, E, R>(pf: (a: A) => STM<B, Option<E>, R>): (self: TSet<A>) => STM<[B, ...Array<B>], E, R>;
<A, B, E, R>(self: TSet<A>, pf: (a: A) => STM<B, Option<E>, R>): STM<[B, ...Array<B>], E, R>;
};Atomically updates all elements using a pure function.
Signature
declare const transform: {
<A>(f: (a: A) => A): (self: TSet<A>) => STM<void>;
<A>(self: TSet<A>, f: (a: A) => A): STM<void>;
};transformSTM
Atomically updates all elements using a transactional function.
Signature
declare const transformSTM: {
<A, R, E>(f: (a: A) => STM<A, E, R>): (self: TSet<A>) => STM<void, E, R>;
<A, R, E>(self: TSet<A>, f: (a: A) => STM<A, E, R>): STM<void, E, R>;
};Atomically transforms the set into the union of itself and the provided set.
Signature
declare const union: {
<A>(other: TSet<A>): (self: TSet<A>) => STM<void>;
<A>(self: TSet<A>, other: TSet<A>): STM<void>;
};Other
Symbols
TSetTypeId
Signature
declare const TSetTypeId: unique symbol;TSetTypeId type
Signature
type TSetTypeId = typeof TSetTypeId;
Makes an empty
TSet.