Skip to main content Link Search Menu Expand Document (external link)
effect

Chunk.ts overview

Since v2.0.0

Exports Grouped by Category

combinators

forEach

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
}

Source

Since v2.0.0

concatenating

append

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

Source

Since v2.0.0

appendAll

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

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" ]

Signature

declare const appendAll: {
  <S extends Chunk<any>, T extends Chunk<any>>(
    that: T
  ): (self: S) => Chunk.OrNonEmpty<S, T, Chunk.Infer<S> | Chunk.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>
}

Source

Since v2.0.0

prepend

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

Source

Since v2.0.0

prependAll

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.

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 ]

Signature

declare const prependAll: {
  <S extends Chunk<any>, T extends Chunk<any>>(
    that: T
  ): (self: S) => Chunk.OrNonEmpty<S, T, Chunk.Infer<S> | Chunk.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>
}

Source

Since v2.0.0

constructors

empty

Signature

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

Source

Since v2.0.0

fromIterable

Creates a new Chunk from an iterable collection of values.

Signature

declare const fromIterable: <A>(self: Iterable<A>) => Chunk<A>

Source

Since v2.0.0

isChunk

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

Source

Since v2.0.0

make

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

Signature

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

Source

Since v2.0.0

makeBy

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

Source

Since v2.0.0

of

Builds a NonEmptyChunk from a single element.

Signature

declare const of: <A>(a: A) => NonEmptyChunk<A>

Source

Since v2.0.0

range

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

Signature

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

Source

Since v2.0.0

conversions

toArray

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

Source

Since v2.0.0

toReadonlyArray

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

Source

Since v2.0.0

elements

chunksOf

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

Source

Since v2.0.0

contains

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 }

Source

Since v2.0.0

containsWith

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
}

Source

Since v2.0.0

dedupe

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

Signature

declare const dedupe: <A>(self: Chunk<A>) => Chunk<A>

Source

Since v2.0.0

every

Check if a predicate holds true for every Chunk element.

Signature

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

Source

Since v2.0.0

findFirst

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

Signature

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

Source

Since v2.0.0

findFirstIndex

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

Source

Since v2.0.0

findLast

Find the last element for which a predicate holds.

Signature

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

Source

Since v2.0.0

findLastIndex

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

Source

Since v2.0.0

get

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

Source

Since v2.0.0

Returns the first element of this chunk if it exists.

Signature

declare const head: <A>(self: Chunk<A>) => Option<A>

Source

Since v2.0.0

headNonEmpty

Returns the first element of this non empty chunk.

Signature

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

Source

Since v2.0.0

intersection

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

Source

Since v2.0.0

isEmpty

Determines if the chunk is empty.

Signature

declare const isEmpty: <A>(self: Chunk<A>) => boolean

Source

Since v2.0.0

isNonEmpty

Determines if the chunk is not empty.

Signature

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

Source

Since v2.0.0

last

Returns the last element of this chunk if it exists.

Signature

declare const last: <A>(self: Chunk<A>) => Option<A>

Source

Since v2.0.0

lastNonEmpty

Returns the last element of this non empty chunk.

Signature

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

Source

Since v3.4.0

reverse

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

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

Signature

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

Source

Since v2.0.0

size

Retireves the size of the chunk

Signature

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

Source

Since v2.0.0

some

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

Source

Since v2.0.0

tail

Returns every elements after the first.

Signature

declare const tail: <A>(self: Chunk<A>) => Option<Chunk<A>>

Source

Since v2.0.0

tailNonEmpty

Returns every elements after the first.

Signature

declare const tailNonEmpty: <A>(self: NonEmptyChunk<A>) => Chunk<A>

Source

Since v2.0.0

takeRight

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

Source

Since v2.0.0

takeWhile

Takes all elements so long as the predicate returns true.

Signature

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

Source

Since v2.0.0

union

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

Source

Since v2.0.0

unzip

Takes a Chunk of pairs and return two corresponding Chunks.

Note: The function is reverse of zip.

Signature

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

Source

Since v2.0.0

equivalence

getEquivalence

Compares the two chunks of equal length using the specified function

Signature

declare const getEquivalence: <A>(isEquivalent: Equivalence.Equivalence<A>) => Equivalence.Equivalence<Chunk<A>>

Source

Since v2.0.0

filtering

compact

Filter out optional values

Signature

declare const compact: <A>(self: Chunk<Option<A>>) => Chunk<A>

Source

Since v2.0.0

dedupeAdjacent

Deduplicates adjacent elements that are identical.

Signature

declare const dedupeAdjacent: <A>(self: Chunk<A>) => Chunk<A>

Source

Since v2.0.0

filter

Returns a filtered and mapped subset of the elements.

Signature

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

Source

Since v2.0.0

filterMap

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

Source

Since v2.0.0

filterMapWhile

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

Source

Since v2.0.0

partition

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

Signature

declare const partition: {
  <A, B extends A>(
    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 extends A>(
    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>]
}

Source

Since v2.0.0

partitionMap

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

Source

Since v2.0.0

separate

Partitions the elements of this chunk into two chunks.

Signature

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

Source

Since v2.0.0

folding

join

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 }

Source

Since v2.0.0

mapAccum

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

Source

Since v2.0.0

reduce

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
}

Source

Since v2.0.0

reduceRight

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
}

Source

Since v2.0.0

mapping

map

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.

Example

import { Chunk } from "effect"

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

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

Signature

declare const map: {
  <S extends Chunk<any>, B>(f: (a: Chunk.Infer<S>, i: number) => B): (self: S) => Chunk.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>
}

Source

Since v2.0.0

model

NonEmptyChunk (interface)

Signature

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

Source

Since v2.0.0

models

Chunk (interface)

Signature

export interface Chunk<out A> extends Iterable<A>, Equal.Equal, Pipeable, Inspectable {
  readonly [TypeId]: {
    readonly _A: Covariant<A>
  }
  readonly length: number
  /** @internal */
  right: Chunk<A>
  /** @internal */
  left: Chunk<A>
  /** @internal */
  backing: Backing<A>
  /** @internal */
  depth: number
}

Source

Since v2.0.0

sequencing

flatMap

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: Chunk.Infer<S>, i: number) => T
  ): (self: S) => Chunk.AndNonEmpty<S, T, Chunk.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>
}

Source

Since v2.0.0

flatten

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>

Source

Since v2.0.0

sorting

sort

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

Signature

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

Source

Since v2.0.0

sortWith

Signature

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

Source

Since v2.0.0

splitting

split

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

Source

Since v2.0.0

splitAt

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

Source

Since v2.0.0

splitNonEmptyAt

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

Source

Since v2.0.0

splitWhere

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

Source

Since v2.0.0

symbol

TypeId (type alias)

Signature

type TypeId = typeof TypeId

Source

Since v2.0.0

type lambdas

ChunkTypeLambda (interface)

Signature

export interface ChunkTypeLambda extends TypeLambda {
  readonly type: Chunk<this["Target"]>
}

Source

Since v2.0.0

unsafe

unsafeFromArray

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

Signature

declare const unsafeFromArray: <A>(self: ReadonlyArray<A>) => Chunk<A>

Source

Since v2.0.0

unsafeFromNonEmptyArray

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

Signature

declare const unsafeFromNonEmptyArray: <A>(self: NonEmptyReadonlyArray<A>) => NonEmptyChunk<A>

Source

Since v2.0.0

unsafeGet

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 }

Source

Since v2.0.0

unsafeHead

Returns the first element of this chunk.

It will throw an error if the chunk is empty.

Signature

declare const unsafeHead: <A>(self: Chunk<A>) => A

Source

Since v2.0.0

unsafeLast

Returns the last element of this chunk.

It will throw an error if the chunk is empty.

Signature

declare const unsafeLast: <A>(self: Chunk<A>) => A

Source

Since v2.0.0

utils

Chunk (namespace)

Source

Since v2.0.0

Infer (type alias)

Signature

type Infer<S> = S extends Chunk<infer A> ? A : never

Source

Since v2.0.0

With (type alias)

Signature

type With<S, A> = S extends NonEmptyChunk<any> ? NonEmptyChunk<A> : Chunk<A>

Source

Since v2.0.0

OrNonEmpty (type alias)

Signature

type OrNonEmpty<S, T, A> =
  S extends NonEmptyChunk<any> ? NonEmptyChunk<A> : T extends NonEmptyChunk<any> ? NonEmptyChunk<A> : Chunk<A>

Source

Since v2.0.0

AndNonEmpty (type alias)

Signature

type AndNonEmpty<S, T, A> =
  S extends NonEmptyChunk<any> ? (T extends NonEmptyChunk<any> ? NonEmptyChunk<A> : Chunk<A>) : Chunk<A>

Source

Since v2.0.0

Flatten (type alias)

Signature

type Flatten<T> =
  T extends NonEmptyChunk<NonEmptyChunk<infer A>>
    ? NonEmptyChunk<A>
    : T extends Chunk<Chunk<infer A>>
      ? Chunk<A>
      : never

Source

Since v2.0.0

difference

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

Source

Since v3.2.0

differenceWith

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 const differenceWith: <A>(isEquivalent: (self: A, that: A) => boolean) => {
  (that: Chunk<A>): (self: Chunk<A>) => Chunk<A>
  (self: Chunk<A>, that: Chunk<A>): Chunk<A>
}

Source

Since v3.2.0

drop

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

Source

Since v2.0.0

dropRight

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

Source

Since v2.0.0

dropWhile

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

Source

Since v2.0.0

modify

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

Source

Since v2.0.0

modifyOption

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

Source

Since v2.0.0

remove

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

Source

Since v2.0.0

replace

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<B | A>
}

Source

Since v2.0.0

replaceOption

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<B | A>>
}

Source

Since v2.0.0

take

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

Source

Since v2.0.0

zipping

zip

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

Source

Since v2.0.0

zipWith

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

Source

Since v2.0.0