Lorem Ipsum MCP Server

/** * @since 2.0.0 */ import type * as Cause from "./Cause.js" import type * as Chunk from "./Chunk.js" import type * as Effect from "./Effect.js" import type * as Exit from "./Exit.js" import * as internal from "./internal/take.js" import type * as Option from "./Option.js" import type { Pipeable } from "./Pipeable.js" import type * as Types from "./Types.js" /** * @since 2.0.0 * @category symbols */ export const TakeTypeId: unique symbol = internal.TakeTypeId /** * @since 2.0.0 * @category symbols */ export type TakeTypeId = typeof TakeTypeId /** * A `Take<A, E>` represents a single `take` from a queue modeling a stream of * values. A `Take` may be a failure cause `Cause<E>`, a chunk value `Chunk<A>`, * or an end-of-stream marker. * * @since 2.0.0 * @category models */ export interface Take<out A, out E = never> extends Take.Variance<A, E>, Pipeable { /** @internal */ readonly exit: Exit.Exit<Chunk.Chunk<A>, Option.Option<E>> } /** * @since 2.0.0 */ export declare namespace Take { /** * @since 2.0.0 * @category models */ export interface Variance<out A, out E> { readonly [TakeTypeId]: { readonly _A: Types.Covariant<A> readonly _E: Types.Covariant<E> } } } /** * Creates a `Take` with the specified chunk. * * @since 2.0.0 * @category constructors */ export const chunk: <A>(chunk: Chunk.Chunk<A>) => Take<A> = internal.chunk /** * Creates a failing `Take` with the specified defect. * * @since 2.0.0 * @category constructors */ export const die: (defect: unknown) => Take<never> = internal.die /** * Creates a failing `Take` with the specified error message. * * @since 2.0.0 * @category constructors */ export const dieMessage: (message: string) => Take<never> = internal.dieMessage /** * Transforms a `Take<A, E>` to an `Effect<A, E>`. * * @since 2.0.0 * @category destructors */ export const done: <A, E>(self: Take<A, E>) => Effect.Effect<Chunk.Chunk<A>, Option.Option<E>> = internal.done /** * Represents the end-of-stream marker. * * @since 2.0.0 * @category constructors */ export const end: Take<never> = internal.end /** * Creates a failing `Take` with the specified error. * * @since 2.0.0 * @category constructors */ export const fail: <E>(error: E) => Take<never, E> = internal.fail /** * Creates a failing `Take` with the specified cause. * * @since 2.0.0 * @category constructors */ export const failCause: <E>(cause: Cause.Cause<E>) => Take<never, E> = internal.failCause /** * Creates an effect from `Effect<A, E, R>` that does not fail, but succeeds with * the `Take<A, E>`. Error from stream when pulling is converted to * `Take.failCause`. Creates a single value chunk. * * @since 2.0.0 * @category constructors */ export const fromEffect: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<Take<A, E>, never, R> = internal.fromEffect /** * Creates a `Take` from an `Exit`. * * @since 2.0.0 * @category constructors */ export const fromExit: <A, E>(exit: Exit.Exit<A, E>) => Take<A, E> = internal.fromExit /** * Creates effect from `Effect<Chunk<A>, Option<E>, R>` that does not fail, but * succeeds with the `Take<A, E>`. Errors from stream when pulling are converted * to `Take.failCause`, and the end-of-stream is converted to `Take.end`. * * @since 2.0.0 * @category constructors */ export const fromPull: <A, E, R>( pull: Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R> ) => Effect.Effect<Take<A, E>, never, R> = internal.fromPull /** * Checks if this `take` is done (`Take.end`). * * @since 2.0.0 * @category getters */ export const isDone: <A, E>(self: Take<A, E>) => boolean = internal.isDone /** * Checks if this `take` is a failure. * * @since 2.0.0 * @category getters */ export const isFailure: <A, E>(self: Take<A, E>) => boolean = internal.isFailure /** * Checks if this `take` is a success. * * @since 2.0.0 * @category getters */ export const isSuccess: <A, E>(self: Take<A, E>) => boolean = internal.isSuccess /** * Constructs a `Take`. * * @since 2.0.0 * @category constructors */ export const make: <A, E>(exit: Exit.Exit<Chunk.Chunk<A>, Option.Option<E>>) => Take<A, E> = internal.make /** * Transforms `Take<A, E>` to `Take<B, A>` by applying function `f`. * * @since 2.0.0 * @category mapping */ export const map: { /** * Transforms `Take<A, E>` to `Take<B, A>` by applying function `f`. * * @since 2.0.0 * @category mapping */ <A, B>(f: (a: A) => B): <E>(self: Take<A, E>) => Take<B, E> /** * Transforms `Take<A, E>` to `Take<B, A>` by applying function `f`. * * @since 2.0.0 * @category mapping */ <A, E, B>(self: Take<A, E>, f: (a: A) => B): Take<B, E> } = internal.map /** * Folds over the failure cause, success value and end-of-stream marker to * yield a value. * * @since 2.0.0 * @category destructors */ export const match: { /** * Folds over the failure cause, success value and end-of-stream marker to * yield a value. * * @since 2.0.0 * @category destructors */ <Z, E, Z2, A, Z3>( options: { readonly onEnd: () => Z readonly onFailure: (cause: Cause.Cause<E>) => Z2 readonly onSuccess: (chunk: Chunk.Chunk<A>) => Z3 } ): (self: Take<A, E>) => Z | Z2 | Z3 /** * Folds over the failure cause, success value and end-of-stream marker to * yield a value. * * @since 2.0.0 * @category destructors */ <A, E, Z, Z2, Z3>( self: Take<A, E>, options: { readonly onEnd: () => Z readonly onFailure: (cause: Cause.Cause<E>) => Z2 readonly onSuccess: (chunk: Chunk.Chunk<A>) => Z3 } ): Z | Z2 | Z3 } = internal.match /** * Effectful version of `Take.fold`. * * Folds over the failure cause, success value and end-of-stream marker to * yield an effect. * * @since 2.0.0 * @category destructors */ export const matchEffect: { /** * Effectful version of `Take.fold`. * * Folds over the failure cause, success value and end-of-stream marker to * yield an effect. * * @since 2.0.0 * @category destructors */ <Z, E2, R, E, Z2, R2, A, Z3, E3, R3>( options: { readonly onEnd: Effect.Effect<Z, E2, R> readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<Z2, E2, R2> readonly onSuccess: (chunk: Chunk.Chunk<A>) => Effect.Effect<Z3, E3, R3> } ): (self: Take<A, E>) => Effect.Effect<Z | Z2 | Z3, E2 | E | E3, R | R2 | R3> /** * Effectful version of `Take.fold`. * * Folds over the failure cause, success value and end-of-stream marker to * yield an effect. * * @since 2.0.0 * @category destructors */ <A, E, Z, E2, R, Z2, R2, Z3, E3, R3>( self: Take<A, E>, options: { readonly onEnd: Effect.Effect<Z, E2, R> readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<Z2, E2, R2> readonly onSuccess: (chunk: Chunk.Chunk<A>) => Effect.Effect<Z3, E3, R3> } ): Effect.Effect<Z | Z2 | Z3, E | E2 | E3, R | R2 | R3> } = internal.matchEffect /** * Creates a `Take` with a single value chunk. * * @since 2.0.0 * @category constructors */ export const of: <A>(value: A) => Take<A> = internal.of /** * Returns an effect that effectfully "peeks" at the success of this take. * * @since 2.0.0 * @category sequencing */ export const tap: { /** * Returns an effect that effectfully "peeks" at the success of this take. * * @since 2.0.0 * @category sequencing */ <A, X, E2, R>(f: (chunk: Chunk.Chunk<A>) => Effect.Effect<X, E2, R>): <E>(self: Take<A, E>) => Effect.Effect<void, E2 | E, R> /** * Returns an effect that effectfully "peeks" at the success of this take. * * @since 2.0.0 * @category sequencing */ <A, E, X, E2, R>(self: Take<A, E>, f: (chunk: Chunk.Chunk<A>) => Effect.Effect<X, E2, R>): Effect.Effect<void, E | E2, R> } = internal.tap