fp-ts-bracket
Version:
Bracket monad for fp-ts
368 lines (367 loc) • 11.3 kB
TypeScript
/**
* The Bracket module provides provides a monadic interface over TE.bracket.
*
* @since 1.0.0
*/
import { Applicative2 } from "fp-ts/lib/Applicative";
import { Apply2 } from "fp-ts/lib/Apply";
import { Chain2 } from "fp-ts/lib/Chain";
import * as E from "fp-ts/lib/Either";
import { FromEither2 } from "fp-ts/lib/FromEither";
import { FromIO2 } from "fp-ts/lib/FromIO";
import { FromTask2 } from "fp-ts/lib/FromTask";
import { Functor2 } from "fp-ts/lib/Functor";
import { IO } from "fp-ts/lib/IO";
import { Monad2 } from "fp-ts/lib/Monad";
import { MonadIO2 } from "fp-ts/lib/MonadIO";
import { MonadTask2 } from "fp-ts/lib/MonadTask";
import { NaturalTransformation22 } from "fp-ts/lib/NaturalTransformation";
import { Pointed2 } from "fp-ts/lib/Pointed";
import * as RNEA from "fp-ts/lib/ReadonlyNonEmptyArray";
import * as T from "fp-ts/lib/Task";
import * as TE from "fp-ts/lib/TaskEither";
/**
* @category type lambdas
* @since 1.0.0
*/
export declare const URI = "Bracket";
/**
* @category type lambdas
* @since 1.0.0
*/
export type URI = typeof URI;
declare module "fp-ts/HKT" {
interface URItoKind2<E, A> {
readonly [URI]: Bracket<E, A>;
}
}
/**
* @category model
* @since 1.0.0
*/
export type Bracket<E, R> = <T>(use: (resource: R) => TE.TaskEither<E, T>) => TE.TaskEither<E, T>;
/**
* Utility type for extraction Resource type from Bracket
*
* @category model
* @since 1.0.0
*/
export type ResourceOf<B extends Bracket<any, any> | Bracket<never, any>> = B extends Bracket<any, infer R> ? R : B extends Bracket<never, infer R> ? R : never;
/**
* @category instances
* @since 1.0.0
*/
export declare const Bracket: <E, R>(acquire: TE.TaskEither<E, R>, dispose: (resource: R) => TE.TaskEither<E, void>) => Bracket<E, R>;
/**
* @category utils
* @since 1.0.0
*/
export declare const use: <E, R, T>(use: (r: R) => TE.TaskEither<E, T>) => (bracket: Bracket<E, R>) => TE.TaskEither<E, T>;
/**
* @category instances
* @since 1.0.0
*/
export declare const Pointed: Pointed2<URI>;
/**
* @category constructors
* @since 1.0.0
*/
export declare const of: <E = never, T = never>(x: T) => Bracket<E, T>;
/**
* @category utils
* @since 1.0.0
*/
export declare const noDispose: <E>() => TE.TaskEither<E, undefined>;
/**
* @category conversions
* @since 1.0.0
*/
export declare const fromIO: <E, R>(fa: IO<R>) => Bracket<E, R>;
/**
* @category instances
* @since 1.0.0
*/
export declare const FromIO: FromIO2<URI>;
/**
* @category conversions
* @since 1.0.0
*/
export declare const fromTask: <E, R>(fa: T.Task<R>) => Bracket<E, R>;
/**
* @category instances
* @since 1.0.0
*/
export declare const FromTask: FromTask2<URI>;
/**
* @category conversions
* @since 1.0.0
*/
export declare const fromTaskEither: NaturalTransformation22<TE.URI, URI>;
/**
* alias for fromTaskEither
*
* @category constructors
* @since 1.0.0
*/
export declare const fromAcquire: NaturalTransformation22<"TaskEither", "Bracket">;
/**
* @category conversions
* @since 1.0.0
*/
export declare const fromEither: <E, R>(fa: E.Either<E, R>) => Bracket<E, R>;
/**
* @category instances
* @since 1.0.0
*/
export declare const FromEither: FromEither2<URI>;
/**
* @category instances
* @since 1.0.0
*/
export declare const Functor: Functor2<URI>;
/**
* @category mapping
* @since 1.0.0
*/
export declare const map: <A, B>(f: (a: A) => B) => <E>(fa: Bracket<E, A>) => Bracket<E, B>;
/**
* Maps the value to the specified constant value.
*
* @category mapping
* @since 1.0.0
*/
export declare const as: {
<A>(a: A): <E, _>(self: Bracket<E, _>) => Bracket<E, A>;
<E, A, _>(self: Bracket<E, _>, a: A): Bracket<E, A>;
};
/**
* @category mapping
* @since 1.0.0
*/
export declare const flap: <A>(a: A) => <E, B>(fab: Bracket<E, (a: A) => B>) => Bracket<E, B>;
/**
* Maps every value to the void constant value.
*
* @category mapping
* @since 1.0.0
*/
export declare const asUnit: <E, _>(self: Bracket<E, _>) => Bracket<E, void>;
/**
* @category instances
* @since 1.0.0
*/
export declare const ApplySeq: Apply2<URI>;
/**
* Runs computations sequentially.
*
* @category instances
* @since 1.0.0
*/
export declare const ApplicativeSeq: Applicative2<URI>;
/**
* @category apply
* @since 1.0.0
*/
export declare const apFirstSeq: <E, B>(second: Bracket<E, B>) => <A>(first: Bracket<E, A>) => Bracket<E, A>;
/**
* @category apply
* @since 1.0.0
*/
export declare const apSecondSeq: <E, B>(second: Bracket<E, B>) => <A>(first: Bracket<E, A>) => Bracket<E, B>;
/**
* @category sequencing
* @since 1.0.0
*/
export declare const sequenceTSeq: <E, T extends Bracket<E, any>[]>(...t: T & {
readonly 0: Bracket<E, any>;
}) => Bracket<E, { [K in keyof T]: [T[K]] extends [Bracket<E, infer A>] ? A : never; }>;
/**
* @category sequencing
* @since 1.0.0
*/
export declare const sequenceSSeq: <E, NER extends Record<string, Bracket<E, any>>>(r: (keyof NER extends never ? never : NER) & Record<string, Bracket<E, any>>) => Bracket<E, { [K in keyof NER]: [NER[K]] extends [Bracket<any, infer A>] ? A : never; }>;
/**
* @category instances
* @since 1.0.0
*/
export declare const ApplyPar: Apply2<URI>;
/**
* @category instances
* @since 1.0.0
*/
export declare const ApplicativePar: Applicative2<URI>;
/**
* @category apply
* @since 1.0.0
*/
export declare const ap: <E, A>(fa: Bracket<E, A>) => <B>(fab: Bracket<E, (a: A) => B>) => Bracket<E, B>;
/**
* @category apply
* @since 1.0.0
*/
export declare const apFirst: <E, B>(second: Bracket<E, B>) => <A>(first: Bracket<E, A>) => Bracket<E, A>;
/**
* @category apply
* @since 1.0.0
*/
export declare const apSecond: <E, B>(second: Bracket<E, B>) => <A>(first: Bracket<E, A>) => Bracket<E, B>;
/**
* @category sequencing
* @since 1.0.0
*/
export declare const sequenceT: <E, T extends Bracket<E, any>[]>(...t: T & {
readonly 0: Bracket<E, any>;
}) => Bracket<E, { [K in keyof T]: [T[K]] extends [Bracket<E, infer A>] ? A : never; }>;
/**
* @category sequencing
* @since 1.0.0
*/
export declare const sequenceS: <E, NER extends Record<string, Bracket<E, any>>>(r: (keyof NER extends never ? never : NER) & Record<string, Bracket<E, any>>) => Bracket<E, { [K in keyof NER]: [NER[K]] extends [Bracket<any, infer A>] ? A : never; }>;
/**
* @category instances
* @since 1.0.0
*/
export declare const Chain: Chain2<URI>;
/**
* @category instances
* @since 1.0.0
*/
export declare const Monad: Monad2<URI>;
/**
* @category instances
* @since 1.0.0
*/
export declare const MonadIO: MonadIO2<URI>;
/**
* @category instances
* @since 1.0.0
*/
export declare const MonadTask: MonadTask2<URI>;
/**
* @category sequencing
* @since 1.0.0
*/
export declare const flatMap: <E, A, B>(f: (a: A) => Bracket<E, B>) => (fa: Bracket<E, A>) => Bracket<E, B>;
/**
* Composes computations in sequence, using the return value of one computation to determine the next computation and
* keeping only the result of the first.
*
* @category combinators
* @since 1.0.0
*/
export declare const tap: {
<A, E, _>(self: Bracket<E, A>, f: (a: A) => Bracket<E, _>): Bracket<E, A>;
<A, E, _>(f: (a: A) => Bracket<E, _>): (self: Bracket<E, A>) => Bracket<E, A>;
};
/**
* @category combinators
* @since 1.0.0
*/
export declare const tapIO: {
<A, _>(f: (a: A) => IO<_>): <E>(self: Bracket<E, A>) => Bracket<E, A>;
<E, A, _>(self: Bracket<E, A>, f: (a: A) => IO<_>): Bracket<E, A>;
};
/**
* @category combinators
* @since 1.0.0
*/
export declare const tapEither: {
<A, E2, _>(f: (a: A) => E.Either<E2, _>): <E1>(self: Bracket<E1, A>) => Bracket<E2 | E1, A>;
<E1, A, E2, _>(self: Bracket<E1, A>, f: (a: A) => E.Either<E2, _>): Bracket<E1 | E2, A>;
};
/**
* @category combinators
* @since 1.0.0
*/
export declare const tapTask: {
<A, _>(f: (a: A) => T.Task<_>): <E>(self: Bracket<E, A>) => Bracket<E, A>;
<E, A, _>(self: Bracket<E, A>, f: (a: A) => T.Task<_>): Bracket<E, A>;
};
/**
* @category do notation
* @since 1.0.0
*/
export declare const Do: Bracket<never, {}>;
/**
* @category do notation
* @since 1.0.0
*/
export declare const bind: <N extends string, A, E, B>(name: Exclude<N, keyof A>, f: (a: A) => Bracket<E, B>) => (ma: Bracket<E, A>) => Bracket<E, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
/**
* @category do notation
* @since 1.0.0
*/
export declare const bindTo: <N extends string>(name: N) => <E, A>(fa: Bracket<E, A>) => Bracket<E, { readonly [K in N]: A; }>;
declare const _let: <N extends string, A, B>(name: Exclude<N, keyof A>, f: (a: A) => B) => <E>(fa: Bracket<E, A>) => Bracket<E, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
export {
/**
* @category do notation
* @since 1.0.0
*/
_let as let, };
/**
* @category do notation
* @since 1.0.0
*/
export declare const apS: <N extends string, A, E, B>(name: Exclude<N, keyof A>, fb: Bracket<E, B>) => (fa: Bracket<E, A>) => Bracket<E, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
/**
* @category do notation
* @since 1.0.0
*/
export declare const apSSeq: <N extends string, A, E, B>(name: Exclude<N, keyof A>, fb: Bracket<E, B>) => (fa: Bracket<E, A>) => Bracket<E, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
/**
* Equivalent to `ReadonlyNonEmptyArray#traverseWithIndex(ApplicativePar)`.
*
* @category traversing
* @since 1.0.0
*/
export declare const traverseReadonlyNonEmptyArrayWithIndex: <A, E, B>(f: (i: number, a: A) => Bracket<E, B>) => (ta: RNEA.ReadonlyNonEmptyArray<A>) => Bracket<E, RNEA.ReadonlyNonEmptyArray<B>>;
/**
* Equivalent to `ReadonlyArray#traverseWithIndex(ApplicativePar)`.
*
* @category traversing
* @since 1.0.0
*/
export declare const traverseReadonlyArrayWithIndex: <A, E, B>(f: (i: number, a: A) => Bracket<E, B>) => (ta: readonly A[]) => Bracket<E, readonly B[]>;
/**
* Equivalent to `ReadonlyArray#traverse(ApplicativePar)`.
*
* @category traversing
* @since 1.0.0
*/
export declare const traverseArray: <A, FE, B>(f: (a: A) => Bracket<FE, B>) => (ta: readonly A[]) => Bracket<FE, readonly B[]>;
/**
* Equivalent to `ReadonlyArray#sequence(ApplicativePar)`.
*
* @category traversing
* @since 1.0.0
*/
export declare const sequenceArray: <E, A>(ta: readonly Bracket<E, A>[]) => Bracket<E, readonly A[]>;
/**
* Equivalent to `ReadonlyNonEmptyArray#traverseWithIndex(ApplicativeSeq)`.
*
* @category traversing
* @since 1.0.0
*/
export declare const traverseSeqReadonlyNonEmptyArrayWithIndex: <A, E, B>(f: (i: number, a: A) => Bracket<E, B>) => (ta: RNEA.ReadonlyNonEmptyArray<A>) => Bracket<E, RNEA.ReadonlyNonEmptyArray<B>>;
/**
* Equivalent to `ReadonlyArray#traverseWithIndex(ApplicativeSeq)`.
*
* @category traversing
* @since 1.0.0
*/
export declare const traverseSeqReadonlyArrayWithIndex: <A, E, B>(f: (i: number, a: A) => Bracket<E, B>) => (ta: readonly A[]) => Bracket<E, readonly B[]>;
/**
* Equivalent to `ReadonlyArray#traverse(ApplicativeSeq)`.
*
* @category traversing
* @since 1.0.0
*/
export declare const traverseSeqArray: <A, FE, B>(f: (a: A) => Bracket<FE, B>) => (ta: readonly A[]) => Bracket<FE, readonly B[]>;
/**
* Equivalent to `ReadonlyArray#sequence(ApplicativeSeq)`.
*
* @category traversing
* @since 1.0.0
*/
export declare const sequenceSeqArray: <E, A>(ta: readonly Bracket<E, A>[]) => Bracket<E, readonly A[]>;