<AR, ER, RR, AL, A>(
right: Stream<AR, ER, RR>,
f: (
left: Arr.NonEmptyReadonlyArray<AL>,
right: Arr.NonEmptyReadonlyArray<AR>
) => readonly [
output: Arr.NonEmptyReadonlyArray<A>,
leftoverLeft: ReadonlyArray<AL>,
leftoverRight: ReadonlyArray<AR>
]
): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>
<AL, EL, RL, AR, ER, RR, A>(
left: Stream<AL, EL, RL>,
right: Stream<AR, ER, RR>,
f: (
left: Arr.NonEmptyReadonlyArray<AL>,
right: Arr.NonEmptyReadonlyArray<AR>
) => readonly [
output: Arr.NonEmptyReadonlyArray<A>,
leftoverLeft: ReadonlyArray<AL>,
leftoverRight: ReadonlyArray<AR>
]
): Stream<A, EL | ER, RL | RR>Zips two streams by applying a function to non-empty arrays of elements.
Details
The function returns output plus leftover arrays that carry into the next pull.
Example (Zipping stream chunks)
import { Array, Console, Effect, Stream } from "effect"
const left = Stream.fromArrays([1, 2, 3], [4, 5])
const right = Stream.fromArrays(["a", "b"], ["c", "d", "e"])
const zipped = Stream.zipWithArray(left, right, (leftChunk, rightChunk) => {
const minLength = Math.min(leftChunk.length, rightChunk.length)
const output = Array.makeBy(minLength, (i) => [leftChunk[i], rightChunk[i]] as const)
return [output, leftChunk.slice(minLength), rightChunk.slice(minLength)]
})
const program = Effect.gen(function*() {
const result = yield* Stream.runCollect(zipped)
yield* Console.log(result)
})
Effect.runPromise(program)
// Output: [[1, "a"], [2, "b"], [3, "c"], [4, "d"], [5, "e"]]zipping
Source effect/Stream.ts:358177 lines
export const const zipWithArray: {
<AR, ER, RR, AL, A>(
right: Stream<AR, ER, RR>,
f: (
left: Arr.NonEmptyReadonlyArray<AL>,
right: Arr.NonEmptyReadonlyArray<AR>
) => readonly [
output: Arr.NonEmptyReadonlyArray<A>,
leftoverLeft: ReadonlyArray<AL>,
leftoverRight: ReadonlyArray<AR>
]
): <EL, RL>(
left: Stream<AL, EL, RL>
) => Stream<A, EL | ER, RL | RR>
<AL, EL, RL, AR, ER, RR, A>(
left: Stream<AL, EL, RL>,
right: Stream<AR, ER, RR>,
f: (
left: Arr.NonEmptyReadonlyArray<AL>,
right: Arr.NonEmptyReadonlyArray<AR>
) => readonly [
output: Arr.NonEmptyReadonlyArray<A>,
leftoverLeft: ReadonlyArray<AL>,
leftoverRight: ReadonlyArray<AR>
]
): Stream<A, EL | ER, RL | RR>
}
Zips two streams by applying a function to non-empty arrays of elements.
Details
The function returns output plus leftover arrays that carry into the next pull.
Example (Zipping stream chunks)
import { Array, Console, Effect, Stream } from "effect"
const left = Stream.fromArrays([1, 2, 3], [4, 5])
const right = Stream.fromArrays(["a", "b"], ["c", "d", "e"])
const zipped = Stream.zipWithArray(left, right, (leftChunk, rightChunk) => {
const minLength = Math.min(leftChunk.length, rightChunk.length)
const output = Array.makeBy(minLength, (i) => [leftChunk[i], rightChunk[i]] as const)
return [output, leftChunk.slice(minLength), rightChunk.slice(minLength)]
})
const program = Effect.gen(function*() {
const result = yield* Stream.runCollect(zipped)
yield* Console.log(result)
})
Effect.runPromise(program)
// Output: [[1, "a"], [2, "b"], [3, "c"], [4, "d"], [5, "e"]]
zipWithArray: {
<function (type parameter) AR in <AR, ER, RR, AL, A>(right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>AR, function (type parameter) ER in <AR, ER, RR, AL, A>(right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>ER, function (type parameter) RR in <AR, ER, RR, AL, A>(right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>RR, function (type parameter) AL in <AR, ER, RR, AL, A>(right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>AL, function (type parameter) A in <AR, ER, RR, AL, A>(right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>A>(
right: Stream<AR, ER, RR>(parameter) right: {
channel: Channel.Channel<Arr.NonEmptyReadonlyArray<A>, E, void, unknown, unknown, unknown, R>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
interface Stream<out A, out E = never, out R = never>A Stream<A, E, R> describes a program that can emit many A values, fail
with E, and require R.
Details
Streams are pull-based with backpressure and emit chunks to amortize effect
evaluation. They support monadic composition and error handling similar to
Effect, adapted for multiple values.
Example (Creating and consuming streams)
import { Console, Effect, Stream } from "effect"
const program = Effect.gen(function*() {
yield* Stream.make(1, 2, 3).pipe(
Stream.map((n) => n * 2),
Stream.runForEach((n) => Console.log(n))
)
})
Effect.runPromise(program)
// Output:
// 2
// 4
// 6
Stream<function (type parameter) AR in <AR, ER, RR, AL, A>(right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>AR, function (type parameter) ER in <AR, ER, RR, AL, A>(right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>ER, function (type parameter) RR in <AR, ER, RR, AL, A>(right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>RR>,
f: (
left: Arr.NonEmptyReadonlyArray<AL>,
right: Arr.NonEmptyReadonlyArray<AR>
) => readonly [
output: Arr.NonEmptyReadonlyArray<A>,
leftoverLeft: ReadonlyArray<AL>,
leftoverRight: ReadonlyArray<AR>
]
left: Arr.NonEmptyReadonlyArray<AL>(parameter) left: {
0: AL;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<AL>>): Array<AL>; (...items: Array<AL | ConcatArray<AL>>): Array<AL> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<AL>;
indexOf: (searchElement: AL, fromIndex?: number) => number;
lastIndexOf: (searchElement: AL, fromIndex?: number) => number;
every: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: AL, index: number, array: ReadonlyArray<AL>) => void, thisArg?: any) => void;
map: (callbackfn: (value: AL, index: number, array: ReadonlyArray<AL>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): Array<S>; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): Array<AL> };
reduce: { (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL): AL; (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL, initialValue: AL): A…;
reduceRight: { (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL): AL; (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL, initialValue: AL): A…;
find: { (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => unknown, thisArg?: any): AL | undefined };
findIndex: (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, AL]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<AL>;
includes: (searchElement: AL, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: AL, index: number, array: Array<AL>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => AL | undefined;
findLast: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): AL | undefined };
findLastIndex: (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any) => number;
toReversed: () => Array<AL>;
toSorted: (compareFn?: ((a: AL, b: AL) => number) | undefined) => Array<AL>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<AL>): Array<AL>; (start: number, deleteCount?: number): Array<AL> };
with: (index: number, value: AL) => Array<AL>;
}
import ArrArr.type Arr.NonEmptyReadonlyArray = /*unresolved*/ anyNonEmptyReadonlyArray<function (type parameter) AL in <AR, ER, RR, AL, A>(right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>AL>,
right: Arr.NonEmptyReadonlyArray<AR>(parameter) right: {
0: AR;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<AR>>): Array<AR>; (...items: Array<AR | ConcatArray<AR>>): Array<AR> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<AR>;
indexOf: (searchElement: AR, fromIndex?: number) => number;
lastIndexOf: (searchElement: AR, fromIndex?: number) => number;
every: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: AR, index: number, array: ReadonlyArray<AR>) => void, thisArg?: any) => void;
map: (callbackfn: (value: AR, index: number, array: ReadonlyArray<AR>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): Array<S>; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): Array<AR> };
reduce: { (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR): AR; (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR, initialValue: AR): A…;
reduceRight: { (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR): AR; (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR, initialValue: AR): A…;
find: { (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => unknown, thisArg?: any): AR | undefined };
findIndex: (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, AR]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<AR>;
includes: (searchElement: AR, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: AR, index: number, array: Array<AR>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => AR | undefined;
findLast: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): AR | undefined };
findLastIndex: (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any) => number;
toReversed: () => Array<AR>;
toSorted: (compareFn?: ((a: AR, b: AR) => number) | undefined) => Array<AR>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<AR>): Array<AR>; (start: number, deleteCount?: number): Array<AR> };
with: (index: number, value: AR) => Array<AR>;
}
import ArrArr.type Arr.NonEmptyReadonlyArray = /*unresolved*/ anyNonEmptyReadonlyArray<function (type parameter) AR in <AR, ER, RR, AL, A>(right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>AR>
) => readonly [
Arr.NonEmptyReadonlyArray<A>output: import ArrArr.type Arr.NonEmptyReadonlyArray = /*unresolved*/ anyNonEmptyReadonlyArray<function (type parameter) A in <AR, ER, RR, AL, A>(right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>A>,
readonly AL[]leftoverLeft: interface ReadonlyArray<T>ReadonlyArray<function (type parameter) AL in <AR, ER, RR, AL, A>(right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>AL>,
readonly AR[]leftoverRight: interface ReadonlyArray<T>ReadonlyArray<function (type parameter) AR in <AR, ER, RR, AL, A>(right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>AR>
]
): <function (type parameter) EL in <EL, RL>(left: Stream<AL, EL, RL>): Stream<A, EL | ER, RL | RR>EL, function (type parameter) RL in <EL, RL>(left: Stream<AL, EL, RL>): Stream<A, EL | ER, RL | RR>RL>(left: Stream<AL, EL, RL>(parameter) left: {
channel: Channel.Channel<Arr.NonEmptyReadonlyArray<A>, E, void, unknown, unknown, unknown, R>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
interface Stream<out A, out E = never, out R = never>A Stream<A, E, R> describes a program that can emit many A values, fail
with E, and require R.
Details
Streams are pull-based with backpressure and emit chunks to amortize effect
evaluation. They support monadic composition and error handling similar to
Effect, adapted for multiple values.
Example (Creating and consuming streams)
import { Console, Effect, Stream } from "effect"
const program = Effect.gen(function*() {
yield* Stream.make(1, 2, 3).pipe(
Stream.map((n) => n * 2),
Stream.runForEach((n) => Console.log(n))
)
})
Effect.runPromise(program)
// Output:
// 2
// 4
// 6
Stream<function (type parameter) AL in <AR, ER, RR, AL, A>(right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>AL, function (type parameter) EL in <EL, RL>(left: Stream<AL, EL, RL>): Stream<A, EL | ER, RL | RR>EL, function (type parameter) RL in <EL, RL>(left: Stream<AL, EL, RL>): Stream<A, EL | ER, RL | RR>RL>) => interface Stream<out A, out E = never, out R = never>A Stream<A, E, R> describes a program that can emit many A values, fail
with E, and require R.
Details
Streams are pull-based with backpressure and emit chunks to amortize effect
evaluation. They support monadic composition and error handling similar to
Effect, adapted for multiple values.
Example (Creating and consuming streams)
import { Console, Effect, Stream } from "effect"
const program = Effect.gen(function*() {
yield* Stream.make(1, 2, 3).pipe(
Stream.map((n) => n * 2),
Stream.runForEach((n) => Console.log(n))
)
})
Effect.runPromise(program)
// Output:
// 2
// 4
// 6
Stream<function (type parameter) A in <AR, ER, RR, AL, A>(right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>A, function (type parameter) EL in <EL, RL>(left: Stream<AL, EL, RL>): Stream<A, EL | ER, RL | RR>EL | function (type parameter) ER in <AR, ER, RR, AL, A>(right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>ER, function (type parameter) RL in <EL, RL>(left: Stream<AL, EL, RL>): Stream<A, EL | ER, RL | RR>RL | function (type parameter) RR in <AR, ER, RR, AL, A>(right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>RR>
<function (type parameter) AL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>AL, function (type parameter) EL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>EL, function (type parameter) RL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>RL, function (type parameter) AR in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>AR, function (type parameter) ER in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>ER, function (type parameter) RR in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>RR, function (type parameter) A in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>A>(
left: Stream<AL, EL, RL>(parameter) left: {
channel: Channel.Channel<Arr.NonEmptyReadonlyArray<A>, E, void, unknown, unknown, unknown, R>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
interface Stream<out A, out E = never, out R = never>A Stream<A, E, R> describes a program that can emit many A values, fail
with E, and require R.
Details
Streams are pull-based with backpressure and emit chunks to amortize effect
evaluation. They support monadic composition and error handling similar to
Effect, adapted for multiple values.
Example (Creating and consuming streams)
import { Console, Effect, Stream } from "effect"
const program = Effect.gen(function*() {
yield* Stream.make(1, 2, 3).pipe(
Stream.map((n) => n * 2),
Stream.runForEach((n) => Console.log(n))
)
})
Effect.runPromise(program)
// Output:
// 2
// 4
// 6
Stream<function (type parameter) AL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>AL, function (type parameter) EL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>EL, function (type parameter) RL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>RL>,
right: Stream<AR, ER, RR>(parameter) right: {
channel: Channel.Channel<Arr.NonEmptyReadonlyArray<A>, E, void, unknown, unknown, unknown, R>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
interface Stream<out A, out E = never, out R = never>A Stream<A, E, R> describes a program that can emit many A values, fail
with E, and require R.
Details
Streams are pull-based with backpressure and emit chunks to amortize effect
evaluation. They support monadic composition and error handling similar to
Effect, adapted for multiple values.
Example (Creating and consuming streams)
import { Console, Effect, Stream } from "effect"
const program = Effect.gen(function*() {
yield* Stream.make(1, 2, 3).pipe(
Stream.map((n) => n * 2),
Stream.runForEach((n) => Console.log(n))
)
})
Effect.runPromise(program)
// Output:
// 2
// 4
// 6
Stream<function (type parameter) AR in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>AR, function (type parameter) ER in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>ER, function (type parameter) RR in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>RR>,
f: (
left: Arr.NonEmptyReadonlyArray<AL>,
right: Arr.NonEmptyReadonlyArray<AR>
) => readonly [
output: Arr.NonEmptyReadonlyArray<A>,
leftoverLeft: ReadonlyArray<AL>,
leftoverRight: ReadonlyArray<AR>
]
left: Arr.NonEmptyReadonlyArray<AL>(parameter) left: {
0: AL;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<AL>>): Array<AL>; (...items: Array<AL | ConcatArray<AL>>): Array<AL> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<AL>;
indexOf: (searchElement: AL, fromIndex?: number) => number;
lastIndexOf: (searchElement: AL, fromIndex?: number) => number;
every: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: AL, index: number, array: ReadonlyArray<AL>) => void, thisArg?: any) => void;
map: (callbackfn: (value: AL, index: number, array: ReadonlyArray<AL>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): Array<S>; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): Array<AL> };
reduce: { (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL): AL; (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL, initialValue: AL): A…;
reduceRight: { (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL): AL; (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL, initialValue: AL): A…;
find: { (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => unknown, thisArg?: any): AL | undefined };
findIndex: (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, AL]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<AL>;
includes: (searchElement: AL, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: AL, index: number, array: Array<AL>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => AL | undefined;
findLast: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): AL | undefined };
findLastIndex: (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any) => number;
toReversed: () => Array<AL>;
toSorted: (compareFn?: ((a: AL, b: AL) => number) | undefined) => Array<AL>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<AL>): Array<AL>; (start: number, deleteCount?: number): Array<AL> };
with: (index: number, value: AL) => Array<AL>;
}
import ArrArr.type Arr.NonEmptyReadonlyArray = /*unresolved*/ anyNonEmptyReadonlyArray<function (type parameter) AL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>AL>,
right: Arr.NonEmptyReadonlyArray<AR>(parameter) right: {
0: AR;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<AR>>): Array<AR>; (...items: Array<AR | ConcatArray<AR>>): Array<AR> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<AR>;
indexOf: (searchElement: AR, fromIndex?: number) => number;
lastIndexOf: (searchElement: AR, fromIndex?: number) => number;
every: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: AR, index: number, array: ReadonlyArray<AR>) => void, thisArg?: any) => void;
map: (callbackfn: (value: AR, index: number, array: ReadonlyArray<AR>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): Array<S>; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): Array<AR> };
reduce: { (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR): AR; (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR, initialValue: AR): A…;
reduceRight: { (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR): AR; (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR, initialValue: AR): A…;
find: { (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => unknown, thisArg?: any): AR | undefined };
findIndex: (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, AR]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<AR>;
includes: (searchElement: AR, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: AR, index: number, array: Array<AR>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => AR | undefined;
findLast: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): AR | undefined };
findLastIndex: (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any) => number;
toReversed: () => Array<AR>;
toSorted: (compareFn?: ((a: AR, b: AR) => number) | undefined) => Array<AR>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<AR>): Array<AR>; (start: number, deleteCount?: number): Array<AR> };
with: (index: number, value: AR) => Array<AR>;
}
import ArrArr.type Arr.NonEmptyReadonlyArray = /*unresolved*/ anyNonEmptyReadonlyArray<function (type parameter) AR in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>AR>
) => readonly [
Arr.NonEmptyReadonlyArray<A>output: import ArrArr.type Arr.NonEmptyReadonlyArray = /*unresolved*/ anyNonEmptyReadonlyArray<function (type parameter) A in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>A>,
readonly AL[]leftoverLeft: interface ReadonlyArray<T>ReadonlyArray<function (type parameter) AL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>AL>,
readonly AR[]leftoverRight: interface ReadonlyArray<T>ReadonlyArray<function (type parameter) AR in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>AR>
]
): interface Stream<out A, out E = never, out R = never>A Stream<A, E, R> describes a program that can emit many A values, fail
with E, and require R.
Details
Streams are pull-based with backpressure and emit chunks to amortize effect
evaluation. They support monadic composition and error handling similar to
Effect, adapted for multiple values.
Example (Creating and consuming streams)
import { Console, Effect, Stream } from "effect"
const program = Effect.gen(function*() {
yield* Stream.make(1, 2, 3).pipe(
Stream.map((n) => n * 2),
Stream.runForEach((n) => Console.log(n))
)
})
Effect.runPromise(program)
// Output:
// 2
// 4
// 6
Stream<function (type parameter) A in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>A, function (type parameter) EL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>EL | function (type parameter) ER in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>ER, function (type parameter) RL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>RL | function (type parameter) RR in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>RR>
} = import dualdual(3, <function (type parameter) AL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>AL, function (type parameter) EL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>EL, function (type parameter) RL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>RL, function (type parameter) AR in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>AR, function (type parameter) ER in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>ER, function (type parameter) RR in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>RR, function (type parameter) A in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>A>(
left: Stream<AL, EL, RL>(parameter) left: {
channel: Channel.Channel<Arr.NonEmptyReadonlyArray<A>, E, void, unknown, unknown, unknown, R>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
interface Stream<out A, out E = never, out R = never>A Stream<A, E, R> describes a program that can emit many A values, fail
with E, and require R.
Details
Streams are pull-based with backpressure and emit chunks to amortize effect
evaluation. They support monadic composition and error handling similar to
Effect, adapted for multiple values.
Example (Creating and consuming streams)
import { Console, Effect, Stream } from "effect"
const program = Effect.gen(function*() {
yield* Stream.make(1, 2, 3).pipe(
Stream.map((n) => n * 2),
Stream.runForEach((n) => Console.log(n))
)
})
Effect.runPromise(program)
// Output:
// 2
// 4
// 6
Stream<function (type parameter) AL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>AL, function (type parameter) EL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>EL, function (type parameter) RL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>RL>,
right: Stream<AR, ER, RR>(parameter) right: {
channel: Channel.Channel<Arr.NonEmptyReadonlyArray<A>, E, void, unknown, unknown, unknown, R>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
interface Stream<out A, out E = never, out R = never>A Stream<A, E, R> describes a program that can emit many A values, fail
with E, and require R.
Details
Streams are pull-based with backpressure and emit chunks to amortize effect
evaluation. They support monadic composition and error handling similar to
Effect, adapted for multiple values.
Example (Creating and consuming streams)
import { Console, Effect, Stream } from "effect"
const program = Effect.gen(function*() {
yield* Stream.make(1, 2, 3).pipe(
Stream.map((n) => n * 2),
Stream.runForEach((n) => Console.log(n))
)
})
Effect.runPromise(program)
// Output:
// 2
// 4
// 6
Stream<function (type parameter) AR in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>AR, function (type parameter) ER in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>ER, function (type parameter) RR in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>RR>,
f: (
left: Arr.NonEmptyReadonlyArray<AL>,
right: Arr.NonEmptyReadonlyArray<AR>
) => readonly [
output: Arr.NonEmptyReadonlyArray<A>,
leftoverLeft: ReadonlyArray<AL>,
leftoverRight: ReadonlyArray<AR>
]
left: Arr.NonEmptyReadonlyArray<AL>(parameter) left: {
0: AL;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<AL>>): Array<AL>; (...items: Array<AL | ConcatArray<AL>>): Array<AL> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<AL>;
indexOf: (searchElement: AL, fromIndex?: number) => number;
lastIndexOf: (searchElement: AL, fromIndex?: number) => number;
every: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: AL, index: number, array: ReadonlyArray<AL>) => void, thisArg?: any) => void;
map: (callbackfn: (value: AL, index: number, array: ReadonlyArray<AL>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): Array<S>; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): Array<AL> };
reduce: { (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL): AL; (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL, initialValue: AL): A…;
reduceRight: { (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL): AL; (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL, initialValue: AL): A…;
find: { (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => unknown, thisArg?: any): AL | undefined };
findIndex: (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, AL]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<AL>;
includes: (searchElement: AL, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: AL, index: number, array: Array<AL>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => AL | undefined;
findLast: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): AL | undefined };
findLastIndex: (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any) => number;
toReversed: () => Array<AL>;
toSorted: (compareFn?: ((a: AL, b: AL) => number) | undefined) => Array<AL>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<AL>): Array<AL>; (start: number, deleteCount?: number): Array<AL> };
with: (index: number, value: AL) => Array<AL>;
}
import ArrArr.type Arr.NonEmptyReadonlyArray = /*unresolved*/ anyNonEmptyReadonlyArray<function (type parameter) AL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>AL>,
right: Arr.NonEmptyReadonlyArray<AR>(parameter) right: {
0: AR;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<AR>>): Array<AR>; (...items: Array<AR | ConcatArray<AR>>): Array<AR> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<AR>;
indexOf: (searchElement: AR, fromIndex?: number) => number;
lastIndexOf: (searchElement: AR, fromIndex?: number) => number;
every: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: AR, index: number, array: ReadonlyArray<AR>) => void, thisArg?: any) => void;
map: (callbackfn: (value: AR, index: number, array: ReadonlyArray<AR>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): Array<S>; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): Array<AR> };
reduce: { (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR): AR; (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR, initialValue: AR): A…;
reduceRight: { (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR): AR; (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR, initialValue: AR): A…;
find: { (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => unknown, thisArg?: any): AR | undefined };
findIndex: (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, AR]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<AR>;
includes: (searchElement: AR, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: AR, index: number, array: Array<AR>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => AR | undefined;
findLast: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): AR | undefined };
findLastIndex: (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any) => number;
toReversed: () => Array<AR>;
toSorted: (compareFn?: ((a: AR, b: AR) => number) | undefined) => Array<AR>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<AR>): Array<AR>; (start: number, deleteCount?: number): Array<AR> };
with: (index: number, value: AR) => Array<AR>;
}
import ArrArr.type Arr.NonEmptyReadonlyArray = /*unresolved*/ anyNonEmptyReadonlyArray<function (type parameter) AR in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>AR>
) => readonly [
Arr.NonEmptyReadonlyArray<A>output: import ArrArr.type Arr.NonEmptyReadonlyArray = /*unresolved*/ anyNonEmptyReadonlyArray<function (type parameter) A in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>A>,
readonly AL[]leftoverLeft: interface ReadonlyArray<T>ReadonlyArray<function (type parameter) AL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>AL>,
readonly AR[]leftoverRight: interface ReadonlyArray<T>ReadonlyArray<function (type parameter) AR in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>AR>
]
): interface Stream<out A, out E = never, out R = never>A Stream<A, E, R> describes a program that can emit many A values, fail
with E, and require R.
Details
Streams are pull-based with backpressure and emit chunks to amortize effect
evaluation. They support monadic composition and error handling similar to
Effect, adapted for multiple values.
Example (Creating and consuming streams)
import { Console, Effect, Stream } from "effect"
const program = Effect.gen(function*() {
yield* Stream.make(1, 2, 3).pipe(
Stream.map((n) => n * 2),
Stream.runForEach((n) => Console.log(n))
)
})
Effect.runPromise(program)
// Output:
// 2
// 4
// 6
Stream<function (type parameter) A in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>A, function (type parameter) EL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>EL | function (type parameter) ER in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>ER, function (type parameter) RL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>RL | function (type parameter) RR in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>RR> =>
const fromChannel: <
Arr extends Arr.NonEmptyReadonlyArray<any>,
E,
R
>(
channel: Channel.Channel<
Arr,
E,
void,
unknown,
unknown,
unknown,
R
>
) => Stream<
Arr extends Arr.NonEmptyReadonlyArray<infer A>
? A
: never,
E,
R
>
Creates a stream from a array-emitting Channel.
Example (Creating a stream from an array-emitting channel)
import { Channel, Console, Effect, Stream } from "effect"
const program = Effect.gen(function*() {
const channel = Channel.succeed([1, 2, 3] as const)
const stream = Stream.fromChannel(channel)
const result = yield* Stream.runCollect(stream)
yield* Console.log(result)
})
// Output: [ 1, 2, 3 ]
fromChannel(import ChannelChannel.fromTransformBracket(import EffectEffect.fnUntraced(function*(_: Pull.Pull<
unknown,
unknown,
unknown,
never
>
(parameter) _: {
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
scope: Scope.Scope(parameter) scope: {
strategy: "sequential" | "parallel";
state: State.Open | State.Closed | State.Empty;
}
const pullLeft: Pull.Pull<
readonly [AL, ...AL[]],
EL,
void,
RL
>
const pullLeft: {
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
import ChannelChannel.toPullScoped(left: Stream<AL, EL, RL>(parameter) left: {
channel: Channel.Channel<Arr.NonEmptyReadonlyArray<A>, E, void, unknown, unknown, unknown, R>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
Stream<out A, out E = never, out R = never>.channel: Channel.Channel<Arr.NonEmptyReadonlyArray<A>, E, void, unknown, unknown, unknown, R>(property) Stream<out A, out E = never, out R = never>.channel: {
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
scope: Scope.Scope(parameter) scope: {
strategy: "sequential" | "parallel";
state: State.Open | State.Closed | State.Empty;
}
const pullRight: Pull.Pull<
readonly [AR, ...AR[]],
ER,
void,
RR
>
const pullRight: {
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
import ChannelChannel.toPullScoped(right: Stream<AR, ER, RR>(parameter) right: {
channel: Channel.Channel<Arr.NonEmptyReadonlyArray<A>, E, void, unknown, unknown, unknown, R>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
Stream<out A, out E = never, out R = never>.channel: Channel.Channel<Arr.NonEmptyReadonlyArray<A>, E, void, unknown, unknown, unknown, R>(property) Stream<out A, out E = never, out R = never>.channel: {
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
scope: Scope.Scope(parameter) scope: {
strategy: "sequential" | "parallel";
state: State.Open | State.Closed | State.Empty;
}
const pullBoth: Effect.Effect<
[
readonly [AL, ...AL[]],
readonly [AR, ...AR[]]
],
never,
RL | RR
>
const pullBoth: {
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
import EffectEffect.gen(function*() {
const const fiberLeft: Fiber.Fiber<
readonly [AL, ...AL[]],
Cause.Done<void> | EL
>
const fiberLeft: {
id: number;
currentOpCount: number;
getRef: <A>(ref: Context.Reference<A>) => A;
context: Context.Context<never>;
setContext: (context: Context.Context<never>) => void;
currentScheduler: Scheduler;
currentDispatcher: SchedulerDispatcher;
currentSpan: AnySpan | undefined;
currentLogLevel: LogLevel;
minimumLogLevel: LogLevel;
currentStackFrame: StackFrame | undefined;
maxOpsBeforeYield: number;
currentPreventYield: boolean;
addObserver: (cb: (exit: Exit<A, E>) => void) => () => void;
interruptUnsafe: (fiberId?: number | undefined, annotations?: Context.Context<never> | undefined) => void;
pollUnsafe: () => Exit<A, E> | undefined;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
import EffectEffect.forkIn(const pullLeft: Pull.Pull<
readonly [AL, ...AL[]],
EL,
void,
RL
>
const pullLeft: {
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
scope: Scope.Scope(parameter) scope: {
strategy: "sequential" | "parallel";
state: State.Open | State.Closed | State.Empty;
}
const fiberRight: Fiber.Fiber<
readonly [AR, ...AR[]],
Cause.Done<void> | ER
>
const fiberRight: {
id: number;
currentOpCount: number;
getRef: <A>(ref: Context.Reference<A>) => A;
context: Context.Context<never>;
setContext: (context: Context.Context<never>) => void;
currentScheduler: Scheduler;
currentDispatcher: SchedulerDispatcher;
currentSpan: AnySpan | undefined;
currentLogLevel: LogLevel;
minimumLogLevel: LogLevel;
currentStackFrame: StackFrame | undefined;
maxOpsBeforeYield: number;
currentPreventYield: boolean;
addObserver: (cb: (exit: Exit<A, E>) => void) => () => void;
interruptUnsafe: (fiberId?: number | undefined, annotations?: Context.Context<never> | undefined) => void;
pollUnsafe: () => Exit<A, E> | undefined;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
import EffectEffect.forkIn(const pullRight: Pull.Pull<
readonly [AR, ...AR[]],
ER,
void,
RR
>
const pullRight: {
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
scope: Scope.Scope(parameter) scope: {
strategy: "sequential" | "parallel";
state: State.Open | State.Closed | State.Empty;
}
import FiberFiber.joinAll([const fiberLeft: Fiber.Fiber<
readonly [AL, ...AL[]],
Cause.Done<void> | EL
>
const fiberLeft: {
id: number;
currentOpCount: number;
getRef: <A>(ref: Context.Reference<A>) => A;
context: Context.Context<never>;
setContext: (context: Context.Context<never>) => void;
currentScheduler: Scheduler;
currentDispatcher: SchedulerDispatcher;
currentSpan: AnySpan | undefined;
currentLogLevel: LogLevel;
minimumLogLevel: LogLevel;
currentStackFrame: StackFrame | undefined;
maxOpsBeforeYield: number;
currentPreventYield: boolean;
addObserver: (cb: (exit: Exit<A, E>) => void) => () => void;
interruptUnsafe: (fiberId?: number | undefined, annotations?: Context.Context<never> | undefined) => void;
pollUnsafe: () => Exit<A, E> | undefined;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
const fiberRight: Fiber.Fiber<
readonly [AR, ...AR[]],
Cause.Done<void> | ER
>
const fiberRight: {
id: number;
currentOpCount: number;
getRef: <A>(ref: Context.Reference<A>) => A;
context: Context.Context<never>;
setContext: (context: Context.Context<never>) => void;
currentScheduler: Scheduler;
currentDispatcher: SchedulerDispatcher;
currentSpan: AnySpan | undefined;
currentLogLevel: LogLevel;
minimumLogLevel: LogLevel;
currentStackFrame: StackFrame | undefined;
maxOpsBeforeYield: number;
currentPreventYield: boolean;
addObserver: (cb: (exit: Exit<A, E>) => void) => () => void;
interruptUnsafe: (fiberId?: number | undefined, annotations?: Context.Context<never> | undefined) => void;
pollUnsafe: () => Exit<A, E> | undefined;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
import ArrArr.type Arr.NonEmptyReadonlyArray = /*unresolved*/ anyNonEmptyReadonlyArray<function (type parameter) AL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>AL>,
import ArrArr.type Arr.NonEmptyReadonlyArray = /*unresolved*/ anyNonEmptyReadonlyArray<function (type parameter) AR in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>AR>
]
})
type type State =
| {
_tag: "PullBoth"
}
| {
_tag: "PullLeft"
rightArray: Arr.NonEmptyReadonlyArray<AR>
}
| {
_tag: "PullRight"
leftArray: Arr.NonEmptyReadonlyArray<AL>
}
_tag: "PullBoth"_tag: "PullBoth" }
| { _tag: "PullLeft"_tag: "PullLeft"; rightArray: Arr.NonEmptyReadonlyArray<AR>(property) rightArray: {
0: AR;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<AR>>): Array<AR>; (...items: Array<AR | ConcatArray<AR>>): Array<AR> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<AR>;
indexOf: (searchElement: AR, fromIndex?: number) => number;
lastIndexOf: (searchElement: AR, fromIndex?: number) => number;
every: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: AR, index: number, array: ReadonlyArray<AR>) => void, thisArg?: any) => void;
map: (callbackfn: (value: AR, index: number, array: ReadonlyArray<AR>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): Array<S>; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): Array<AR> };
reduce: { (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR): AR; (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR, initialValue: AR): A…;
reduceRight: { (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR): AR; (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR, initialValue: AR): A…;
find: { (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => unknown, thisArg?: any): AR | undefined };
findIndex: (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, AR]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<AR>;
includes: (searchElement: AR, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: AR, index: number, array: Array<AR>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => AR | undefined;
findLast: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): AR | undefined };
findLastIndex: (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any) => number;
toReversed: () => Array<AR>;
toSorted: (compareFn?: ((a: AR, b: AR) => number) | undefined) => Array<AR>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<AR>): Array<AR>; (start: number, deleteCount?: number): Array<AR> };
with: (index: number, value: AR) => Array<AR>;
}
import ArrArr.type Arr.NonEmptyReadonlyArray = /*unresolved*/ anyNonEmptyReadonlyArray<function (type parameter) AR in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>AR> }
| { _tag: "PullRight"_tag: "PullRight"; leftArray: Arr.NonEmptyReadonlyArray<AL>(property) leftArray: {
0: AL;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<AL>>): Array<AL>; (...items: Array<AL | ConcatArray<AL>>): Array<AL> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<AL>;
indexOf: (searchElement: AL, fromIndex?: number) => number;
lastIndexOf: (searchElement: AL, fromIndex?: number) => number;
every: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: AL, index: number, array: ReadonlyArray<AL>) => void, thisArg?: any) => void;
map: (callbackfn: (value: AL, index: number, array: ReadonlyArray<AL>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): Array<S>; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): Array<AL> };
reduce: { (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL): AL; (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL, initialValue: AL): A…;
reduceRight: { (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL): AL; (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL, initialValue: AL): A…;
find: { (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => unknown, thisArg?: any): AL | undefined };
findIndex: (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, AL]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<AL>;
includes: (searchElement: AL, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: AL, index: number, array: Array<AL>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => AL | undefined;
findLast: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): AL | undefined };
findLastIndex: (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any) => number;
toReversed: () => Array<AL>;
toSorted: (compareFn?: ((a: AL, b: AL) => number) | undefined) => Array<AL>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<AL>): Array<AL>; (start: number, deleteCount?: number): Array<AL> };
with: (index: number, value: AL) => Array<AL>;
}
import ArrArr.type Arr.NonEmptyReadonlyArray = /*unresolved*/ anyNonEmptyReadonlyArray<function (type parameter) AL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>AL> }
let let state: Statestate: type State =
| {
_tag: "PullBoth"
}
| {
_tag: "PullLeft"
rightArray: Arr.NonEmptyReadonlyArray<AR>
}
| {
_tag: "PullRight"
leftArray: Arr.NonEmptyReadonlyArray<AL>
}
_tag: "PullBoth"_tag: "PullBoth" }
const const pull: Effect.Effect<
Arr.NonEmptyReadonlyArray<A>,
EL | ER | Cause.Done,
RL | RR
>
const pull: {
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<
import ArrArr.type Arr.NonEmptyReadonlyArray = /*unresolved*/ anyNonEmptyReadonlyArray<function (type parameter) A in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>A>,
function (type parameter) EL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>EL | function (type parameter) ER in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>ER | import CauseCause.type Cause.Done = /*unresolved*/ anyDone,
function (type parameter) RL in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>RL | function (type parameter) RR in <AL, EL, RL, AR, ER, RR, A>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>, f: (left: Arr.NonEmptyReadonlyArray<AL>, right: Arr.NonEmptyReadonlyArray<AR>) => readonly [output: Arr.NonEmptyReadonlyArray<A>, leftoverLeft: ReadonlyArray<AL>, leftoverRight: ReadonlyArray<AR>]): Stream<A, EL | ER, RL | RR>RR
> = import EffectEffect.gen(function*() {
const [const left: anyconst left: {
0: AL;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<AL>>): Array<AL>; (...items: Array<AL | ConcatArray<AL>>): Array<AL> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<AL>;
indexOf: (searchElement: AL, fromIndex?: number) => number;
lastIndexOf: (searchElement: AL, fromIndex?: number) => number;
every: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: AL, index: number, array: ReadonlyArray<AL>) => void, thisArg?: any) => void;
map: (callbackfn: (value: AL, index: number, array: ReadonlyArray<AL>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): Array<S>; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): Array<AL> };
reduce: { (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL): AL; (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL, initialValue: AL): A…;
reduceRight: { (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL): AL; (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL, initialValue: AL): A…;
find: { (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => unknown, thisArg?: any): AL | undefined };
findIndex: (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, AL]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<AL>;
includes: (searchElement: AL, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: AL, index: number, array: Array<AL>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => AL | undefined;
findLast: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): AL | undefined };
findLastIndex: (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any) => number;
toReversed: () => Array<AL>;
toSorted: (compareFn?: ((a: AL, b: AL) => number) | undefined) => Array<AL>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<AL>): Array<AL>; (start: number, deleteCount?: number): Array<AL> };
with: (index: number, value: AL) => Array<AL>;
}
const right: anyconst right: {
0: AR;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<AR>>): Array<AR>; (...items: Array<AR | ConcatArray<AR>>): Array<AR> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<AR>;
indexOf: (searchElement: AR, fromIndex?: number) => number;
lastIndexOf: (searchElement: AR, fromIndex?: number) => number;
every: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: AR, index: number, array: ReadonlyArray<AR>) => void, thisArg?: any) => void;
map: (callbackfn: (value: AR, index: number, array: ReadonlyArray<AR>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): Array<S>; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): Array<AR> };
reduce: { (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR): AR; (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR, initialValue: AR): A…;
reduceRight: { (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR): AR; (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR, initialValue: AR): A…;
find: { (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => unknown, thisArg?: any): AR | undefined };
findIndex: (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, AR]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<AR>;
includes: (searchElement: AR, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: AR, index: number, array: Array<AR>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => AR | undefined;
findLast: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): AR | undefined };
findLastIndex: (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any) => number;
toReversed: () => Array<AR>;
toSorted: (compareFn?: ((a: AR, b: AR) => number) | undefined) => Array<AR>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<AR>): Array<AR>; (start: number, deleteCount?: number): Array<AR> };
with: (index: number, value: AR) => Array<AR>;
}
let state: Statestate._tag: "PullBoth" | "PullLeft" | "PullRight"_tag === "PullBoth"
? yield* const pullBoth: Effect.Effect<
[
readonly [AL, ...AL[]],
readonly [AR, ...AR[]]
],
never,
RL | RR
>
const pullBoth: {
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
let state:
| {
_tag: "PullLeft"
rightArray: Arr.NonEmptyReadonlyArray<AR>
}
| {
_tag: "PullRight"
leftArray: Arr.NonEmptyReadonlyArray<AL>
}
_tag: "PullLeft" | "PullRight"_tag === "PullLeft"
? [yield* const pullLeft: Pull.Pull<
readonly [AL, ...AL[]],
EL,
void,
RL
>
const pullLeft: {
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
let state: {
_tag: "PullLeft"
rightArray: Arr.NonEmptyReadonlyArray<AR>
}
rightArray: Arr.NonEmptyReadonlyArray<AR>(property) rightArray: {
0: AR;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<AR>>): Array<AR>; (...items: Array<AR | ConcatArray<AR>>): Array<AR> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<AR>;
indexOf: (searchElement: AR, fromIndex?: number) => number;
lastIndexOf: (searchElement: AR, fromIndex?: number) => number;
every: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: AR, index: number, array: ReadonlyArray<AR>) => void, thisArg?: any) => void;
map: (callbackfn: (value: AR, index: number, array: ReadonlyArray<AR>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): Array<S>; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): Array<AR> };
reduce: { (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR): AR; (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR, initialValue: AR): A…;
reduceRight: { (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR): AR; (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR, initialValue: AR): A…;
find: { (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => unknown, thisArg?: any): AR | undefined };
findIndex: (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, AR]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<AR>;
includes: (searchElement: AR, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: AR, index: number, array: Array<AR>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => AR | undefined;
findLast: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): AR | undefined };
findLastIndex: (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any) => number;
toReversed: () => Array<AR>;
toSorted: (compareFn?: ((a: AR, b: AR) => number) | undefined) => Array<AR>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<AR>): Array<AR>; (start: number, deleteCount?: number): Array<AR> };
with: (index: number, value: AR) => Array<AR>;
}
let state: {
_tag: "PullRight"
leftArray: Arr.NonEmptyReadonlyArray<AL>
}
leftArray: Arr.NonEmptyReadonlyArray<AL>(property) leftArray: {
0: AL;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<AL>>): Array<AL>; (...items: Array<AL | ConcatArray<AL>>): Array<AL> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<AL>;
indexOf: (searchElement: AL, fromIndex?: number) => number;
lastIndexOf: (searchElement: AL, fromIndex?: number) => number;
every: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: AL, index: number, array: ReadonlyArray<AL>) => void, thisArg?: any) => void;
map: (callbackfn: (value: AL, index: number, array: ReadonlyArray<AL>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): Array<S>; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): Array<AL> };
reduce: { (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL): AL; (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL, initialValue: AL): A…;
reduceRight: { (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL): AL; (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL, initialValue: AL): A…;
find: { (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => unknown, thisArg?: any): AL | undefined };
findIndex: (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, AL]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<AL>;
includes: (searchElement: AL, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: AL, index: number, array: Array<AL>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => AL | undefined;
findLast: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): AL | undefined };
findLastIndex: (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any) => number;
toReversed: () => Array<AL>;
toSorted: (compareFn?: ((a: AL, b: AL) => number) | undefined) => Array<AL>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<AL>): Array<AL>; (start: number, deleteCount?: number): Array<AL> };
with: (index: number, value: AL) => Array<AL>;
}
const pullRight: Pull.Pull<
readonly [AR, ...AR[]],
ER,
void,
RR
>
const pullRight: {
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
const result: readonly [
output: Arr.NonEmptyReadonlyArray<A>,
leftoverLeft: readonly AL[],
leftoverRight: readonly AR[]
]
const result: {
0: readonly [A, ...A[]];
1: ReadonlyArray<AL>;
2: ReadonlyArray<AR>;
length: 3;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>>): Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>; (...items: Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A…;
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
indexOf: (searchElement: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], fromIndex?: number) => number;
lastIndexOf: (searchElement: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], fromIndex?: number) => number;
every: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): this is readonly S[]; (pr…;
some: (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => void, thisArg?: any) => void;
map: (callbackfn: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): Array<S>; (predicate: (va…;
reduce: { (callbackfn: (previousValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentIndex: number, array: ReadonlyArray<ReadonlyArray<AL> | Readonl…;
reduceRight: { (callbackfn: (previousValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentIndex: number, array: ReadonlyArray<ReadonlyArray<AL> | Readonl…;
find: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, obj: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): S | undefined; (predicate: …;
findIndex: (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, obj: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
includes: (searchElement: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => U | ReadonlyArray<U>, thisArg?: This | undefined) =>…;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]] | undefined;
findLast: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): S | undefined; (predicate…;
findLastIndex: (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => unknown, thisArg?: any) => number;
toReversed: () => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
toSorted: (compareFn?: ((a: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], b: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]) => number) | undefined) => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>): Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>; (start: number, deleteCount?: number): Array<Readon…;
with: (index: number, value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]) => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
}
f: (
left: Arr.NonEmptyReadonlyArray<AL>,
right: Arr.NonEmptyReadonlyArray<AR>
) => readonly [
output: Arr.NonEmptyReadonlyArray<A>,
leftoverLeft: ReadonlyArray<AL>,
leftoverRight: ReadonlyArray<AR>
]
const left: anyconst left: {
0: AL;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<AL>>): Array<AL>; (...items: Array<AL | ConcatArray<AL>>): Array<AL> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<AL>;
indexOf: (searchElement: AL, fromIndex?: number) => number;
lastIndexOf: (searchElement: AL, fromIndex?: number) => number;
every: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: AL, index: number, array: ReadonlyArray<AL>) => void, thisArg?: any) => void;
map: (callbackfn: (value: AL, index: number, array: ReadonlyArray<AL>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): Array<S>; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): Array<AL> };
reduce: { (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL): AL; (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL, initialValue: AL): A…;
reduceRight: { (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL): AL; (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL, initialValue: AL): A…;
find: { (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => unknown, thisArg?: any): AL | undefined };
findIndex: (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, AL]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<AL>;
includes: (searchElement: AL, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: AL, index: number, array: Array<AL>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => AL | undefined;
findLast: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): AL | undefined };
findLastIndex: (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any) => number;
toReversed: () => Array<AL>;
toSorted: (compareFn?: ((a: AL, b: AL) => number) | undefined) => Array<AL>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<AL>): Array<AL>; (start: number, deleteCount?: number): Array<AL> };
with: (index: number, value: AL) => Array<AL>;
}
const right: anyconst right: {
0: AR;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<AR>>): Array<AR>; (...items: Array<AR | ConcatArray<AR>>): Array<AR> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<AR>;
indexOf: (searchElement: AR, fromIndex?: number) => number;
lastIndexOf: (searchElement: AR, fromIndex?: number) => number;
every: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: AR, index: number, array: ReadonlyArray<AR>) => void, thisArg?: any) => void;
map: (callbackfn: (value: AR, index: number, array: ReadonlyArray<AR>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): Array<S>; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): Array<AR> };
reduce: { (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR): AR; (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR, initialValue: AR): A…;
reduceRight: { (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR): AR; (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR, initialValue: AR): A…;
find: { (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => unknown, thisArg?: any): AR | undefined };
findIndex: (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, AR]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<AR>;
includes: (searchElement: AR, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: AR, index: number, array: Array<AR>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => AR | undefined;
findLast: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): AR | undefined };
findLastIndex: (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any) => number;
toReversed: () => Array<AR>;
toSorted: (compareFn?: ((a: AR, b: AR) => number) | undefined) => Array<AR>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<AR>): Array<AR>; (start: number, deleteCount?: number): Array<AR> };
with: (index: number, value: AR) => Array<AR>;
}
import ArrArr.isReadonlyArrayNonEmpty(const result: readonly [
output: Arr.NonEmptyReadonlyArray<A>,
leftoverLeft: readonly AL[],
leftoverRight: readonly AR[]
]
const result: {
0: readonly [A, ...A[]];
1: ReadonlyArray<AL>;
2: ReadonlyArray<AR>;
length: 3;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>>): Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>; (...items: Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A…;
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
indexOf: (searchElement: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], fromIndex?: number) => number;
lastIndexOf: (searchElement: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], fromIndex?: number) => number;
every: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): this is readonly S[]; (pr…;
some: (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => void, thisArg?: any) => void;
map: (callbackfn: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): Array<S>; (predicate: (va…;
reduce: { (callbackfn: (previousValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentIndex: number, array: ReadonlyArray<ReadonlyArray<AL> | Readonl…;
reduceRight: { (callbackfn: (previousValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentIndex: number, array: ReadonlyArray<ReadonlyArray<AL> | Readonl…;
find: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, obj: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): S | undefined; (predicate: …;
findIndex: (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, obj: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
includes: (searchElement: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => U | ReadonlyArray<U>, thisArg?: This | undefined) =>…;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]] | undefined;
findLast: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): S | undefined; (predicate…;
findLastIndex: (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => unknown, thisArg?: any) => number;
toReversed: () => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
toSorted: (compareFn?: ((a: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], b: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]) => number) | undefined) => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>): Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>; (start: number, deleteCount?: number): Array<Readon…;
with: (index: number, value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]) => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
}
let state: Statestate = { _tag: "PullRight"_tag: "PullRight", leftArray: Arr.NonEmptyReadonlyArray<AL>(property) leftArray: {
0: AL;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<AL>>): Array<AL>; (...items: Array<AL | ConcatArray<AL>>): Array<AL> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<AL>;
indexOf: (searchElement: AL, fromIndex?: number) => number;
lastIndexOf: (searchElement: AL, fromIndex?: number) => number;
every: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: AL, index: number, array: ReadonlyArray<AL>) => void, thisArg?: any) => void;
map: (callbackfn: (value: AL, index: number, array: ReadonlyArray<AL>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): Array<S>; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): Array<AL> };
reduce: { (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL): AL; (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL, initialValue: AL): A…;
reduceRight: { (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL): AL; (callbackfn: (previousValue: AL, currentValue: AL, currentIndex: number, array: ReadonlyArray<AL>) => AL, initialValue: AL): A…;
find: { (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => unknown, thisArg?: any): AL | undefined };
findIndex: (predicate: (value: AL, index: number, obj: ReadonlyArray<AL>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, AL]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<AL>;
includes: (searchElement: AL, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: AL, index: number, array: Array<AL>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => AL | undefined;
findLast: { (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any): AL | undefined };
findLastIndex: (predicate: (value: AL, index: number, array: ReadonlyArray<AL>) => unknown, thisArg?: any) => number;
toReversed: () => Array<AL>;
toSorted: (compareFn?: ((a: AL, b: AL) => number) | undefined) => Array<AL>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<AL>): Array<AL>; (start: number, deleteCount?: number): Array<AL> };
with: (index: number, value: AL) => Array<AL>;
}
const result: readonly [
output: Arr.NonEmptyReadonlyArray<A>,
leftoverLeft: readonly AL[],
leftoverRight: readonly AR[]
]
const result: {
0: readonly [A, ...A[]];
1: ReadonlyArray<AL>;
2: ReadonlyArray<AR>;
length: 3;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>>): Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>; (...items: Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A…;
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
indexOf: (searchElement: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], fromIndex?: number) => number;
lastIndexOf: (searchElement: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], fromIndex?: number) => number;
every: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): this is readonly S[]; (pr…;
some: (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => void, thisArg?: any) => void;
map: (callbackfn: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): Array<S>; (predicate: (va…;
reduce: { (callbackfn: (previousValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentIndex: number, array: ReadonlyArray<ReadonlyArray<AL> | Readonl…;
reduceRight: { (callbackfn: (previousValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentIndex: number, array: ReadonlyArray<ReadonlyArray<AL> | Readonl…;
find: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, obj: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): S | undefined; (predicate: …;
findIndex: (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, obj: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
includes: (searchElement: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => U | ReadonlyArray<U>, thisArg?: This | undefined) =>…;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]] | undefined;
findLast: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): S | undefined; (predicate…;
findLastIndex: (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => unknown, thisArg?: any) => number;
toReversed: () => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
toSorted: (compareFn?: ((a: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], b: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]) => number) | undefined) => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>): Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>; (start: number, deleteCount?: number): Array<Readon…;
with: (index: number, value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]) => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
}
import ArrArr.isReadonlyArrayNonEmpty(const result: readonly [
output: Arr.NonEmptyReadonlyArray<A>,
leftoverLeft: readonly AL[],
leftoverRight: readonly AR[]
]
const result: {
0: readonly [A, ...A[]];
1: ReadonlyArray<AL>;
2: ReadonlyArray<AR>;
length: 3;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>>): Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>; (...items: Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A…;
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
indexOf: (searchElement: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], fromIndex?: number) => number;
lastIndexOf: (searchElement: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], fromIndex?: number) => number;
every: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): this is readonly S[]; (pr…;
some: (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => void, thisArg?: any) => void;
map: (callbackfn: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): Array<S>; (predicate: (va…;
reduce: { (callbackfn: (previousValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentIndex: number, array: ReadonlyArray<ReadonlyArray<AL> | Readonl…;
reduceRight: { (callbackfn: (previousValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentIndex: number, array: ReadonlyArray<ReadonlyArray<AL> | Readonl…;
find: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, obj: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): S | undefined; (predicate: …;
findIndex: (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, obj: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
includes: (searchElement: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => U | ReadonlyArray<U>, thisArg?: This | undefined) =>…;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]] | undefined;
findLast: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): S | undefined; (predicate…;
findLastIndex: (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => unknown, thisArg?: any) => number;
toReversed: () => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
toSorted: (compareFn?: ((a: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], b: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]) => number) | undefined) => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>): Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>; (start: number, deleteCount?: number): Array<Readon…;
with: (index: number, value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]) => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
}
let state: Statestate = { _tag: "PullLeft"_tag: "PullLeft", rightArray: Arr.NonEmptyReadonlyArray<AR>(property) rightArray: {
0: AR;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<AR>>): Array<AR>; (...items: Array<AR | ConcatArray<AR>>): Array<AR> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<AR>;
indexOf: (searchElement: AR, fromIndex?: number) => number;
lastIndexOf: (searchElement: AR, fromIndex?: number) => number;
every: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: AR, index: number, array: ReadonlyArray<AR>) => void, thisArg?: any) => void;
map: (callbackfn: (value: AR, index: number, array: ReadonlyArray<AR>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): Array<S>; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): Array<AR> };
reduce: { (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR): AR; (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR, initialValue: AR): A…;
reduceRight: { (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR): AR; (callbackfn: (previousValue: AR, currentValue: AR, currentIndex: number, array: ReadonlyArray<AR>) => AR, initialValue: AR): A…;
find: { (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => unknown, thisArg?: any): AR | undefined };
findIndex: (predicate: (value: AR, index: number, obj: ReadonlyArray<AR>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, AR]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<AR>;
includes: (searchElement: AR, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: AR, index: number, array: Array<AR>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => AR | undefined;
findLast: { (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => value is S, thisArg?: any): S | undefined; (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any): AR | undefined };
findLastIndex: (predicate: (value: AR, index: number, array: ReadonlyArray<AR>) => unknown, thisArg?: any) => number;
toReversed: () => Array<AR>;
toSorted: (compareFn?: ((a: AR, b: AR) => number) | undefined) => Array<AR>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<AR>): Array<AR>; (start: number, deleteCount?: number): Array<AR> };
with: (index: number, value: AR) => Array<AR>;
}
const result: readonly [
output: Arr.NonEmptyReadonlyArray<A>,
leftoverLeft: readonly AL[],
leftoverRight: readonly AR[]
]
const result: {
0: readonly [A, ...A[]];
1: ReadonlyArray<AL>;
2: ReadonlyArray<AR>;
length: 3;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>>): Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>; (...items: Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A…;
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
indexOf: (searchElement: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], fromIndex?: number) => number;
lastIndexOf: (searchElement: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], fromIndex?: number) => number;
every: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): this is readonly S[]; (pr…;
some: (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => void, thisArg?: any) => void;
map: (callbackfn: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): Array<S>; (predicate: (va…;
reduce: { (callbackfn: (previousValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentIndex: number, array: ReadonlyArray<ReadonlyArray<AL> | Readonl…;
reduceRight: { (callbackfn: (previousValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentIndex: number, array: ReadonlyArray<ReadonlyArray<AL> | Readonl…;
find: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, obj: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): S | undefined; (predicate: …;
findIndex: (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, obj: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
includes: (searchElement: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => U | ReadonlyArray<U>, thisArg?: This | undefined) =>…;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]] | undefined;
findLast: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): S | undefined; (predicate…;
findLastIndex: (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => unknown, thisArg?: any) => number;
toReversed: () => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
toSorted: (compareFn?: ((a: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], b: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]) => number) | undefined) => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>): Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>; (start: number, deleteCount?: number): Array<Readon…;
with: (index: number, value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]) => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
}
let state: Statestate = { _tag: "PullBoth"_tag: "PullBoth" }
}
return const result: readonly [
output: Arr.NonEmptyReadonlyArray<A>,
leftoverLeft: readonly AL[],
leftoverRight: readonly AR[]
]
const result: {
0: readonly [A, ...A[]];
1: ReadonlyArray<AL>;
2: ReadonlyArray<AR>;
length: 3;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>>): Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>; (...items: Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A…;
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
indexOf: (searchElement: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], fromIndex?: number) => number;
lastIndexOf: (searchElement: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], fromIndex?: number) => number;
every: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): this is readonly S[]; (pr…;
some: (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => void, thisArg?: any) => void;
map: (callbackfn: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): Array<S>; (predicate: (va…;
reduce: { (callbackfn: (previousValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentIndex: number, array: ReadonlyArray<ReadonlyArray<AL> | Readonl…;
reduceRight: { (callbackfn: (previousValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentValue: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], currentIndex: number, array: ReadonlyArray<ReadonlyArray<AL> | Readonl…;
find: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, obj: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): S | undefined; (predicate: …;
findIndex: (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, obj: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
includes: (searchElement: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => U | ReadonlyArray<U>, thisArg?: This | undefined) =>…;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]] | undefined;
findLast: { (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => value is S, thisArg?: any): S | undefined; (predicate…;
findLastIndex: (predicate: (value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], index: number, array: ReadonlyArray<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>) => unknown, thisArg?: any) => number;
toReversed: () => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
toSorted: (compareFn?: ((a: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]], b: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]) => number) | undefined) => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>): Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>; (start: number, deleteCount?: number): Array<Readon…;
with: (index: number, value: ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]) => Array<ReadonlyArray<AL> | ReadonlyArray<AR> | readonly [A, ...A[]]>;
}
const pull: Effect.Effect<
Arr.NonEmptyReadonlyArray<A>,
EL | ER | Cause.Done,
RL | RR
>
const pull: {
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
Referenced by 3 symbols