@typed/fp/cjs/ResumeOption.d.ts

Data Structures and Resources for fp-ts

/**
 * ResumeOption is an OptionT of [Resume](./Resume.ts.md)
 * @since 0.9.2
 */
import { Alt1 } from 'fp-ts/Alt';
import { Alternative1 } from 'fp-ts/Alternative';
import { Applicative1 } from 'fp-ts/Applicative';
import { Apply1 } from 'fp-ts/Apply';
import { Chain1 } from 'fp-ts/Chain';
import { ChainRec1 } from 'fp-ts/ChainRec';
import * as E from 'fp-ts/Either';
import { Functor1 } from 'fp-ts/Functor';
import { Monad1 } from 'fp-ts/Monad';
import * as O from 'fp-ts/Option';
import { Pointed1 } from 'fp-ts/Pointed';
import { MonadRec1 } from './MonadRec';
import * as R from './Resume';
/**
 * @since 0.9.2
 * @category Model
 */
export declare type ResumeOption<A> = R.Resume<O.Option<A>>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const alt: <A>(second: import("fp-ts/function").Lazy<R.Resume<O.Option<A>>>) => (first: R.Resume<O.Option<A>>) => R.Resume<O.Option<A>>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const ap: <A>(fa: R.Resume<O.Option<A>>) => <B>(fab: R.Resume<O.Option<(a: A) => B>>) => R.Resume<O.Option<B>>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chain: <A, B>(f: (a: A) => R.Resume<O.Option<B>>) => (ma: R.Resume<O.Option<A>>) => R.Resume<O.Option<B>>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainNullableK: <A, B>(f: (a: A) => B | null | undefined) => (ma: R.Resume<O.Option<A>>) => R.Resume<O.Option<NonNullable<B>>>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainOptionK: <A, B>(f: (a: A) => O.Option<B>) => (ma: R.Resume<O.Option<A>>) => R.Resume<O.Option<B>>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromEither: <A>(e: E.Either<unknown, A>) => R.Resume<O.Option<A>>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromResume: <A>(ma: R.Resume<A>) => R.Resume<O.Option<A>>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromNullable: <A>(a: A) => R.Resume<O.Option<NonNullable<A>>>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromNullableK: <A extends readonly unknown[], B>(f: (...a: A) => B | null | undefined) => (...a: A) => R.Resume<O.Option<NonNullable<B>>>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromOptionK: <A extends readonly unknown[], B>(f: (...a: A) => O.Option<B>) => (...a: A) => R.Resume<O.Option<B>>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromPredicate: {
    <A, B extends A>(refinement: import("fp-ts/Refinement").Refinement<A, B>): (a: A) => R.Resume<O.Option<B>>;
    <A_1>(predicate: import("fp-ts/Predicate").Predicate<A_1>): <B_1 extends A_1>(b: B_1) => R.Resume<O.Option<B_1>>;
};
/**
 * @since 0.9.2
 * @category Deconstructor
 */
export declare const getOrElse: <A>(onNone: import("fp-ts/function").Lazy<A>) => (fa: R.Resume<O.Option<A>>) => R.Resume<A>;
/**
 * @since 0.9.2
 * @category Deconstructor
 */
export declare const getOrElseE: <A>(onNone: import("fp-ts/function").Lazy<R.Resume<A>>) => (fa: R.Resume<O.Option<A>>) => R.Resume<A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const map: <A, B>(f: (a: A) => B) => (fa: R.Resume<O.Option<A>>) => R.Resume<O.Option<B>>;
/**
 * @since 0.9.2
 * @category Deconstructor
 */
export declare const match: <B, A>(onNone: () => B, onSome: (a: A) => B) => (ma: R.Resume<O.Option<A>>) => R.Resume<B>;
/**
 * @since 0.9.2
 * @category Deconstructor
 */
export declare const matchE: <B, A>(onNone: () => R.Resume<B>, onSome: (a: A) => R.Resume<B>) => (ma: R.Resume<O.Option<A>>) => R.Resume<B>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const some: <A>(a: A) => R.Resume<O.Option<A>>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const zero: <A>() => R.Resume<O.Option<A>>;
/**
 * @since 0.9.2
 * @category URI
 */
export declare const URI = "@typed/fp/ResumeOption";
/**
 * @since 0.9.2
 * @category URI
 */
export declare type URI = typeof URI;
declare module 'fp-ts/HKT' {
    interface URItoKind<A> {
        [URI]: ResumeOption<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 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: Chain1<URI>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainRec: <A, B>(f: (value: A) => ResumeOption<E.Either<A, B>>) => (value: A) => R.Resume<O.Option<B>>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const ChainRec: ChainRec1<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Monad: Monad1<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 Alternative: Alternative1<URI>;
//# sourceMappingURL=ResumeOption.d.ts.map