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

Data Structures and Resources for fp-ts

/**
 *
 * `Resume` is a possibly synchronous or asynchronous effect type. Conceptually you can think of
 * `Resume` as a union between the `IO` and `Task` monads w/ cancelation. The `Disposable` interface is
 * borrowed from `@most/core`'s internal types and makes it easy to interoperate. Using `Disposable`
 * makes it easy to reuse the `@most/scheduler` package for providing scheduling consistent with any
 * other most-based workflows you have.
 *
 * The beauty of `Resume` is that it can do work as fast as possible without delay. Sync when possible
 * but async when needed allows you to unify your sync/async workflows using a single monad w/ easy
 * interop with your existing IO/Task allowing for cancelation when required.
 * @since 0.9.2
 */
import { Disposable } from '@most/types';
import { Alt1 } from 'fp-ts/Alt';
import { Applicative1 } from 'fp-ts/Applicative';
import { Apply1 } from 'fp-ts/Apply';
import * as Ch from 'fp-ts/Chain';
import { ChainRec1 } from 'fp-ts/ChainRec';
import * as E from 'fp-ts/Either';
import { FromIO1 } from 'fp-ts/FromIO';
import { FromTask1 } from 'fp-ts/FromTask';
import { Functor1 } from 'fp-ts/Functor';
import { IO } from 'fp-ts/IO';
import { Monad1 } from 'fp-ts/Monad';
import { Pointed1 } from 'fp-ts/Pointed';
import { Task } from 'fp-ts/Task';
import { Arity1 } from './function';
import { MonadRec1 } from './MonadRec';
/**
 * @since 0.9.2
 * @category Model
 */
export declare type Resume<A> = Sync<A> | Async<A>;
/**
 * @since 0.9.2
 * @category Type-level
 */
export declare type ValueOf<A> = [A] extends [Resume<infer R>] ? R : never;
/**
 * @since 0.9.2
 * @category Model
 */
export interface Async<A> {
    readonly _tag: 'async';
    readonly resume: AsyncResume<A>;
}
/**
 * @since 0.9.2
 * @category Model
 */
export declare type AsyncResume<A> = (resume: (value: A) => Disposable) => Disposable;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const async: <A>(resume: AsyncResume<A>) => Async<A>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromTask: <A>(task: Task<A>) => Async<A>;
/**
 * @since 0.9.2
 * @category Model
 */
export interface Sync<A> {
    readonly _tag: 'sync';
    readonly resume: IO<A>;
}
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const sync: <A>(resume: IO<A>) => Sync<A>;
/**
 * @since 0.9.2
 * @category Refinement
 */
export declare const isSync: <A>(resume: Resume<A>) => resume is Sync<A>;
/**
 * @since 0.9.2
 * @category Refinement
 */
export declare const isAsync: <A>(resume: Resume<A>) => resume is Async<A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const ap: <A>(fa: Resume<A>) => <B>(fab: Resume<Arity1<A, B>>) => Resume<B>;
/**
 * @since 0.9.2
 * @category Deconstructor
 */
export declare const run: <A>(f: Arity1<A, Disposable>) => (resume: Resume<A>) => Disposable;
/**
 * @since 0.9.2
 * @category Deconstructor
 */
export declare const start: <A>(f: Arity1<A, any>) => (resume: Resume<A>) => Disposable;
/**
 * @since 0.9.2
 * @category Deconstructor
 */
export declare const exec: (resume: Resume<any>) => Disposable;
/**
 * @since 0.9.2
 * @category Model
 */
export declare type DisposableTask<A> = () => DisposablePromise<A>;
/**
 * @since 0.9.2
 * @category Model
 */
export declare type DisposablePromise<A> = Promise<A> & Disposable;
/**
 * @since 0.9.2
 * @category Deconstructor
 */
export declare const toTask: <A>(resume: Resume<A>) => DisposableTask<A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chain: <A, B>(f: Arity1<A, Resume<B>>) => (resume: Resume<A>) => Resume<B>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const of: <A>(a: A) => Sync<A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainRec: <A, B>(f: Arity1<A, Resume<E.Either<A, B>>>) => (value: A) => Resume<B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const race: <A>(ra: Resume<A>) => <B>(rb: Resume<B>) => Resume<A | B>;
/**
 * @since 0.9.2
 * @category URI
 */
export declare const URI = "@typed/fp/Resume";
/**
 * @since 0.9.2
 * @category URI
 */
export declare type URI = typeof URI;
declare module 'fp-ts/HKT' {
    interface URItoKind<A> {
        [URI]: Resume<A>;
    }
}
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Pointed: Pointed1<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Functor: Functor1<URI>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const map: <A, B>(f: (a: A) => B) => (fa: Resume<A>) => Resume<B>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Apply: Apply1<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Applicative: Applicative1<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Chain: Ch.Chain1<URI>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainFirst: <A, B>(f: (a: A) => Resume<B>) => (first: Resume<A>) => Resume<A>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Monad: Monad1<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const ChainRec: ChainRec1<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const MonadRec: MonadRec1<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Alt: Alt1<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const FromIO: FromIO1<URI>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromIO: import("fp-ts/NaturalTransformation").NaturalTransformation11<"IO", "@typed/fp/Resume">;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const FromTask: FromTask1<URI>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const Do: Resume<{}>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const bindTo: <N extends string>(name: N) => <A>(fa: Resume<A>) => Resume<{ [K in N]: A; }>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const bind: <N extends string, A, B>(name: Exclude<N, keyof A>, f: (a: A) => Resume<B>) => (ma: Resume<A>) => Resume<{ readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const tupled: <A>(fa: Resume<A>) => Resume<readonly [A]>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const traverseReadonlyArray: <A, B>(f: (a: A) => Resume<B>) => (ta: readonly A[]) => Resume<readonly B[]>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const traverseReadonlyArrayWithIndex: <A, B>(f: (i: number, a: A) => Resume<B>) => (ta: readonly A[]) => Resume<readonly B[]>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const zip: <A>(ta: readonly Resume<A>[]) => Resume<readonly A[]>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainFirstTaskK: <A, B>(f: (a: A) => Task<B>) => (first: Resume<A>) => Resume<A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainTaskK: <A, B>(f: (a: A) => Task<B>) => (first: Resume<A>) => Resume<B>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromTaskK: <A extends readonly unknown[], B>(f: (...a: A) => Task<B>) => (...a: A) => Resume<B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainFirstIOK: <A, B>(f: (a: A) => IO<B>) => (first: Resume<A>) => Resume<A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainIOK: <A, B>(f: (a: A) => IO<B>) => (first: Resume<A>) => Resume<B>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromIOK: <A extends readonly unknown[], B>(f: (...a: A) => IO<B>) => (...a: A) => Resume<B>;
/**
 * @since 0.9.2
 * @category Typeclass Constructor
 */
export declare const getMonoid: <A>(M: import("fp-ts/Monoid").Monoid<A>) => import("fp-ts/Monoid").Monoid<Resume<A>>;
//# sourceMappingURL=Resume.d.ts.map