TSet API Reference

Constructors

empty

Since v2.0.0

Makes an empty TSet.

Signature

declare const empty: <A>() => STM.STM<TSet<A>>

fromIterable

Since v2.0.0

Creates a new TSet from an iterable collection of values.

Signature

declare const fromIterable: <A>(iterable: Iterable<A>) => STM.STM<TSet<A>>

make

Since v2.0.0

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

toArray

Since v2.0.0

Collects all elements into a Array.

Signature

declare const toArray: <A>(self: TSet<A>) => STM.STM<Array<A>>

toChunk

Since v2.0.0

Collects all elements into a Chunk.

Signature

declare const toChunk: <A>(self: TSet<A>) => STM.STM<Chunk.Chunk<A>>

toHashSet

Since v2.0.0

Collects all elements into a HashSet.

Signature

declare const toHashSet: <A>(self: TSet<A>) => STM.STM<HashSet.HashSet<A>>

toReadonlySet

Since v2.0.0

Collects all elements into a ReadonlySet.

Signature

declare const toReadonlySet: <A>(self: TSet<A>) => STM.STM<ReadonlySet<A>>

Elements

forEach

Since v2.0.0

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>;
}

has

Since v2.0.0

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

reduce

Since v2.0.0

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>;
}

reduceSTM

Since v2.0.0

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

isEmpty

Since v2.0.0

Tests if the set is empty or not

Signature

declare const isEmpty: <A>(self: TSet<A>) => STM.STM<boolean>

size

Since v2.0.0

Returns the set's cardinality.

Signature

declare const size: <A>(self: TSet<A>) => STM.STM<number>

Models

TSet

interface

Since v2.0.0

Transactional set implemented on top of TMap.

Signature

interface TSet<in out A> extends Variance<A> {}

Mutations

add

Since v2.0.0

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

Since v2.0.0

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

Since v2.0.0

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>;
}

remove

Since v2.0.0

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>;
}

removeAll

Since v2.0.0

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>;
}

removeIf

Since v2.0.0

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>>;
}

retainIf

Since v2.0.0

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>>;
}

takeFirst

Since v2.0.0

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

Since v2.0.0

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>;
}

takeSome

Since v2.0.0

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

Since v2.0.0

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>;
}

transform

Since v2.0.0

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

Since v2.0.0

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>;
}

union

Since v2.0.0

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

TSet

Since v2.0.0

Symbols

TSetTypeId

Since v2.0.0

Signature

declare const TSetTypeId: unique symbol

TSetTypeId

type

Since v2.0.0

Signature

type TSetTypeId = typeof TSetTypeId