@typed/fp/esm/DataT.js

Data Structures and Resources for fp-ts

/**
 * DataT is a collection of transformers than can lift your effect types
 * to use Data to represent asynchronous loading.
 * @since 0.9.2
 */
import * as Apply from 'fp-ts/Apply';
import { flow, pipe } from 'fp-ts/function';
import * as Functor from 'fp-ts/Functor';
import * as D from './Data';
export function noData(P) {
    return P.of(D.noData);
}
export function loading(P) {
    return P.of(D.loading);
}
export function fromProgress(P) {
    return flow(D.fromProgress, P.of);
}
export function refresh(P) {
    return flow(D.refresh, P.of);
}
export function replete(P) {
    return flow(D.replete, P.of);
}
export function repleteF(F) {
    return F.map(D.replete);
}
export function map(F) {
    return Functor.map(F, D.Functor);
}
export function ap(F) {
    return Apply.ap(F, D.Apply);
}
export function chain(M) {
    return (f) => (fa) => pipe(fa, M.chain((data) => (D.hasValue(data) ? f(data.value) : M.of(data))));
}
export function alt(M) {
    return (second) => M.chain((e) => (D.hasValue(e) ? M.of(e) : second()));
}
export function match(F) {
    return flow(D.match, F.map);
}
export function matchW(F) {
    return flow(D.matchW, F.map);
}
export function match3W(F) {
    return flow(D.match3W, F.map);
}
export function matchE(C) {
    return (onNoData, onLoading, onRefresh, onReplete) => (data) => pipe(data, C.chain(D.matchW(onNoData, onLoading, onRefresh, onReplete)));
}
export function matchEW(C) {
    return (onNoData, onLoading, onRefresh, onReplete) => (data) => pipe(data, C.chain(D.matchW(onNoData, onLoading, onRefresh, onReplete)));
}
export function getOrElse(F) {
    return flow(D.getOrElse, F.map);
}
export function getOrElseW(F) {
    return (onData, onLoading) => F.map(D.getOrElseW(onData, onLoading));
}
//# sourceMappingURL=DataT.js.map