@typed/fp
Version:
Data Structures and Resources for fp-ts
349 lines • 10.3 kB
TypeScript
import * as types from '@most/types';
import * as Alt_ from 'fp-ts/Alt';
import { Alternative1 } 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 { ChainRec1 } from 'fp-ts/ChainRec';
import { Compactable1 } from 'fp-ts/Compactable';
import { Either } from 'fp-ts/Either';
import { Eq } from 'fp-ts/Eq';
import { Filterable1 } from 'fp-ts/Filterable';
import { FromIO1 } from 'fp-ts/FromIO';
import { FromTask1 } from 'fp-ts/FromTask';
import { Functor1 } from 'fp-ts/Functor';
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 { Separated } from 'fp-ts/Separated';
import * as FRe from './FromResume';
import { Arity1 } from './function';
import * as R from './Resume';
/**
* @since 0.9.2
* @category Model
*/
export declare type Stream<A> = types.Stream<A>;
/**
* @since 0.9.2
* @category Type-level
*/
export declare type ValueOf<A> = [A] extends [Stream<infer R>] ? R : never;
/**
* Convert an IO<Disposable> into a Most.js Task
* @since 0.9.2
* @category Constructor
*/
export declare function createCallbackTask(cb: Arity1<types.Time, types.Disposable>, onError?: (error: Error) => void): types.Task;
/**
* @since 0.9.2
* @category URI
*/
export declare const URI: "@most/core/Stream";
/**
* @since 0.9.2
* @category URI
*/
export declare type URI = typeof URI;
declare module 'fp-ts/HKT' {
interface URItoKind<A> {
[URI]: types.Stream<A>;
}
}
/**
* Create a Stream monoid where concat is a parallel merge.
*/
/**
* @since 0.9.2
* @category Typeclass Constructor
*/
export declare const getMonoid: <A>() => Monoid<types.Stream<A>>;
/**
* Filter Option's from within a Stream
*/
/**
* @since 0.9.2
* @category Combinator
*/
export declare const compact: <A>(stream: types.Stream<O.Option<A>>) => types.Stream<A>;
/**
* Separate left and right values
*/
/**
* @since 0.9.2
* @category Combinator
*/
export declare const separate: <A, B>(stream: types.Stream<Either<A, B>>) => Separated<types.Stream<A>, types.Stream<B>>;
/**
* @since 0.9.2
* @category Combinator
*/
export declare const partitionMap: <A, B, C>(f: (a: A) => Either<B, C>) => (fa: types.Stream<A>) => Separated<types.Stream<B>, types.Stream<C>>;
/**
* @since 0.9.2
* @category Combinator
*/
export declare const partition: <A>(predicate: Predicate<A>) => (fa: types.Stream<A>) => Separated<types.Stream<A>, types.Stream<A>>;
/**
* @since 0.9.2
* @category Combinator
*/
export declare const filterMap: <A, B>(f: (a: A) => O.Option<B>) => (fa: types.Stream<A>) => types.Stream<B>;
/**
* @since 0.9.2
* @category Instance
*/
export declare const Functor: Functor1<URI>;
/**
* @since 0.9.2
* @category Instance
*/
export declare const Pointed: Pointed1<URI>;
/**
* @since 0.9.2
* @category Constructor
*/
export declare const of: <A>(a: A) => types.Stream<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: types.Stream<B>) => <A>(first: types.Stream<A>) => types.Stream<A>;
/**
* @since 0.9.2
* @category Combinator
*/
export declare const apS: <N extends string, A, B>(name: Exclude<N, keyof A>, fb: types.Stream<B>) => (fa: types.Stream<A>) => types.Stream<{ 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: types.Stream<B>) => <A>(first: types.Stream<A>) => types.Stream<B>;
/**
* @since 0.9.2
* @category Combinator
*/
export declare const apT: <B>(fb: types.Stream<B>) => <A extends readonly unknown[]>(fas: types.Stream<A>) => types.Stream<readonly [...A, B]>;
/**
* @since 0.9.2
* @category Typeclass Constructor
*/
export declare const getApplySemigroup: <A>(S: import("fp-ts/Semigroup").Semigroup<A>) => import("fp-ts/Semigroup").Semigroup<types.Stream<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<types.Stream<A>>;
/**
* @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) => types.Stream<B>) => (first: types.Stream<A>) => types.Stream<A>;
/**
* @since 0.9.2
* @category Combinator
*/
export declare const bind: <N extends string, A, B>(name: Exclude<N, keyof A>, f: (a: A) => types.Stream<B>) => (ma: types.Stream<A>) => types.Stream<{ readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
/**
* @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) => types.Stream<Either<A, B>>) => (value: A) => types.Stream<B>;
/**
* @since 0.9.2
* @category Instance
*/
export declare const ChainRec: ChainRec1<URI>;
/**
* @since 0.9.2
* @category Combinator
*/
export declare const switchRec: <A, B>(f: (value: A) => types.Stream<Either<A, B>>) => (value: A) => types.Stream<B>;
/**
* @since 0.9.2
* @category Instance
*/
export declare const SwitchRec: ChainRec1<URI>;
/**
* @since 0.9.2
* @category Combinator
*/
export declare const mergeConcurrentlyRec: (concurrency: number) => <A, B>(f: (value: A) => types.Stream<Either<A, B>>) => (value: A) => types.Stream<B>;
/**
* @since 0.9.2
* @category Typeclass Constructor
*/
export declare const getConcurrentChainRec: (concurrency: number) => ChainRec1<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", "@most/core/Stream">;
/**
* @since 0.9.2
* @category Instance
*/
export declare const FromTask: FromTask1<URI>;
/**
* @since 0.9.2
* @category Constructor
*/
export declare const fromTask: import("fp-ts/NaturalTransformation").NaturalTransformation11<"Task", "@most/core/Stream">;
/**
* @since 0.9.2
* @category Instance
*/
export declare const FromResume: FRe.FromResume1<URI>;
/**
* @since 0.9.2
* @category Constructor
*/
export declare const fromResume: import("fp-ts/NaturalTransformation").NaturalTransformation11<"@typed/fp/Resume", "@most/core/Stream">;
/**
* @since 0.9.2
* @category Combinator
*/
export declare const chainFirstResumeK: <A, B>(f: (value: A) => R.Resume<B>) => (hkt: types.Stream<A>) => types.Stream<A>;
/**
* @since 0.9.2
* @category Combinator
*/
export declare const chainResumeK: <A, B>(f: (value: A) => R.Resume<B>) => (hkt: types.Stream<A>) => types.Stream<B>;
/**
* @since 0.9.2
* @category Constructor
*/
export declare const fromResumeK: <A extends readonly any[], B>(f: (...args: A) => R.Resume<B>) => (...args: A) => types.Stream<B>;
/**
* @since 0.9.2
* @category Instance
*/
export declare const Alt: Alt_.Alt1<URI>;
/**
* @since 0.9.2
* @category Combinator
*/
export declare const race: <A>(second: import("fp-ts/function").Lazy<types.Stream<A>>) => (first: types.Stream<A>) => types.Stream<A>;
/**
* @since 0.9.2
* @category Instance
*/
export declare const Alternative: Alternative1<URI>;
/**
* @since 0.9.2
* @category Constructor
*/
export declare const zero: <A>() => types.Stream<A>;
/**
* @since 0.9.2
* @category Instance
*/
export declare const Compactable: Compactable1<URI>;
/**
* @since 0.9.2
* @category Instance
*/
export declare const Filterable: Filterable1<URI>;
/**
* @since 0.9.2
* @category Constructor
*/
export declare const Do: types.Stream<{}>;
/**
* @since 0.9.2
* @category Combinator
*/
export declare const bindTo: <N extends string>(name: N) => <A>(fa: types.Stream<A>) => types.Stream<{ [K in N]: A; }>;
/**
* @since 0.9.2
* @category Combinator
*/
export declare const tupled: <A>(fa: types.Stream<A>) => types.Stream<readonly [A]>;
/**
* @since 0.9.2
* @category Constructor
*/
export declare const createSink: <A>(sink?: Partial<types.Sink<A>>) => types.Sink<A>;
/**
* @since 0.9.2
* @category Combinator
*/
export declare const collectEvents: (scheduler: types.Scheduler) => <A>(stream: types.Stream<A>) => Promise<readonly A[]>;
/**
* @since 0.9.2
* @category Combinator
*/
export declare const onDispose: (disposable: types.Disposable) => <A>(stream: types.Stream<A>) => types.Stream<A>;
/**
* @since 0.9.2
* @category Combinator
*/
export declare const combineAll: <A extends readonly types.Stream<any>[]>(...streams: A) => types.Stream<{ readonly [K in keyof A]: ValueOf<A[K]>; }>;
/**
* @since 0.11.0
* @category Combinator
*/
export declare const combineStruct: <A>(streams: { readonly [K in keyof A]: types.Stream<A[K]>; }) => types.Stream<A>;
/**
* @since 0.9.2
* @category Combinator
*/
export declare const exhaustLatest: <A>(stream: types.Stream<types.Stream<A>>) => types.Stream<A>;
/**
* @since 0.9.2
* @category Combinator
*/
export declare const exhaustMapLatest: <A, B>(f: (value: A) => types.Stream<B>) => (stream: types.Stream<A>) => types.Stream<B>;
/**
* Using the provided Eq mergeMapWhen conditionally applies a Kliesli arrow
* to the values within an Array when they are added and any values removed
* from the array will be disposed of immediately
* @since 0.9.2
* @category Combinator
*/
export declare const mergeMapWhen: <V>(Eq?: Eq<V>) => <A>(f: (value: V) => types.Stream<A>) => (values: Stream<readonly V[]>) => Stream<readonly A[]>;
/**
* @since 0.9.2
* @category Combinator
*/
export declare const keyed: <A>(Eq: Eq<A>) => (stream: Stream<readonly A[]>) => Stream<readonly Stream<A>[]>;
/**
* @since 0.9.2
* @category Combinator
*/
export declare const switchFirst: <A>(second: Stream<A>) => <B>(first: Stream<B>) => Stream<B>;
/**
* @since 0.9.2
* @category Combinator
*/
export declare function mergeFirst<A>(a: Stream<A>): <B>(b: Stream<B>) => Stream<B>;
export * from '@most/core';
export * from '@most/types';
//# sourceMappingURL=Stream.d.ts.map