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

Data Structures and Resources for fp-ts

/**
 * Data is an ADT which allows you to represent all the states involved in loading a
 * piece of data asynchronously.
 *
 * @since 0.9.2
 */
import * as AD from 'fp-ts/Alt';
import * as Alternative_ from 'fp-ts/Alternative';
import * as App from 'fp-ts/Applicative';
import * as Ap from 'fp-ts/Apply';
import * as Ch from 'fp-ts/Chain';
import { Compactable1 } from 'fp-ts/Compactable';
import * as Ei from 'fp-ts/Either';
import { Eq } from 'fp-ts/Eq';
import { Filterable1 } from 'fp-ts/Filterable';
import { Foldable1 } from 'fp-ts/Foldable';
import { Lazy } from 'fp-ts/function';
import * as F from 'fp-ts/Functor';
import { HKT } from 'fp-ts/HKT';
import { Monad1 } from 'fp-ts/Monad';
import { Monoid } from 'fp-ts/Monoid';
import * as O from 'fp-ts/Option';
import { Pointed1 } from 'fp-ts/Pointed';
import { Predicate } from 'fp-ts/Predicate';
import { Semigroup } from 'fp-ts/Semigroup';
import { Separated } from 'fp-ts/Separated';
import { Show } from 'fp-ts/Show';
import { Traversable1 } from 'fp-ts/Traversable';
import * as P from './Progress';
/**
 * @since 0.9.2
 * @category Model
 */
export declare type Data<A> = NoData | Loading | Refresh<A> | Replete<A>;
/**
 * @since 0.9.2
 * @category Type-level
 */
export declare type Value<A> = [A] extends [Data<infer R>] ? R : never;
/**
 * @since 0.9.2
 * @category Refinement
 */
export declare const isNoData: <A>(data: Data<A>) => data is NoData;
/**
 * @since 0.9.2
 * @category Refinement
 */
export declare const isLoading: <A>(data: Data<A>) => data is Loading;
/**
 * @since 0.9.2
 * @category Refinement
 */
export declare const isRefresh: <A>(data: Data<A>) => data is Refresh<A>;
/**
 * @since 0.9.2
 * @category Refinement
 */
export declare const isReplete: <A>(data: Data<A>) => data is Replete<A>;
/**
 * @since 0.9.2
 * @category Refinement
 */
export declare const hasValue: <A>(data: Data<A>) => data is Refresh<A> | Replete<A>;
/**
 * @since 0.9.2
 * @category Model
 */
export interface NoData {
    readonly _tag: 'NoData';
}
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const noData: NoData;
/**
 * @since 0.9.2
 * @category Model
 */
export interface Loading {
    readonly _tag: 'Loading';
    readonly progress: O.Option<P.Progress>;
}
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const loading: Loading;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromProgress: (progress: P.Progress) => Loading;
/**
 * @since 0.9.2
 * @category Model
 */
export interface Refresh<A> {
    readonly _tag: 'Refresh';
    readonly value: A;
    readonly progress: O.Option<P.Progress>;
}
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const refresh: <A>(value: A, progress?: O.Option<P.Progress>) => Refresh<A>;
/**
 * @since 0.9.2
 * @category Model
 */
export interface Replete<A> {
    readonly _tag: 'Replete';
    readonly value: A;
}
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const replete: <A>(value: A) => Replete<A>;
/**
 * @since 0.9.2
 * @category Deconstructor
 */
export declare const matchW: <A, B, C, D, E>(onNoData: () => A, onLoading: (progress: O.Option<P.Progress>) => B, onRefresh: (value: C, progress: O.Option<P.Progress>) => D, onReplete: (value: C) => E) => (data: Data<C>) => A | B | D | E;
/**
 * @since 0.9.2
 * @category Deconstructor
 */
export declare const match3W: <A, B, C, D>(onNoData: () => A, onLoading: (progress: O.Option<P.Progress>) => B, onRefreshOrReplete: (value: C) => D) => (data: Data<C>) => A | B | D;
/**
 * @since 0.9.2
 * @category Deconstructor
 */
export declare const match: <A, B>(onNoData: () => A, onLoading: () => A, onRefresh: (value: B) => A, onReplete: (value: B) => A) => (data: Data<B>) => A;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const toLoading: <A>(data: Data<A>) => Data<A>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const fromNullable: <A>(a: A | null | undefined) => Data<A>;
/**
 * @since 0.9.2
 * @category Typeclass Constructor
 */
export declare const getShow: <A>(S: Show<A>) => Show<Data<A>>;
/**
 * @since 0.9.2
 * @category Typeclass Constructor
 */
export declare const getEq: <A>(S: Eq<A>) => Eq<Data<A>>;
/**
 * @since 0.9.2
 * @category Typeclass Constructor
 */
export declare const getSemigroup: <A>(S: Semigroup<A>) => Semigroup<Data<A>>;
/**
 * @since 0.9.2
 * @category Typeclass Constructor
 */
export declare const getMonoid: <A>(S: Semigroup<A>) => Monoid<Data<A>>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const getOrElse: <A>(onInitial: () => A, onLoading: (progress: O.Option<P.Progress>) => A) => (ma: Data<A>) => A;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const getOrElseW: <A, B>(onInitial: () => A, onLoading: (progress: O.Option<P.Progress>) => B) => <C>(ma: Data<C>) => A | B | C;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const elem: <A>(E: Eq<A>) => (a: A) => (ma: Data<A>) => boolean;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const exists: <A>(predicate: Predicate<A>) => (ma: Data<A>) => boolean;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const of: <A>(value: A) => Data<A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const map: <A, B>(f: (value: A) => B) => (data: Data<A>) => Data<B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chain: <A, B>(f: (value: A) => Data<B>) => (data: Data<A>) => Data<B>;
/**
 * @since 0.9.2
 * @category URI
 */
export declare const URI = "@typed/fp/Data";
/**
 * @since 0.9.2
 * @category URI
 */
export declare type URI = typeof URI;
declare module 'fp-ts/HKT' {
    interface URItoKind<A> {
        [URI]: Data<A>;
    }
}
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Pointed: Pointed1<URI>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Functor: F.Functor1<URI>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const bindTo: <N extends string>(name: N) => <A>(fa: Data<A>) => Data<{ [K in N]: A; }>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const flap: <A>(a: A) => <B>(fab: Data<(a: A) => B>) => Data<B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const tupled: <A>(fa: Data<A>) => Data<readonly [A]>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Chain: Ch.Chain1<URI>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const ap: <A>(fa: Data<A>) => <B>(fab: Data<(a: A) => B>) => Data<B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const bind: <N extends string, A, B>(name: Exclude<N, keyof A>, f: (a: A) => Data<B>) => (ma: Data<A>) => Data<{ readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainFirst: <A, B>(f: (a: A) => Data<B>) => (first: Data<A>) => Data<A>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Apply: Ap.Apply1<URI>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apFirst: <B>(second: Data<B>) => <A>(first: Data<A>) => Data<A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apS: <N extends string, A, B>(name: Exclude<N, keyof A>, fb: Data<B>) => (fa: Data<A>) => Data<{ readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apSecond: <B>(second: Data<B>) => <A>(first: Data<A>) => Data<B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const apT: <B>(fb: Data<B>) => <A extends readonly unknown[]>(fas: Data<A>) => Data<readonly [...A, B]>;
/**
 * @since 0.9.2
 * @category Typeclass Constructor
 */
export declare const getApplySemigroup: <A>(S: Semigroup<A>) => Semigroup<Data<A>>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Applicative: App.Applicative1<URI>;
/**
 * @since 0.9.2
 * @category Typeclass Constructor
 */
export declare const getApplicativeMonoid: <A>(M: Monoid<A>) => Monoid<Data<A>>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Monad: Monad1<URI>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const chainRec: <A, B>(f: (value: A) => Data<Ei.Either<A, B>>) => (value: A) => Data<B>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const alt: <A>(f: Lazy<Data<A>>) => <B>(b: Data<B>) => Data<A | B>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Alt: AD.Alt1<URI>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const altAll: <A>(startWith: Data<A>) => (as: readonly Data<A>[]) => Data<A>;
/**
 * @since 0.9.2
 * @category Constructor
 */
export declare const zero: <A>() => Data<A>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Alternative: Alternative_.Alternative1<URI>;
/**
 * @since 0.9.2
 * @category Natural Transformation
 */
export declare const fromOption: <A>(option: O.Option<A>) => Data<A>;
/**
 * @since 0.9.2
 * @category Natural Transformation
 */
export declare const toOption: <A>(data: Data<A>) => O.Option<A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare function foldMap<M>(M: Monoid<M>): <A>(f: (a: A) => M) => (fa: Data<A>) => M;
/**
 * @since 0.9.2
 * @category Deconstructor
 */
export declare const reduce: <A, B>(seed: A, f: (acc: A, value: B) => A) => (data: Data<B>) => A;
/**
 * @since 0.9.2
 * @category Deconstructor
 */
export declare const reduceRight: <A, B>(seed: A, f: (value: B, acc: A) => A) => (data: Data<B>) => A;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Foldable: Foldable1<URI>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare function traverse<F>(F: App.Applicative<F>): <A, B>(f: (value: A) => HKT<F, B>) => (data: Data<A>) => HKT<F, Data<B>>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Traversable: Traversable1<URI>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const compact: <A>(dataOption: Data<O.Option<A>>) => Data<A>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const separate: <E, A>(dataEither: Data<Ei.Either<E, A>>) => Separated<Data<E>, Data<A>>;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Compactable: Compactable1<URI>;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const partitionMap: Filterable1<URI>['partitionMap'];
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const partition: import("fp-ts/Filterable").Partition1<"@typed/fp/Data">;
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const filterMap: Filterable1<URI>['filterMap'];
/**
 * @since 0.9.2
 * @category Combinator
 */
export declare const filter: import("fp-ts/Filterable").Filter1<"@typed/fp/Data">;
/**
 * @since 0.9.2
 * @category Instance
 */
export declare const Filterable: Filterable1<URI>;
//# sourceMappingURL=Data.d.ts.map