@typed/fp/esm/Env.d.ts

Data Structures and Resources for fp-ts

import { Disposable } from '@most/types';
import * as Alt_ from 'fp-ts/Alt';
import * as FpApplicative from 'fp-ts/Applicative';
import * as Ap from 'fp-ts/Apply';
import * as FpChain from 'fp-ts/Chain';
import { ChainRec2 } from 'fp-ts/ChainRec';
import * as E from 'fp-ts/Either';
import * as FIO from 'fp-ts/FromIO';
import * as FR from 'fp-ts/FromReader';
import * as FT from 'fp-ts/FromTask';
import * as FN from 'fp-ts/function';
import { Functor2 } from 'fp-ts/Functor';
import * as IO from 'fp-ts/IO';
import { Monad2 } from 'fp-ts/Monad';
import { Pointed2 } from 'fp-ts/Pointed';
import * as Re from 'fp-ts/Reader';
import * as Task from 'fp-ts/Task';
import { FromResume2 } from './FromResume';
import { ArgsOf, Arity1 } from './function';
import { Intersect } from './HKT';
import { MonadRec2 } from './MonadRec';
import * as P from './Provide';
import * as R from './Resume';
/**
 * Env is specialization of Reader<R, Resume<A>>
 * @since 0.9.2
 * @category Model
 */
export interface Env<R, A> extends Re.Reader<R, R.Resume<A>> {
}
/**
 * @since 0.9.2
 * @category Type-level
 */
export declare type RequirementsOf<A> = [A] extends [Env<infer R, any>] ? R : [A] extends [FN.FunctionN<any, Env<infer R, any>>] ? R : never;
/**
 * @since 0.9.2
 * @category Type-level
 */
export declare type ValueOf<A> = A extends Env<any, infer R> ? R : A extends FN.FunctionN<any, Env<any, infer R>> ? R : never;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const ap: <R, A>(fa: Env<R, A>) => <B>(fab: Env<R, Arity1<A, B>>) => Env<R, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apW: <R1, A>(fa: Env<R1, A>) => <R2, B>(fab: Env<R2, Arity1<A, B>>) => Env<R1 & R2, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chain: <A, R, B>(f: (a: A) => Re.Reader<R, R.Resume<B>>) => (ma: Re.Reader<R, R.Resume<A>>) => Re.Reader<R, R.Resume<B>>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainW: <A, R1, B>(f: (a: A) => Env<R1, B>) => <R2>(ma: Env<R2, A>) => Env<R1 & R2, B>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromReader: <R, A>(ma: Re.Reader<R, A>) => Env<R, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const map: <A, B>(f: (a: A) => B) => <R>(fa: Env<R, A>) => Env<R, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const tap: <A>(f: (a: A) => any) => <R>(fa: Env<R, A>) => Env<R, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const constant: <A>(a: A) => <R>(fa: Env<R, unknown>) => Env<R, A>;
/**
 * @since 0.9.2
 * @category Model
 */
export declare type Of<A> = Env<unknown, A>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const of: <A>(a: A) => Of<A>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const asksIOK: <R, A>(f: (r: R) => IO.IO<A>) => Env<R, A>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const asksTaskK: <R, A>(f: (r: R) => Task.Task<A>) => Env<R, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare function chainRec<F extends (value: any) => Env<any, E.Either<any, any>>>(f: F): (value: ArgsOf<F>[0]) => Env<RequirementsOf<ReturnType<F>>, [
    ValueOf<ReturnType<F>>
] extends [E.Either<any, infer R>] ? R : never>;
/**
 * @since 0.9.2
 * @category URI
 */
export declare const URI = "@typed/fp/Env";
/**
 * @since 0.9.2
 * @category URI
 */
export declare type URI = typeof URI;
declare module 'fp-ts/HKT' {
    interface URItoKind2<E, A> {
        [URI]: Env<E, A>;
    }
}
declare module './HKT' {
    interface URItoVariance {
        [URI]: V<E, Contravariant>;
    }
}
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Pointed: Pointed2<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Functor: Functor2<URI>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const flap: <A>(a: A) => <E, B>(fab: Env<E, (a: A) => B>) => Env<E, B>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Apply: Ap.Apply2<URI>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apS: <N extends string, A, E, B>(name: Exclude<N, keyof A>, fb: Env<E, B>) => (fa: Env<E, A>) => Env<E, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apSW: <N extends string, A, E1, B>(name: Exclude<N, keyof A>, fb: Env<E1, B>) => <E2>(fa: Env<E2, A>) => Env<E1 & E2, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apT: <E, B>(fb: Env<E, B>) => <A extends readonly unknown[]>(fas: Env<E, A>) => Env<E, readonly [...A, B]>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apTW: <E1, B>(fb: Env<E1, B>) => <E2, A extends readonly unknown[]>(fas: Env<E2, A>) => Env<E1 & E2, readonly [...A, B]>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apFirst: <E, B>(second: Env<E, B>) => <A>(first: Env<E, A>) => Env<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apFirstW: <E1, B>(second: Env<E1, B>) => <E2, A>(first: Env<E2, A>) => Env<E1 & E2, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apSecond: <E, B>(second: Env<E, B>) => <A>(first: Env<E, A>) => Env<E, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apSecondW: <E1, B>(second: Env<E1, B>) => <E2, A>(first: Env<E2, A>) => Env<E1 & E2, B>;
/**
 * @since 0.9.2
 * @category Typeclass Constructor
 */
export declare const getSemigroup: <A, E>(S: import("fp-ts/Semigroup").Semigroup<A>) => import("fp-ts/Semigroup").Semigroup<Env<E, A>>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Applicative: FpApplicative.Applicative2<URI>;
/**
 * @since 0.9.2
 * @category Typeclass Constructor
 */
export declare const getMonoid: <A, E>(M: import("fp-ts/Monoid").Monoid<A>) => import("fp-ts/Monoid").Monoid<Env<E, A>>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Chain: FpChain.Chain2<URI>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainFirst: <A, E, B>(f: (a: A) => Env<E, B>) => (first: Env<E, A>) => Env<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainFirstW: <A, E1, B>(f: (a: A) => Env<E1, B>) => <E2>(first: Env<E2, A>) => Env<E1 & E2, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const flattenW: <E1, E2, A>(env: Env<E1, Env<E2, A>>) => Env<E1 & E2, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const flatten: <E, A>(env: Env<E, Env<E, A>>) => Env<E, A>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Monad: Monad2<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const ChainRec: ChainRec2<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const MonadRec: MonadRec2<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const FromReader: FR.FromReader2<URI>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const raceW: <E1, A>(a: Env<E1, A>) => <E2, B>(b: Env<E2, B>) => Env<E1 & E2, A | B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const race: <E, A>(a: Env<E, A>) => <B>(b: Env<E, B>) => Env<E, A | B>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Alt: Alt_.Alt2<URI>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const alt: <E, A>(second: FN.Lazy<Env<E, A>>) => (first: Env<E, A>) => Env<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const altW: <E1, A>(snd: FN.Lazy<Env<E1, A>>) => <E2>(fst: Env<E2, A>) => Env<E1 & E2, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const altAll: <E, A>(startWith: Env<E, A>) => (as: readonly Env<E, A>[]) => Env<E, A>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromIO: <A>(fa: IO.IO<A>) => Env<unknown, A>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const FromIO: FIO.FromIO2<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const FromTask: FT.FromTask2<URI>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromTask: <A, E = unknown>(fa: Task.Task<A>) => Env<E, A>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromResume: <A, E = unknown>(resume: R.Resume<A>) => Env<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const FromResume: FromResume2<URI>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const useSome: <E1>(provided: E1) => <E2, A>(env: Env<E1 & E2, A>) => Env<E2, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const provideSome: <E1>(provided: E1) => <E2, A>(env: Env<E1 & E2, A>) => Env<E2, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const useAll: <E1>(provided: E1) => <A>(env: Env<E1, A>) => Env<unknown, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const provideAll: <E1>(provided: E1) => <A>(env: Env<E1, A>) => Env<unknown, A>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const UseSome: P.UseSome2<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const UseAll: P.UseAll2<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const ProvideSome: P.ProvideSome2<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const ProvideAll: P.ProvideAll2<URI>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const provideAllWith: <R, A>(provider: Env<R, A>) => <B>(hkt: Env<A, B>) => Env<R, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const useAllWith: <R, A>(provider: Env<R, A>) => <B>(hkt: Env<A, B>) => Env<R, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const provideSomeWith: <E1, A>(provider: Env<E1, A>) => P.Provider2<"@typed/fp/Env", A, E1>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const useSomeWith: <E1, A>(provider: Env<E1, A>) => P.Provider2<"@typed/fp/Env", A, E1>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const askAndUse: <E, B>(hkt: Env<E, B>) => Env<E, Env<unknown, B>>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const askAndProvide: <E, B>(hkt: Env<E, B>) => Env<E, Env<unknown, B>>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const toResume: <E, B>(hkt: Env<E, B>) => Env<E, R.Resume<B>>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Provide: P.Provide2<URI>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const Do: Env<unknown, {}>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const bindTo: <N extends string>(name: N) => <E, A>(fa: Env<E, A>) => Env<E, { readonly [K in N]: A; }>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const bind: <N extends string, A, E, B>(name: Exclude<N, keyof A>, f: (a: A) => Env<E, B>) => (ma: Env<E, A>) => Env<E, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const bindW: <N extends string, A, E1, B>(name: Exclude<N, keyof A>, f: (a: A) => Env<E1, B>) => <E2>(ma: Env<E2, A>) => Env<E1 & E2, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const tupled: <E, A>(fa: Env<E, A>) => Env<E, readonly [A]>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const ask: <R>() => Env<R, R>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const asks: <R, A>(f: (r: R) => A) => Env<R, A>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const asksE: <R, E, A>(f: (r: R) => Env<E, A>) => Env<E & R, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainReaderK: <A, R, B>(f: (a: A) => Re.Reader<R, B>) => (ma: Env<R, A>) => Env<R, B>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromReaderK: <A extends readonly unknown[], R, B>(f: (...a: A) => Re.Reader<R, B>) => (...a: A) => Env<R, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainFirstResumeK: <A, B>(f: (value: A) => R.Resume<B>) => <E>(hkt: Env<E, A>) => Env<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainResumeK: <A, B>(f: (value: A) => R.Resume<B>) => <E>(hkt: Env<E, A>) => Env<E, B>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromResumeK: <A extends readonly any[], B>(f: (...args: A) => R.Resume<B>) => <E>(...args: A) => Env<E, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainFirstTaskK: <A, B>(f: (a: A) => Task.Task<B>) => <E>(first: Env<E, A>) => Env<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainTaskK: <A, B>(f: (a: A) => Task.Task<B>) => <E>(first: Env<E, A>) => Env<E, B>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromTaskK: <A extends readonly unknown[], B>(f: (...a: A) => Task.Task<B>) => <E>(...a: A) => Env<E, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainFirstIOK: <A, B>(f: (a: A) => IO.IO<B>) => <E>(first: Env<E, A>) => Env<E, A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainIOK: <A, B>(f: (a: A) => IO.IO<B>) => <E>(first: Env<E, A>) => Env<E, B>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromIOK: <A extends readonly unknown[], B>(f: (...a: A) => IO.IO<B>) => <E>(...a: A) => Env<E, B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const zip: <E, A>(ta: readonly Env<E, A>[]) => Env<E, readonly A[]>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const zipW: <A extends readonly Env<any, any>[]>(envs: A) => Env<Intersect<{ [K in keyof A]: RequirementsOf<A[K]>; }, unknown>, { [K_1 in keyof A]: ValueOf<A[K_1]>; }>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const combineAll: <A extends readonly Env<any, any>[]>(...envs: A) => Env<Intersect<{ [K in keyof A]: RequirementsOf<A[K]>; }, unknown>, { [K_1 in keyof A]: ValueOf<A[K_1]>; }>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare const combineStruct: <Props extends Readonly<Record<string, Env<any, any>>>>(props: Props) => Env<unknown, { readonly [K in keyof Props]: ValueOf<Props[K]>; }>;
/**
 * @since 0.9.2
 * @category Execution
 */
export declare const runWith: <A>(f: (value: A) => Disposable) => <E>(requirements: E) => (env: Env<E, A>) => Disposable;
/**
 * @since 0.9.2
 * @category Execution
 */
export declare const execWith: <E>(requirements: E) => (env: Env<E, any>) => Disposable;
/**
 * Construct an Env to a lazily-defined Env-based effect that must be provided later.
 * Does not support functions which require type-parameters as they will resolve to unknown, due
 * to limitations in TS, if you need this maybe use [asksE](#askse)
 * @since 0.9.2
 * @category Constructor
 */
export declare const op: <F extends (...args: readonly any[]) => Env<any, any>>() => <K extends PropertyKey>(key: K) => {
    (...args: ArgsOf<F>): Env<RequirementsOf<ReturnType<F>> & { readonly [_ in K]: F; }, ValueOf<ReturnType<F>>>;
    readonly key: K;
};
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const toResumeK: <Args extends readonly any[], E, A>(envK: (...args: Args) => Env<E, A>) => Env<E, (...args: Args) => R.Resume<A>>;
//# sourceMappingURL=Env.d.ts.map