Skip to content

TArray

44 exports Added in v2.0.0 Source

Constructors

empty

Added in v2.0.0 Source

Makes an empty TArray.

Signature

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

fromIterable

Added in v2.0.0 Source

Creates a new TArray from an iterable collection of values.

Signature

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

make

Added in v2.0.0 Source

Makes a new TArray that is initialized with specified values.

Signature

declare const make: <Elements extends [any, ...Array<any>]>(
  ...elements: Elements
) => STM.STM<TArray<Elements[number]>>;

Destructors

toArray

Added in v2.0.0 Source

Collects all elements into a chunk.

Signature

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

Elements

collectFirst

Added in v2.0.0 Source

Finds the result of applying a partial function to the first value in its domain.

Signature

declare const collectFirst: {
  <A, B>(pf: (a: A) => Option<B>): (self: TArray<A>) => STM<Option<B>>;
  <A, B>(self: TArray<A>, pf: (a: A) => Option<B>): STM<Option<B>>;
};

collectFirstSTM

Added in v2.0.0 Source

Finds the result of applying an transactional partial function to the first value in its domain.

Signature

declare const collectFirstSTM: {
  <A, B, E, R>(pf: (a: A) => Option<STM<B, E, R>>): (self: TArray<A>) => STM<Option<B>, E, R>;
  <A, B, E, R>(self: TArray<A>, pf: (a: A) => Option<STM<B, E, R>>): STM<Option<B>, E, R>;
};

contains

Added in v2.0.0 Source

Determine if the array contains a specified value.

Signature

declare const contains: {
  <A>(value: A): (self: TArray<A>) => STM<boolean>;
  <A>(self: TArray<A>, value: A): STM<boolean>;
};

every

Added in v2.0.0 Source

Atomically evaluate the conjunction of a predicate across the members of the array.

Signature

declare const every: {
  <A>(predicate: Predicate<A>): (self: TArray<A>) => STM<boolean>;
  <A>(self: TArray<A>, predicate: Predicate<A>): STM<boolean>;
};

everySTM

Added in v2.0.0 Source

Atomically evaluate the conjunction of a transactional predicate across the members of the array.

Signature

declare const everySTM: {
  <A, R, E>(predicate: (value: A) => STM<boolean, E, R>): (self: TArray<A>) => STM<boolean, E, R>;
  <A, R, E>(self: TArray<A>, predicate: (value: A) => STM<boolean, E, R>): STM<boolean, E, R>;
};

findFirst

Added in v2.0.0 Source

Find the first element in the array matching the specified predicate.

Signature

declare const findFirst: {
  <A>(predicate: Predicate<A>): (self: TArray<A>) => STM<Option<A>>;
  <A>(self: TArray<A>, predicate: Predicate<A>): STM<Option<A>>;
};

findFirstIndex

Added in v2.0.0 Source

Get the first index of a specific value in the array.

Signature

declare const findFirstIndex: {
  <A>(value: A): (self: TArray<A>) => STM<Option<number>>;
  <A>(self: TArray<A>, value: A): STM<Option<number>>;
};

findFirstIndexFrom

Added in v2.0.0 Source

Get the first index of a specific value in the array starting from the specified index.

Signature

declare const findFirstIndexFrom: {
  <A>(value: A, from: number): (self: TArray<A>) => STM<Option<number>>;
  <A>(self: TArray<A>, value: A, from: number): STM<Option<number>>;
};

findFirstIndexWhere

Added in v2.0.0 Source

Get the index of the first entry in the array matching a predicate.

Signature

declare const findFirstIndexWhere: {
  <A>(predicate: Predicate<A>): (self: TArray<A>) => STM<Option<number>>;
  <A>(self: TArray<A>, predicate: Predicate<A>): STM<Option<number>>;
};

findFirstIndexWhereFrom

Added in v2.0.0 Source

Get the index of the first entry in the array starting from the specified index, matching a predicate.

Signature

declare const findFirstIndexWhereFrom: {
  <A>(predicate: Predicate<A>, from: number): (self: TArray<A>) => STM<Option<number>>;
  <A>(self: TArray<A>, predicate: Predicate<A>, from: number): STM<Option<number>>;
};

findFirstIndexWhereFromSTM

Added in v2.0.0 Source

Starting at specified index, get the index of the next entry that matches a transactional predicate.

Signature

declare const findFirstIndexWhereFromSTM: {
  <A, R, E>(
    predicate: (value: A) => STM<boolean, E, R>,
    from: number,
  ): (self: TArray<A>) => STM<Option<number>, E, R>;
  <A, R, E>(
    self: TArray<A>,
    predicate: (value: A) => STM<boolean, E, R>,
    from: number,
  ): STM<Option<number>, E, R>;
};

findFirstIndexWhereSTM

Added in v2.0.0 Source

Get the index of the next entry that matches a transactional predicate.

Signature

declare const findFirstIndexWhereSTM: {
  <A, R, E>(
    predicate: (value: A) => STM<boolean, E, R>,
  ): (self: TArray<A>) => STM<Option<number>, E, R>;
  <A, R, E>(
    self: TArray<A>,
    predicate: (value: A) => STM<boolean, E, R>,
  ): STM<Option<number>, E, R>;
};

findFirstSTM

Added in v2.0.0 Source

Find the first element in the array matching a transactional predicate.

Signature

declare const findFirstSTM: {
  <A, R, E>(predicate: (value: A) => STM<boolean, E, R>): (self: TArray<A>) => STM<Option<A>, E, R>;
  <A, R, E>(self: TArray<A>, predicate: (value: A) => STM<boolean, E, R>): STM<Option<A>, E, R>;
};

findLast

Added in v2.0.0 Source

Find the last element in the array matching a predicate.

Signature

declare const findLast: {
  <A>(predicate: Predicate<A>): (self: TArray<A>) => STM<Option<A>>;
  <A>(self: TArray<A>, predicate: Predicate<A>): STM<Option<A>>;
};

findLastIndex

Added in v2.0.0 Source

Get the last index of a specific value in the array bounded above by a specific index.

Signature

declare const findLastIndex: {
  <A>(value: A): (self: TArray<A>) => STM<Option<number>>;
  <A>(self: TArray<A>, value: A): STM<Option<number>>;
};

findLastIndexFrom

Added in v2.0.0 Source

Get the last index of a specific value in the array bounded above by a specific index.

Signature

declare const findLastIndexFrom: {
  <A>(value: A, end: number): (self: TArray<A>) => STM<Option<number>>;
  <A>(self: TArray<A>, value: A, end: number): STM<Option<number>>;
};

findLastSTM

Added in v2.0.0 Source

Find the last element in the array matching a transactional predicate.

Signature

declare const findLastSTM: {
  <A, R, E>(predicate: (value: A) => STM<boolean, E, R>): (self: TArray<A>) => STM<Option<A>, E, R>;
  <A, R, E>(self: TArray<A>, predicate: (value: A) => STM<boolean, E, R>): STM<Option<A>, E, R>;
};

forEach

Added in v2.0.0 Source

Atomically performs transactional effect for each item in array.

Signature

declare const forEach: {
  <A, R, E>(f: (value: A) => STM<void, E, R>): (self: TArray<A>) => STM<void, E, R>;
  <A, R, E>(self: TArray<A>, f: (value: A) => STM<void, E, R>): STM<void, E, R>;
};

get

Added in v2.0.0 Source

Extracts value from ref in array.

Signature

declare const get: {
  (index: number): <A>(self: TArray<A>) => STM<A>;
  <A>(self: TArray<A>, index: number): STM<A>;
};

headOption

Added in v2.0.0 Source

The first entry of the array, if it exists.

Signature

declare const headOption: <A>(self: TArray<A>) => STM.STM<Option.Option<A>>;

lastOption

Added in v2.0.0 Source

The last entry in the array, if it exists.

Signature

declare const lastOption: <A>(self: TArray<A>) => STM.STM<Option.Option<A>>;

maxOption

Added in v2.0.0 Source

Atomically compute the greatest element in the array, if it exists.

Signature

declare const maxOption: {
  <A>(order: Order<A>): (self: TArray<A>) => STM<Option<A>>;
  <A>(self: TArray<A>, order: Order<A>): STM<Option<A>>;
};

minOption

Added in v2.0.0 Source

Atomically compute the least element in the array, if it exists.

Signature

declare const minOption: {
  <A>(order: Order<A>): (self: TArray<A>) => STM<Option<A>>;
  <A>(self: TArray<A>, order: Order<A>): STM<Option<A>>;
};

reduceOption

Added in v2.0.0 Source

Atomically reduce the array, if non-empty, by a binary operator.

Signature

declare const reduceOption: {
  <A>(f: (x: A, y: A) => A): (self: TArray<A>) => STM<Option<A>>;
  <A>(self: TArray<A>, f: (x: A, y: A) => A): STM<Option<A>>;
};

reduceOptionSTM

Added in v2.0.0 Source

Atomically reduce the non-empty array using a transactional binary operator.

Signature

declare const reduceOptionSTM: {
  <A, R, E>(f: (x: A, y: A) => STM<A, E, R>): (self: TArray<A>) => STM<Option<A>, E, R>;
  <A, R, E>(self: TArray<A>, f: (x: A, y: A) => STM<A, E, R>): STM<Option<A>, E, R>;
};

some

Added in v2.0.0 Source

Determine if the array contains a value satisfying a predicate.

Signature

declare const some: {
  <A>(predicate: Predicate<A>): (self: TArray<A>) => STM<boolean>;
  <A>(self: TArray<A>, predicate: Predicate<A>): STM<boolean>;
};

someSTM

Added in v2.0.0 Source

Determine if the array contains a value satisfying a transactional predicate.

Signature

declare const someSTM: {
  <A, R, E>(predicate: (value: A) => STM<boolean, E, R>): (self: TArray<A>) => STM<boolean, E, R>;
  <A, R, E>(self: TArray<A>, predicate: (value: A) => STM<boolean, E, R>): STM<boolean, E, R>;
};

transform

Added in v2.0.0 Source

Atomically updates all elements using a pure function.

Signature

declare const transform: {
  <A>(f: (value: A) => A): (self: TArray<A>) => STM<void>;
  <A>(self: TArray<A>, f: (value: A) => A): STM<void>;
};

transformSTM

Added in v2.0.0 Source

Atomically updates all elements using a transactional effect.

Signature

declare const transformSTM: {
  <A, R, E>(f: (value: A) => STM<A, E, R>): (self: TArray<A>) => STM<void, E, R>;
  <A, R, E>(self: TArray<A>, f: (value: A) => STM<A, E, R>): STM<void, E, R>;
};

update

Added in v2.0.0 Source

Updates element in the array with given function.

Signature

declare const update: {
  <A>(index: number, f: (value: A) => A): (self: TArray<A>) => STM<void>;
  <A>(self: TArray<A>, index: number, f: (value: A) => A): STM<void>;
};

updateSTM

Added in v2.0.0 Source

Atomically updates element in the array with given transactional effect.

Signature

declare const updateSTM: {
  <A, R, E>(index: number, f: (value: A) => STM<A, E, R>): (self: TArray<A>) => STM<void, E, R>;
  <A, R, E>(self: TArray<A>, index: number, f: (value: A) => STM<A, E, R>): STM<void, E, R>;
};

Folding

count

Added in v2.0.0 Source

Count the values in the array matching a predicate.

Signature

declare const count: {
  <A>(predicate: Predicate<A>): (self: TArray<A>) => STM<number>;
  <A>(self: TArray<A>, predicate: Predicate<A>): STM<number>;
};

countSTM

Added in v2.0.0 Source

Count the values in the array matching a transactional predicate.

Signature

declare const countSTM: {
  <A, R, E>(predicate: (value: A) => STM<boolean, E, R>): (self: TArray<A>) => STM<number, E, R>;
  <A, R, E>(self: TArray<A>, predicate: (value: A) => STM<boolean, E, R>): STM<number, E, R>;
};

reduce

Added in v2.0.0 Source

Atomically folds using a pure function.

Signature

declare const reduce: {
  <Z, A>(zero: Z, f: (accumulator: Z, current: A) => Z): (self: TArray<A>) => STM<Z>;
  <Z, A>(self: TArray<A>, zero: Z, f: (accumulator: Z, current: A) => Z): STM<Z>;
};

reduceSTM

Added in v2.0.0 Source

Atomically folds using a transactional function.

Signature

declare const reduceSTM: {
  <Z, A, R, E>(
    zero: Z,
    f: (accumulator: Z, current: A) => STM<Z, E, R>,
  ): (self: TArray<A>) => STM<Z, E, R>;
  <Z, A, R, E>(
    self: TArray<A>,
    zero: Z,
    f: (accumulator: Z, current: A) => STM<Z, E, R>,
  ): STM<Z, E, R>;
};

Getters

size

Added in v2.0.0 Source

Returns the size of the TArray.

Signature

declare const size: <A>(self: TArray<A>) => number;

Models

TArray interface

Added in v2.0.0 Source

Signature

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

Other

TArray

Added in v2.0.0 Source

Symbols

TArrayTypeId

Added in v2.0.0 Source

Signature

declare const TArrayTypeId: unique symbol;

TArrayTypeId type

Added in v2.0.0 Source

Signature

type TArrayTypeId = typeof TArrayTypeId;