Skip to content
Effect 4.0 is here. One ecosystem. Zero dependencies.

Chunk

86 exports Since v2.0.0 Source

Combinators

forEach

Since v2.0.0

Iterates over each element of a Chunk and applies a function to it.

Details

This function processes every element of the given Chunk, calling the provided function f on each element. It does not return a new value; instead, it is primarily used for side effects, such as logging or accumulating data in an external variable.

Signature

declare const forEach: {
  <A, B>(f: (a: A, index: number) => B): (self: Chunk<A>) => void;
  <A, B>(self: Chunk<A>, f: (a: A, index: number) => B): void;
}

Concatenating

append

Since v2.0.0

Appends the specified element to the end of the Chunk.

Signature

declare const append: {
  <A2>(a: A2): <A>(self: Chunk<A>) => NonEmptyChunk<A2 | A>;
  <A, A2>(self: Chunk<A>, a: A2): NonEmptyChunk<A | A2>;
}

appendAll

Since v2.0.0

Concatenates two chunks, combining their elements. If either chunk is non-empty, the result is also a non-empty chunk.

Signature

declare const appendAll: {
  <S extends Chunk<any>, T extends Chunk<any>>(that: T): (self: S) => OrNonEmpty<S, T, Infer<S> | Infer<T>>;
  <A, B>(self: Chunk<A>, that: NonEmptyChunk<B>): NonEmptyChunk<A | B>;
  <A, B>(self: NonEmptyChunk<A>, that: Chunk<B>): NonEmptyChunk<A | B>;
  <A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<A | B>;
}

Example 

import { Chunk } from "effect"


const result = Chunk.make(1, 2).pipe(Chunk.appendAll(Chunk.make("a", "b")), Chunk.toArray)


console.log(result)
// [ 1, 2, "a", "b" ]

prepend

Since v2.0.0

Prepend an element to the front of a Chunk, creating a new NonEmptyChunk.

Signature

declare const prepend: {
  <B>(elem: B): <A>(self: Chunk<A>) => NonEmptyChunk<B | A>;
  <A, B>(self: Chunk<A>, elem: B): NonEmptyChunk<A | B>;
}

prependAll

Since v2.0.0

Prepends the specified prefix chunk to the beginning of the specified chunk. If either chunk is non-empty, the result is also a non-empty chunk.

Signature

declare const prependAll: {
  <S extends Chunk<any>, T extends Chunk<any>>(that: T): (self: S) => OrNonEmpty<S, T, Infer<S> | Infer<T>>;
  <A, B>(self: Chunk<A>, that: NonEmptyChunk<B>): NonEmptyChunk<A | B>;
  <A, B>(self: NonEmptyChunk<A>, that: Chunk<B>): NonEmptyChunk<A | B>;
  <A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<A | B>;
}

Example 

import { Chunk } from "effect"


const result = Chunk.make(1, 2).pipe(Chunk.prependAll(Chunk.make("a", "b")), Chunk.toArray)


console.log(result)
// [ "a", "b", 1, 2 ]

Constructors

empty

Since v2.0.0

Signature

declare const empty: <A = never>() => Chunk<A>

fromIterable

Since v2.0.0

Creates a new Chunk from an iterable collection of values.

Signature

declare function fromIterable<A>(self: Iterable<A>): Chunk<A>

isChunk

Since v2.0.0

Checks if u is a Chunk<unknown>

Signature

declare const isChunk: {
  <A>(u: Iterable<A>): u is Chunk<A>;
  (u: unknown): u is Chunk<unknown>;
}

make

Since v2.0.0

Builds a NonEmptyChunk from an non-empty collection of elements.

Signature

declare function make<As extends readonly [any, any]>(...as: As): NonEmptyChunk<As[number]>

makeBy

Since v2.0.0

Return a Chunk of length n with element i initialized with f(i).

Note. n is normalized to an integer >= 1.

Signature

declare const makeBy: {
  <A>(f: (i: number) => A): (n: number) => NonEmptyChunk<A>;
  <A>(n: number, f: (i: number) => A): NonEmptyChunk<A>;
}

of

Since v2.0.0

Builds a NonEmptyChunk from a single element.

Signature

declare function of<A>(a: A): NonEmptyChunk<A>

range

Since v2.0.0

Create a non empty Chunk containing a range of integers, including both endpoints.

Signature

declare function range(start: number, end: number): NonEmptyChunk<number>

Conversions

toArray

Since v2.0.0

Converts a Chunk into an Array. If the provided Chunk is non-empty (NonEmptyChunk), the function will return a NonEmptyArray, ensuring the non-empty property is preserved.

Signature

declare const toArray: <S extends Chunk<any>>(self: S) => S extends NonEmptyChunk<any> ? RA.NonEmptyArray<Chunk.Infer<S>> : Array<Chunk.Infer<S>>

toReadonlyArray

Since v2.0.0

Converts a Chunk into a ReadonlyArray. If the provided Chunk is non-empty (NonEmptyChunk), the function will return a NonEmptyReadonlyArray, ensuring the non-empty property is preserved.

Signature

declare const toReadonlyArray: <S extends Chunk<any>>(self: S) => S extends NonEmptyChunk<any> ? RA.NonEmptyReadonlyArray<Chunk.Infer<S>> : ReadonlyArray<Chunk.Infer<S>>

Elements

chunksOf

Since v2.0.0

Groups elements in chunks of up to n elements.

Signature

declare const chunksOf: {
  (n: number): <A>(self: Chunk<A>) => Chunk<Chunk<A>>;
  <A>(self: Chunk<A>, n: number): Chunk<Chunk<A>>;
}

contains

Since v2.0.0

Returns a function that checks if a Chunk contains a given value using the default Equivalence.

Signature

declare const contains: {
  <A>(a: A): (self: Chunk<A>) => boolean;
  <A>(self: Chunk<A>, a: A): boolean;
}

containsWith

Since v2.0.0

Returns a function that checks if a Chunk contains a given value using a provided isEquivalent function.

Signature

declare const containsWith: <A>(isEquivalent: (self: A, that: A) => boolean) => {
  (a: A): (self: Chunk<A>) => boolean;
  (self: Chunk<A>, a: A): boolean;
}

dedupe

Since v2.0.0

Remove duplicates from an array, keeping the first occurrence of an element.

Signature

declare function dedupe<A>(self: Chunk<A>): Chunk<A>

every

Since v2.0.0

Check if a predicate holds true for every Chunk element.

Signature

declare const every: {
  <A, B>(refinement: Refinement<NoInfer<A>, B>): (self: Chunk<A>) => self is Chunk<B>;
  <A>(predicate: Predicate<A>): (self: Chunk<A>) => boolean;
  <A, B>(self: Chunk<A>, refinement: Refinement<A, B>): self is Chunk<B>;
  <A>(self: Chunk<A>, predicate: Predicate<A>): boolean;
}

findFirst

Since v2.0.0

Returns the first element that satisfies the specified predicate, or None if no such element exists.

Signature

declare const findFirst: {
  <A, B>(refinement: Refinement<NoInfer<A>, B>): (self: Chunk<A>) => Option<B>;
  <A>(predicate: Predicate<NoInfer<A>>): (self: Chunk<A>) => Option<A>;
  <A, B>(self: Chunk<A>, refinement: Refinement<A, B>): Option<B>;
  <A>(self: Chunk<A>, predicate: Predicate<A>): Option<A>;
}

findFirstIndex

Since v2.0.0

Return the first index for which a predicate holds.

Signature

declare const findFirstIndex: {
  <A>(predicate: Predicate<A>): (self: Chunk<A>) => Option<number>;
  <A>(self: Chunk<A>, predicate: Predicate<A>): Option<number>;
}

findLast

Since v2.0.0

Find the last element for which a predicate holds.

Signature

declare const findLast: {
  <A, B>(refinement: Refinement<NoInfer<A>, B>): (self: Chunk<A>) => Option<B>;
  <A>(predicate: Predicate<NoInfer<A>>): (self: Chunk<A>) => Option<A>;
  <A, B>(self: Chunk<A>, refinement: Refinement<A, B>): Option<B>;
  <A>(self: Chunk<A>, predicate: Predicate<A>): Option<A>;
}

findLastIndex

Since v2.0.0

Return the last index for which a predicate holds.

Signature

declare const findLastIndex: {
  <A>(predicate: Predicate<A>): (self: Chunk<A>) => Option<number>;
  <A>(self: Chunk<A>, predicate: Predicate<A>): Option<number>;
}

get

Since v2.0.0

This function provides a safe way to read a value at a particular index from a Chunk.

Signature

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

headNonEmpty

Since v2.0.0

Returns the first element of this non empty chunk.

Signature

declare const headNonEmpty: <A>(self: NonEmptyChunk<A>) => A

intersection

Since v2.0.0

Creates a Chunk of unique values that are included in all given Chunks.

The order and references of result values are determined by the Chunk.

Signature

declare const intersection: {
  <A>(that: Chunk<A>): <B>(self: Chunk<B>) => Chunk<A & B>;
  <A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<A & B>;
}

isEmpty

Since v2.0.0

Determines if the chunk is empty.

Signature

declare function isEmpty<A>(self: Chunk<A>): boolean

isNonEmpty

Since v2.0.0

Determines if the chunk is not empty.

Signature

declare function isNonEmpty<A>(self: Chunk<A>): self is NonEmptyChunk<A>

last

Since v2.0.0

Returns the last element of this chunk if it exists.

Signature

declare function last<A>(self: Chunk<A>): Option<A>

lastNonEmpty

Since v3.4.0

Returns the last element of this non empty chunk.

Signature

declare const lastNonEmpty: <A>(self: NonEmptyChunk<A>) => A

reverse

Since v2.0.0

Reverses the order of elements in a Chunk. Importantly, if the input chunk is a NonEmptyChunk, the reversed chunk will also be a NonEmptyChunk.

Signature

declare const reverse: <S extends Chunk<any>>(self: S) => Chunk.With<S, Chunk.Infer<S>>

Example 

import { Chunk } from "effect"


const chunk = Chunk.make(1, 2, 3)
const result = Chunk.reverse(chunk)


console.log(result)
// { _id: 'Chunk', values: [ 3, 2, 1 ] }

size

Since v2.0.0

Retireves the size of the chunk

Signature

declare function size<A>(self: Chunk<A>): number

some

Since v2.0.0

Check if a predicate holds true for some Chunk element.

Signature

declare const some: {
  <A>(predicate: Predicate<NoInfer<A>>): (self: Chunk<A>) => self is NonEmptyChunk<A>;
  <A>(self: Chunk<A>, predicate: Predicate<A>): self is NonEmptyChunk<A>;
}

tail

Since v2.0.0

Returns every elements after the first.

Signature

declare function tail<A>(self: Chunk<A>): Option<Chunk<A>>

tailNonEmpty

Since v2.0.0

Returns every elements after the first.

Signature

declare function tailNonEmpty<A>(self: NonEmptyChunk<A>): Chunk<A>

takeRight

Since v2.0.0

Takes the last n elements.

Signature

declare const takeRight: {
  (n: number): <A>(self: Chunk<A>) => Chunk<A>;
  <A>(self: Chunk<A>, n: number): Chunk<A>;
}

takeWhile

Since v2.0.0

Takes all elements so long as the predicate returns true.

Signature

declare const takeWhile: {
  <A, B>(refinement: Refinement<NoInfer<A>, B>): (self: Chunk<A>) => Chunk<B>;
  <A>(predicate: Predicate<NoInfer<A>>): (self: Chunk<A>) => Chunk<A>;
  <A, B>(self: Chunk<A>, refinement: Refinement<A, B>): Chunk<B>;
  <A>(self: Chunk<A>, predicate: Predicate<A>): Chunk<A>;
}

union

Since v2.0.0

Creates a Chunks of unique values, in order, from all given Chunks.

Signature

declare const union: {
  <A>(that: Chunk<A>): <B>(self: Chunk<B>) => Chunk<A | B>;
  <A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<A | B>;
}

unzip

Since v2.0.0

Takes a Chunk of pairs and return two corresponding Chunks.

Note: The function is reverse of zip.

Signature

declare function unzip<A, B>(self: Chunk<readonly [A, B]>): [Chunk<A>, Chunk<B>]

Equivalence

getEquivalence

Since v2.0.0

Compares the two chunks of equal length using the specified function

Signature

declare function getEquivalence<A>(isEquivalent: Equivalence<A>): Equivalence<Chunk<A>>

Filtering

compact

Since v2.0.0

Filter out optional values

Signature

declare function compact<A>(self: Chunk<Option<A>>): Chunk<A>

dedupeAdjacent

Since v2.0.0

Deduplicates adjacent elements that are identical.

Signature

declare function dedupeAdjacent<A>(self: Chunk<A>): Chunk<A>

filter

Since v2.0.0

Returns a filtered and mapped subset of the elements.

Signature

declare const filter: {
  <A, B>(refinement: Refinement<NoInfer<A>, B>): (self: Chunk<A>) => Chunk<B>;
  <A>(predicate: Predicate<NoInfer<A>>): (self: Chunk<A>) => Chunk<A>;
  <A, B>(self: Chunk<A>, refinement: Refinement<A, B>): Chunk<B>;
  <A>(self: Chunk<A>, predicate: Predicate<A>): Chunk<A>;
}

filterMap

Since v2.0.0

Returns a filtered and mapped subset of the elements.

Signature

declare const filterMap: {
  <A, B>(f: (a: A, i: number) => Option<B>): (self: Chunk<A>) => Chunk<B>;
  <A, B>(self: Chunk<A>, f: (a: A, i: number) => Option<B>): Chunk<B>;
}

filterMapWhile

Since v2.0.0

Transforms all elements of the chunk for as long as the specified function returns some value

Signature

declare const filterMapWhile: {
  <A, B>(f: (a: A) => Option<B>): (self: Chunk<A>) => Chunk<B>;
  <A, B>(self: Chunk<A>, f: (a: A) => Option<B>): Chunk<B>;
}

partition

Since v2.0.0

Separate elements based on a predicate that also exposes the index of the element.

Signature

declare const partition: {
  <A, B>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: Chunk<A>) => [excluded: Chunk<Exclude<A, B>>, satisfying: Chunk<B>];
  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Chunk<A>) => [excluded: Chunk<A>, satisfying: Chunk<A>];
  <A, B>(self: Chunk<A>, refinement: (a: A, i: number) => a is B): [excluded: Chunk<Exclude<A, B>>, satisfying: Chunk<B>];
  <A>(self: Chunk<A>, predicate: (a: A, i: number) => boolean): [excluded: Chunk<A>, satisfying: Chunk<A>];
}

partitionMap

Since v2.0.0

Partitions the elements of this chunk into two chunks using f.

Signature

declare const partitionMap: {
  <A, B, C>(f: (a: A) => Either<C, B>): (self: Chunk<A>) => [left: Chunk<B>, right: Chunk<C>];
  <A, B, C>(self: Chunk<A>, f: (a: A) => Either<C, B>): [left: Chunk<B>, right: Chunk<C>];
}

separate

Since v2.0.0

Partitions the elements of this chunk into two chunks.

Signature

declare function separate<A, B>(self: Chunk<Either<B, A>>): [Chunk<A>, Chunk<B>]

Folding

join

Since v2.0.0

Joins the elements together with "sep" in the middle.

Signature

declare const join: {
  (sep: string): (self: Chunk<string>) => string;
  (self: Chunk<string>, sep: string): string;
}

mapAccum

Since v2.0.0

Statefully maps over the chunk, producing new elements of type B.

Signature

declare const mapAccum: {
  <S, A, B>(s: S, f: (s: S, a: A) => readonly [S, B]): (self: Chunk<A>) => [S, Chunk<B>];
  <S, A, B>(self: Chunk<A>, s: S, f: (s: S, a: A) => readonly [S, B]): [S, Chunk<B>];
}

reduce

Since v2.0.0

Signature

declare const reduce: {
  <B, A>(b: B, f: (b: B, a: A, i: number) => B): (self: Chunk<A>) => B;
  <A, B>(self: Chunk<A>, b: B, f: (b: B, a: A, i: number) => B): B;
}

reduceRight

Since v2.0.0

Signature

declare const reduceRight: {
  <B, A>(b: B, f: (b: B, a: A, i: number) => B): (self: Chunk<A>) => B;
  <A, B>(self: Chunk<A>, b: B, f: (b: B, a: A, i: number) => B): B;
}

Mapping

map

Since v2.0.0

Transforms the elements of a chunk using the specified mapping function. If the input chunk is non-empty, the resulting chunk will also be non-empty.

Signature

declare const map: {
  <S extends Chunk<any>, B>(f: (a: Infer<S>, i: number) => B): (self: S) => With<S, B>;
  <A, B>(self: NonEmptyChunk<A>, f: (a: A, i: number) => B): NonEmptyChunk<B>;
  <A, B>(self: Chunk<A>, f: (a: A, i: number) => B): Chunk<B>;
}

Example 

import { Chunk } from "effect"


const result = Chunk.map(Chunk.make(1, 2), (n) => n + 1)


console.log(result)
// { _id: 'Chunk', values: [ 2, 3 ] }

Model

NonEmptyChunk

interface
Since v2.0.0

Signature

interface NonEmptyChunk<out A> extends Chunk<A>, NonEmptyIterable<A> {}

Models

Chunk

interface
Since v2.0.0

Signature

interface Chunk<out A> extends Iterable<A>, Equal, Pipeable, Inspectable {
  readonly [TypeId]: {
    readonly _A: Covariant<A>;
  };
  readonly length: number;
}

Other

Chunk

Since v2.0.0

difference

Since v3.2.0

Creates a Chunk of values not included in the other given Chunk. The order and references of result values are determined by the first Chunk.

Signature

declare const difference: {
  <A>(that: Chunk<A>): (self: Chunk<A>) => Chunk<A>;
  <A>(self: Chunk<A>, that: Chunk<A>): Chunk<A>;
}

differenceWith

Since v3.2.0

Creates a Chunk of values not included in the other given Chunk using the provided isEquivalent function. The order and references of result values are determined by the first Chunk.

Signature

declare function differenceWith<A>(isEquivalent: (self: A, that: A) => boolean): {
  (that: Chunk<A>): (self: Chunk<A>) => Chunk<A>;
  (self: Chunk<A>, that: Chunk<A>): Chunk<A>;
}

drop

Since v2.0.0

Drops the first up to n elements from the chunk

Signature

declare const drop: {
  (n: number): <A>(self: Chunk<A>) => Chunk<A>;
  <A>(self: Chunk<A>, n: number): Chunk<A>;
}

dropRight

Since v2.0.0

Drops the last n elements.

Signature

declare const dropRight: {
  (n: number): <A>(self: Chunk<A>) => Chunk<A>;
  <A>(self: Chunk<A>, n: number): Chunk<A>;
}

dropWhile

Since v2.0.0

Drops all elements so long as the predicate returns true.

Signature

declare const dropWhile: {
  <A>(predicate: Predicate<NoInfer<A>>): (self: Chunk<A>) => Chunk<A>;
  <A>(self: Chunk<A>, predicate: Predicate<A>): Chunk<A>;
}

modify

Since v2.0.0

Apply a function to the element at the specified index, creating a new Chunk, or returning the input if the index is out of bounds.

Signature

declare const modify: {
  <A, B>(i: number, f: (a: A) => B): (self: Chunk<A>) => Chunk<A | B>;
  <A, B>(self: Chunk<A>, i: number, f: (a: A) => B): Chunk<A | B>;
}

modifyOption

Since v2.0.0

Signature

declare const modifyOption: {
  <A, B>(i: number, f: (a: A) => B): (self: Chunk<A>) => Option<Chunk<A | B>>;
  <A, B>(self: Chunk<A>, i: number, f: (a: A) => B): Option<Chunk<A | B>>;
}

remove

Since v2.0.0

Delete the element at the specified index, creating a new Chunk.

Signature

declare const remove: {
  (i: number): <A>(self: Chunk<A>) => Chunk<A>;
  <A>(self: Chunk<A>, i: number): Chunk<A>;
}

removeOption

Since v3.16.0

Signature

declare const removeOption: {
  (i: number): <A>(self: Chunk<A>) => Option<Chunk<A>>;
  <A>(self: Chunk<A>, i: number): Option<Chunk<A>>;
}

replace

Since v2.0.0

Change the element at the specified index, creating a new Chunk, or returning the input if the index is out of bounds.

Signature

declare const replace: {
  <B>(i: number, b: B): <A>(self: Chunk<A>) => Chunk<B | A>;
  <A, B>(self: Chunk<A>, i: number, b: B): Chunk<A | B>;
}

replaceOption

Since v2.0.0

Signature

declare const replaceOption: {
  <B>(i: number, b: B): <A>(self: Chunk<A>) => Option<Chunk<B | A>>;
  <A, B>(self: Chunk<A>, i: number, b: B): Option<Chunk<A | B>>;
}

take

Since v2.0.0

Takes the first up to n elements from the chunk

Signature

declare const take: {
  (n: number): <A>(self: Chunk<A>) => Chunk<A>;
  <A>(self: Chunk<A>, n: number): Chunk<A>;
}

Sequencing

flatMap

Since v2.0.0

Applies a function to each element in a chunk and returns a new chunk containing the concatenated mapped elements.

Signature

declare const flatMap: {
  <S extends Chunk<any>, T extends Chunk<any>>(f: (a: Infer<S>, i: number) => T): (self: S) => AndNonEmpty<S, T, Infer<T>>;
  <A, B>(self: NonEmptyChunk<A>, f: (a: A, i: number) => NonEmptyChunk<B>): NonEmptyChunk<B>;
  <A, B>(self: Chunk<A>, f: (a: A, i: number) => Chunk<B>): Chunk<B>;
}

flatten

Since v2.0.0

Flattens a chunk of chunks into a single chunk by concatenating all chunks.

Signature

declare const flatten: <S extends Chunk<Chunk<any>>>(self: S) => Chunk.Flatten<S>

Sorting

sort

Since v2.0.0

Sort the elements of a Chunk in increasing order, creating a new Chunk.

Signature

declare const sort: {
  <B>(O: Order<B>): <A>(self: Chunk<A>) => Chunk<A>;
  <A, B>(self: Chunk<A>, O: Order<B>): Chunk<A>;
}

sortWith

Since v2.0.0

Signature

declare const sortWith: {
  <A, B>(f: (a: A) => B, order: Order<B>): (self: Chunk<A>) => Chunk<A>;
  <A, B>(self: Chunk<A>, f: (a: A) => B, order: Order<B>): Chunk<A>;
}

Splitting

split

Since v2.0.0

Splits this chunk into n equally sized chunks.

Signature

declare const split: {
  (n: number): <A>(self: Chunk<A>) => Chunk<Chunk<A>>;
  <A>(self: Chunk<A>, n: number): Chunk<Chunk<A>>;
}

splitAt

Since v2.0.0

Returns two splits of this chunk at the specified index.

Signature

declare const splitAt: {
  (n: number): <A>(self: Chunk<A>) => [beforeIndex: Chunk<A>, fromIndex: Chunk<A>];
  <A>(self: Chunk<A>, n: number): [beforeIndex: Chunk<A>, fromIndex: Chunk<A>];
}

splitNonEmptyAt

Since v2.0.0

Splits a NonEmptyChunk into two segments, with the first segment containing a maximum of n elements. The value of n must be >= 1.

Signature

declare const splitNonEmptyAt: {
  (n: number): <A>(self: NonEmptyChunk<A>) => [beforeIndex: NonEmptyChunk<A>, fromIndex: Chunk<A>];
  <A>(self: NonEmptyChunk<A>, n: number): [beforeIndex: NonEmptyChunk<A>, fromIndex: Chunk<A>];
}

splitWhere

Since v2.0.0

Splits this chunk on the first element that matches this predicate. Returns a tuple containing two chunks: the first one is before the match, and the second one is from the match onward.

Signature

declare const splitWhere: {
  <A>(predicate: Predicate<NoInfer<A>>): (self: Chunk<A>) => [beforeMatch: Chunk<A>, fromMatch: Chunk<A>];
  <A>(self: Chunk<A>, predicate: Predicate<A>): [beforeMatch: Chunk<A>, fromMatch: Chunk<A>];
}

Symbol

TypeId

type
Since v2.0.0

Signature

type TypeId = typeof TypeId

Type Lambdas

ChunkTypeLambda

interface
Since v2.0.0

Signature

interface ChunkTypeLambda extends TypeLambda {
  readonly type: Chunk<unknown>;
}

Unsafe

unsafeFromArray

Since v2.0.0

Wraps an array into a chunk without copying, unsafe on mutable arrays

Signature

declare function unsafeFromArray<A>(self: readonly Array<A>): Chunk<A>

unsafeFromNonEmptyArray

Since v2.0.0

Wraps an array into a chunk without copying, unsafe on mutable arrays

Signature

declare function unsafeFromNonEmptyArray<A>(self: readonly [A, A]): NonEmptyChunk<A>

unsafeGet

Since v2.0.0

Gets an element unsafely, will throw on out of bounds

Signature

declare const unsafeGet: {
  (index: number): <A>(self: Chunk<A>) => A;
  <A>(self: Chunk<A>, index: number): A;
}

unsafeHead

Since v2.0.0

Returns the first element of this chunk.

It will throw an error if the chunk is empty.

Signature

declare function unsafeHead<A>(self: Chunk<A>): A

unsafeLast

Since v2.0.0

Returns the last element of this chunk.

It will throw an error if the chunk is empty.

Signature

declare function unsafeLast<A>(self: Chunk<A>): A

Zipping

zip

Since v2.0.0

Zips this chunk pointwise with the specified chunk.

Signature

declare const zip: {
  <B>(that: Chunk<B>): <A>(self: Chunk<A>) => Chunk<[A, B]>;
  <A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<[A, B]>;
}

zipWith

Since v2.0.0

Zips this chunk pointwise with the specified chunk using the specified combiner.

Signature

declare const zipWith: {
  <A, B, C>(that: Chunk<B>, f: (a: A, b: B) => C): (self: Chunk<A>) => Chunk<C>;
  <A, B, C>(self: Chunk<A>, that: Chunk<B>, f: (a: A, b: B) => C): Chunk<C>;
}