@typed/fp
Version:
Data Structures and Resources for fp-ts
883 lines • 19.1 kB
JavaScript
import * as H from '@most/hold';
import * as App from 'fp-ts/Applicative';
import * as Ap from 'fp-ts/Apply';
import * as Ch from 'fp-ts/Chain';
import { isLeft, isRight } 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 { pipe } from 'fp-ts/function';
import * as F from 'fp-ts/Functor';
import { not } from 'fp-ts/Predicate';
import * as RT from 'fp-ts/ReaderT';
import * as RA from 'fp-ts/ReadonlyArray';
import { settable } from './Disposable';
import { deepEqualsEq } from './Eq';
import * as FE from './FromEnv';
import * as FRe from './FromResume';
import * as FS from './FromStream';
import * as FN from './function';
import * as P from './Provide';
import { async } from './Resume';
import * as S from './Stream';
import * as St from './struct';
/**
* @since 0.9.2
* @category Combinator
*/
export const ap = RT.ap(S.Apply);
/**
* @since 0.9.2
* @category Combinator
*/
export const apW = ap;
/**
* @since 0.9.2
* @category Combinator
*/
export const chain = RT.chain(S.Chain);
/**
* @since 0.9.2
* @category Combinator
*/
export const chainW = chain;
/**
* @since 0.9.2
* @category Combinator
*/
export const switchMap = RT.chain({
map: S.map,
chain: (f) => FN.flow(S.map(f), S.switchLatest),
});
/**
* @since 0.9.2
* @category Combinator
*/
export const switchMapW = switchMap;
/**
* @since 0.9.2
* @category Combinator
*/
export const switchFirst = (second) => (first) => (r) => pipe(first, withStream(S.switchFirst(second(r))))(r);
/**
* @since 0.9.2
* @category Constructor
*/
export const fromReader = RT.fromReader(S.Pointed);
/**
* @since 0.9.2
* @category Combinator
*/
export const map = RT.map(S.Functor);
/**
* @since 0.9.2
* @category Combinator
*/
export const constant = (b) => map(() => b);
/**
* @since 0.9.2
* @category Constructor
*/
export const of = RT.of(S.Pointed);
/**
* @since 0.9.2
* @category Combinator
*/
export function chainRec(f) {
return (value) => (env) => S.chainRec((a) => f(a)(env))(value);
}
/**
* @since 0.9.2
* @category URI
*/
export const URI = '@typed/fp/ReaderStream';
/**
* @since 0.9.2
* @category Instance
*/
export const Pointed = {
of,
};
/**
* @since 0.9.2
* @category Instance
*/
export const Functor = {
map,
};
/**
* @since 0.9.2
* @category Combinator
*/
export const bindTo = F.bindTo(Functor);
/**
* @since 0.9.2
* @category Combinator
*/
export const flap = F.flap(Functor);
/**
* @since 0.9.2
* @category Combinator
*/
export const tupled = F.tupled(Functor);
/**
* @since 0.9.2
* @category Instance
*/
export const Apply = {
...Functor,
ap,
};
/**
* @since 0.9.2
* @category Combinator
*/
export const apFirst = Ap.apFirst(Apply);
/**
* @since 0.9.2
* @category Combinator
*/
export const apFirstW = apFirst;
/**
* @since 0.9.2
* @category Combinator
*/
export const apS = Ap.apS(Apply);
/**
* @since 0.9.2
* @category Combinator
*/
export const apSW = apS;
/**
* @since 0.9.2
* @category Combinator
*/
export const apSecond = Ap.apSecond(Apply);
/**
* @since 0.9.2
* @category Combinator
*/
export const apSecondW = apSecond;
/**
* @since 0.9.2
* @category Combinator
*/
export const apT = Ap.apT(Apply);
/**
* @since 0.9.2
* @category Combinator
*/
export const apTW = apT;
/**
* @since 0.9.2
* @category Typeclass Constructor
*/
export const getApplySemigroup = Ap.getApplySemigroup(Apply);
/**
* @since 0.9.2
* @category Combinator
*/
export const apSEnv = (name, fb) => apS(name, FN.pipe(fb, fromEnv));
/**
* @since 0.9.2
* @category Combinator
*/
export const apSEnvW = apSEnv;
/**
* @since 0.9.2
* @category Combinator
*/
export const apTEnvW = (fb) => FN.pipe(fb, fromEnv, apTW);
/**
* @since 0.9.2
* @category Combinator
*/
export const apTEnv = apTEnvW;
/**
* @since 0.9.2
* @category Instance
*/
export const Applicative = {
...Apply,
...Pointed,
};
/**
* @since 0.9.2
* @category Typeclass Constructor
*/
export const getApplicativeMonoid = App.getApplicativeMonoid(Applicative);
/**
* @since 0.9.2
* @category Instance
*/
export const Chain = {
...Functor,
chain,
};
/**
* @since 0.9.2
* @category Combinator
*/
export const chainFirst = Ch.chainFirst(Chain);
/**
* @since 0.9.2
* @category Combinator
*/
export const chainFirstW = chainFirst;
/**
* @since 0.9.2
* @category Combinator
*/
export const bind = Ch.bind(Chain);
/**
* @since 0.9.2
* @category Combinator
*/
export const bindW = bind;
/**
* @since 0.9.2
* @category Combinator
*/
export const bindEnv = (name, f) => bind(name, FN.flow(f, fromEnv));
/**
* @since 0.9.2
* @category Combinator
*/
export const bindEnvW = (name, f) => bindW(name, FN.flow(f, fromEnv));
/**
* @since 0.9.2
* @category Instance
*/
export const Monad = {
...Chain,
...Pointed,
};
/**
* @since 0.9.2
* @category Instance
*/
export const ChainRec = {
chainRec,
};
/**
* @since 0.9.2
* @category Instance
*/
export const MonadRec = {
...Monad,
chainRec,
};
/**
* @since 0.9.2
* @category Instance
*/
export const FromReader = {
fromReader,
};
/**
* @since 0.9.2
* @category Constructor
*/
export const ask = FR.ask(FromReader);
/**
* @since 0.9.2
* @category Constructor
*/
export const asks = FR.asks(FromReader);
/**
* @since 0.9.2
* @category Combinator
*/
export const chainFirstReaderK = FR.chainFirstReaderK(FromReader, Chain);
/**
* @since 0.9.2
* @category Combinator
*/
export const chainReaderK = FR.chainReaderK(FromReader, Chain);
/**
* @since 0.9.2
* @category Constructor
*/
export const fromReaderK = FR.fromReaderK(FromReader);
/**
* @since 0.9.2
* @category Instance
*/
export const FromResume = {
fromResume: (r) => () => S.fromResume(r),
};
/**
* @since 0.9.2
* @category Constructor
*/
export const fromResume = FromResume.fromResume;
/**
* @since 0.9.2
* @category Combinator
*/
export const chainFirstResumeK = FRe.chainFirstResumeK(FromResume, Chain);
/**
* @since 0.9.2
* @category Combinator
*/
export const chainResumeK = FRe.chainResumeK(FromResume, Chain);
/**
* @since 0.9.2
* @category Constructor
*/
export const fromResumeK = FRe.fromResumeK(FromResume);
/**
* @since 0.9.2
* @category Instance
*/
export const FromEnv = {
fromEnv: (env) => FN.flow(env, S.fromResume),
};
/**
* @since 0.9.2
* @category Constructor
*/
export const fromEnv = FromEnv.fromEnv;
/**
* @since 0.9.2
* @category Combinator
*/
export const chainEnvK = FE.chainEnvK(FromEnv, Chain);
/**
* @since 0.9.2
* @category Combinator
*/
export const chainFirstEnvK = FE.chainFirstEnvK(FromEnv, Chain);
/**
* @since 0.9.2
* @category Constructor
*/
export const fromEnvK = FE.fromEnvK(FromEnv);
/**
* @since 0.9.2
* @category Instance
*/
export const FromIO = {
fromIO: (io) => () => S.fromIO(io),
};
/**
* @since 0.9.2
* @category Constructor
*/
export const fromIO = FromIO.fromIO;
/**
* @since 0.9.2
* @category Combinator
*/
export const chainFirstIOK = FIO.chainFirstIOK(FromIO, Chain);
/**
* @since 0.9.2
* @category Combinator
*/
export const chainIOK = FIO.chainIOK(FromIO, Chain);
/**
* @since 0.9.2
* @category Constructor
*/
export const fromIOK = FIO.fromIOK(FromIO);
/**
* @since 0.9.2
* @category Constructor
*/
export const Do = fromIO(() => Object.create(null));
/**
* @since 0.9.2
* @category Instance
*/
export const FromTask = {
...FromIO,
fromTask: (task) => () => S.fromTask(task),
};
/**
* @since 0.9.2
* @category Constructor
*/
export const fromTask = FromTask.fromTask;
/**
* @since 0.9.2
* @category Combinator
*/
export const chainFirstTaskK = FT.chainFirstTaskK(FromTask, Chain);
/**
* @since 0.9.2
* @category Combinator
*/
export const chainTaskK = FT.chainTaskK(FromTask, Chain);
/**
* @since 0.9.2
* @category Constructor
*/
export const fromTaskK = FT.fromTaskK(FromTask);
/**
* @since 0.9.2
* @category Instance
*/
export const FromStream = {
fromStream: FN.constant,
};
/**
* @since 0.9.2
* @category Constructor
*/
export const fromStream = FromStream.fromStream;
/**
* @since 0.9.2
* @category Combinator
*/
export const chainFirstStreamK = FS.chainFirstStreamK(FromStream, Chain);
/**
* @since 0.9.2
* @category Combinator
*/
export const chainStreamK = FS.chainStreamK(FromStream, Chain);
/**
* @since 0.9.2
* @category Constructor
*/
export const fromStreamK = FS.fromStreamK(FromStream);
/**
* @since 0.9.2
* @category Constructor
*/
export const asksEnv = (f) => (r) => FN.pipe(r, f(r), S.fromResume);
/**
* @since 0.9.2
* @category Constructor
*/
export const asksIO = (f) => (r) => FN.pipe(r, f, S.fromIO);
/**
* @since 0.9.2
* @category Constructor
*/
export const asksTask = (f) => (r) => FN.pipe(r, f, S.fromTask);
export function filter(predicate) {
return (rs) => (r) => FN.pipe(r, rs, S.filter(predicate));
}
/**
* @since 0.9.2
* @category Combinator
*/
export function merge(a) {
return (b) => (r) => FN.pipe(a(r), S.merge(b(r)));
}
/**
* @since 0.9.2
* @category Combinator
*/
export function mergeFirst(a) {
return (b) => (r) => FN.pipe(r, b, S.mergeFirst(a(r)));
}
/**
* @since 0.9.2
* @category Combinator
*/
export function mergeArray(streams) {
return (r) => S.mergeArray(streams.map((rs) => rs(r)));
}
/**
* @since 0.9.2
* @category Combinator
*/
export function concatMap(f) {
return (rs) => (r) => FN.pipe(r, rs, S.concatMap((a) => FN.pipe(r, f(a))));
}
/**
* @since 0.9.2
* @category Combinator
*/
export const recoverWith = (f) => (rs) => (r) => FN.pipe(r, rs, S.recoverWith((e) => FN.pipe(r, f(e))));
/**
* @since 0.9.2
* @category Constructor
*/
export const empty = fromStreamK(S.empty);
/**
* @since 0.9.2
* @category Constructor
*/
export const never = fromStreamK(S.never);
/**
* @since 0.9.2
* @category Constructor
*/
export const periodic = fromStreamK(S.periodic);
/**
* @since 0.9.2
* @category Combinator
*/
export const provideSome = (provided) => (rs) => (e2) => rs({ ...provided, ...e2 });
/**
* @since 0.9.2
* @category Combinator
*/
export const useSome = (provided) => (rs) => (e2) => rs({ ...e2, ...provided });
/**
* @since 0.9.2
* @category Combinator
*/
export const provideAll = (provided) => (rs) => (e2) => rs({ ...provided, ...e2 });
/**
* @since 0.9.2
* @category Combinator
*/
export const useAll = (provided) => (rs) => () => rs(provided);
/**
* @since 0.9.2
* @category Instance
*/
export const ProvideSome = {
provideSome,
};
/**
* @since 0.9.2
* @category Instance
*/
export const UseSome = {
useSome,
};
/**
* @since 0.9.2
* @category Instance
*/
export const ProvideAll = {
provideAll,
};
/**
* @since 0.9.2
* @category Instance
*/
export const UseAll = {
useAll,
};
/**
* @since 0.9.2
* @category Instance
*/
export const Provide = {
provideAll,
provideSome,
useAll,
useSome,
};
/**
* @since 0.9.2
* @category Combinator
*/
export const askAndProvide = P.askAndProvide({ ...ProvideAll, ...Chain, ...FromReader });
/**
* @since 0.9.2
* @category Combinator
*/
export const askAndUse = P.askAndUse({ ...UseAll, ...Chain, ...FromReader });
/**
* @since 0.9.2
* @category Combinator
*/
export const provideAllWith = P.provideAllWith({ ...ProvideAll, ...Chain });
/**
* @since 0.9.2
* @category Combinator
*/
export const provideSomeWith = P.provideSomeWith({ ...ProvideSome, ...Chain });
/**
* @since 0.9.2
* @category Combinator
*/
export const useAllWith = P.useAllWith({ ...UseAll, ...Chain });
/**
* @since 0.9.2
* @category Combinator
*/
export const useSomeWith = P.useSomeWith({ ...UseSome, ...Chain });
/**
* @since 0.9.2
* @category Combinator
*/
export const provideSomeWithEnv = FE.provideSomeWithEnv({ ...FromEnv, ...ProvideSome, ...Chain });
/**
* @since 0.9.2
* @category Combinator
*/
export const provideAllWithEnv = FE.provideAllWithEnv({ ...FromEnv, ...ProvideAll, ...Chain });
/**
* @since 0.9.2
* @category Combinator
*/
export const useSomeWithEnv = FE.useSomeWithEnv({ ...FromEnv, ...UseSome, ...Chain });
/**
* @since 0.9.2
* @category Combinator
*/
export const useAllWithEnv = FE.useAllWithEnv({ ...FromEnv, ...UseAll, ...Chain });
/**
* @since 0.9.2
* @category Combinator
*/
export const combine = (f) => (rsa) => (rsb) => (e) => S.combine(f, rsa(e), rsb(e));
/**
* @since 0.9.2
* @category Combinator
*/
export const combineAll = (...rss) => (e) => S.combineAll(...rss.map((rs) => rs(e)));
/**
* @since 0.13.2
* @category Combinator
*/
export const struct = (props) => pipe(combineAll(...pipe(Object.entries(props), RA.map(([k, stream]) => pipe(stream, map((v) => St.make(k, v)))))), map((o) => Object.assign({}, ...o)));
/**
* @since 0.9.2
* @category Combinator
*/
export const withStream = (f) => (rs) => (e) => FN.pipe(e, rs, f);
/**
* @since 0.9.2
* @category Combinator
*/
export const tap = (f) => (rs) => FN.pipe(rs, withStream(S.tap(f)));
/**
* @since 0.9.2
* @category Combinator
*/
export const take = FN.flow(S.take, withStream);
/**
* @since 0.9.2
* @category Combinator
*/
export const skip = FN.flow(S.skip, withStream);
/**
* @since 0.9.2
* @category Combinator
*/
export const startWith = (value) => (stream) => withStream(S.startWith(value))(stream);
/**
* @since 0.9.2
* @category Combinator
*/
export const exhaustLatest = (rs) => (e) => S.exhaustMapLatest((rs) => rs(e))(rs(e));
/**
* @since 0.9.2
* @category Combinator
*/
export const exhaustMapLatest = (f) => (rs) => (e) => S.exhaustMapLatest((a) => f(a)(e))(rs(e));
/**
* @since 0.9.2
* @category Combinator
*/
export const exhaustLatestEnv = (env) => (rs) => exhaustMapLatest(() => fromEnv(env))(rs);
/**
* @since 0.9.2
* @category Combinator
*/
export const exhaustMapLatestEnv = (f) => (rs) => exhaustMapLatest((a) => fromEnv(f(a)))(rs);
/**
* @since 0.9.2
* @category Combinator
*/
export const onDispose = (disposable) => withStream(S.onDispose(disposable));
/**
* @since 0.9.2
* @category Combinator
*/
export const collectEvents = (scheduler) => (rs) => FN.pipe(rs, withStream(S.collectEvents(scheduler)));
/**
* @since 0.9.2
* @category Constructor
*/
export const now = FN.flow(S.now, fromStream);
/**
* @since 0.9.2
* @category Constructor
*/
export const at = FN.flow(S.at, fromStream);
/**
* @since 0.9.2
* @category Combinator
*/
export const scan = (f, seed) => (rs) => FN.pipe(rs, withStream(S.scan(f, seed)));
/**
* @since 0.9.2
* @category Combinator
*/
export const skipRepeatsWith = (Eq) => (rs) => FN.pipe(rs, withStream(S.skipRepeatsWith((a, b) => Eq.equals(a)(b))));
/**
* @since 0.9.2
* @category Combinator
*/
export const skipRepeats = skipRepeatsWith(deepEqualsEq);
/**
* @since 0.9.2
* @category Combinator
*/
export const compact = withStream(S.compact);
/**
* @since 0.9.2
* @category Combinator
*/
export const continueWith = (f) => (rs) => (e) => FN.pipe(e, rs, S.continueWith(() => f()(e)));
/**
* @since 0.9.2
* @category Combinator
*/
export const debounce = (delay) => (rs) => FN.pipe(rs, withStream(S.debounce(delay)));
/**
* @since 0.9.2
* @category Combinator
*/
export const delay = (delay) => (rs) => FN.pipe(rs, withStream(S.delay(delay)));
/**
* @since 0.9.2
* @category Combinator
*/
export const join = (rs) => (e) => FN.pipe(e, rs, S.chain((f) => f(e)));
/**
* @since 0.9.2
* @category Combinator
*/
export const during = (timeWindow) => (values) => (e) => FN.pipe(e, values, S.during(join(timeWindow)(e)));
/**
* @since 0.9.2
* @category Combinator
*/
export const filterMap = (f) => (fa) => FN.pipe(fa, withStream(S.filterMap(f)));
/**
* @since 0.9.2
* @category Combinator
*/
export const loop = (f, seed) => (fa) => (e) => FN.pipe(e, fa, S.loop(f, seed));
/**
* @since 0.9.2
* @category Combinator
*/
export const mergeConcurrently = (concurrency) => (rs) => (e) => FN.pipe(e, rs, S.mergeMapConcurrently((rs) => rs(e), concurrency));
/**
* @since 0.9.2
* @category Combinator
*/
export const multicast = (rs) => FN.pipe(rs, withStream(S.multicast));
/**
* @since 0.9.2
* @category Combinator
*/
export const partition = (predicate) => (fa) => ({
left: FN.pipe(fa, filter(not(predicate))),
right: FN.pipe(fa, filter(predicate)),
});
/**
* @since 0.9.2
* @category Combinator
*/
export const partitionMap = (f) => (fa) => ({
left: FN.pipe(fa, map(f), filter(isLeft), map((x) => x.left)),
right: FN.pipe(fa, map(f), filter(isRight), map((x) => x.right)),
});
/**
* @since 0.9.2
* @category Combinator
*/
export const race = (second) => (first) => (e) => FN.pipe(e, first, S.race(() => second(e)));
/**
* @since 0.9.2
* @category Combinator
*/
export const separate = (rs) => FN.pipe(rs, partitionMap((e) => e));
/**
* @since 0.9.2
* @category Combinator
*/
export const since = (timeWindow) => (values) => (e) => FN.pipe(e, values, S.since(timeWindow(e)));
/**
* @since 0.9.2
* @category Combinator
*/
export const skipAfter = (p) => (s) => FN.pipe(s, withStream(S.skipAfter(p)));
/**
* @since 0.9.2
* @category Combinator
*/
export const skipWhile = (p) => (s) => FN.pipe(s, withStream(S.skipWhile(p)));
/**
* @since 0.9.2
* @category Combinator
*/
export const slice = (skip, take) => (rs) => FN.pipe(rs, withStream(S.slice(skip, take)));
/**
* @since 0.9.2
* @category Combinator
*/
export const switchLatest = (rs) => (e) => FN.pipe(e, rs, S.map((f) => f(e)), S.switchLatest);
/**
* @since 0.9.2
* @category Combinator
*/
export const takeWhile = (p) => (s) => FN.pipe(s, withStream(S.takeWhile(p)));
/**
* @since 0.9.2
* @category Combinator
*/
export const throttle = (period) => (s) => FN.pipe(s, withStream(S.throttle(period)));
/**
* @since 0.9.2
* @category Combinator
*/
export const throwError = fromStreamK(S.throwError);
/**
* @since 0.9.2
* @category Combinator
*/
export const until = (timeWindow) => (values) => (e) => FN.pipe(e, values, S.until(timeWindow(e)));
/**
* @since 0.9.2
* @category Combinator
*/
export const zero = FN.flow(S.zero, fromStream);
/**
* @since 0.9.2
* @category Instance
*/
export const Filterable = {
partitionMap,
partition,
filterMap,
filter,
};
/**
* @since 0.9.2
* @category Instance
*/
export const Compactable = {
compact,
separate,
};
/**
* @since 0.9.2
* @category Combinator
*/
export const keyed = (Eq) => (rs) => pipe(rs, withStream(S.keyed(Eq)));
/**
* @since 0.9.2
* @category Combinator
*/
export const mergeMapWhen = (Eq = deepEqualsEq) => (f) => (values) => (e) => pipe(values, withStream(S.mergeMapWhen(Eq)((v) => f(v)(e))))(e);
/**
* Listens to the next value of a stream.
*/
/**
* @since 0.9.2
* @category Natural Transformation
*/
export const toEnv = (rs) => (e) => async((resume) => {
const disposable = settable();
disposable.addDisposable(pipe(e, rs, S.take(1)).run(S.createSink({ event: (_, x) => disposable.addDisposable(resume(x)) }), e.scheduler));
return disposable;
});
/**
* @since 0.9.2
* @category Combinator
*/
export const hold = (rs) => pipe(rs, withStream(H.hold));
//# sourceMappingURL=ReaderStream.js.map