fp-ts-zio/lib/Stream.d.ts

fp-ts bindings for Scala ZIO

import { Alt2 } from 'fp-ts/lib/Alt';
import { Bifunctor2 } from 'fp-ts/lib/Bifunctor';
import * as Et from 'fp-ts/lib/Either';
import { Monad2 } from 'fp-ts/lib/Monad';
import { MonadTask2 } from 'fp-ts/lib/MonadTask';
import { MonadThrow2 } from 'fp-ts/lib/MonadThrow';
import { Observable } from 'rxjs';
import Either = Et.Either;
import { ZIO } from './ZIO';
declare module 'fp-ts/lib/HKT' {
    interface URItoKind2<E, A> {
        Stream: Stream<E, A>;
    }
}
export declare const URI = "Stream";
export declare type URI = typeof URI;
export declare type Stream<E, A> = Observable<Either<E, A>>;
declare const fail: <E = never, A = never>(e: E) => Stream<E, A>;
declare const succeed: <E = never, A = never>(a: A) => Stream<E, A>;
declare const failObservable: <E = never, A = never>(me: Observable<E>) => Observable<Et.Either<E, A>>;
declare const succeedObservable: <E = never, A = never>(ma: Observable<A>) => Stream<E, A>;
declare const failLazy: <E = never, A = never>(me: () => E) => Observable<Et.Either<E, A>>;
declare const succeedLazy: <E = never, A = never>(ma: () => A) => Observable<Et.Either<E, A>>;
declare const failPromise: <E = never, A = never>(me: () => Promise<E>) => Observable<Et.Either<E, A>>;
declare const succeedPromise: <E = never, A = never>(ma: () => Promise<A>) => Observable<Et.Either<E, A>>;
declare const foldM: <E, A, B>(onError: (e: E) => Observable<Et.Either<never, B>>, onSuccess: (a: A) => Observable<Et.Either<never, B>>) => (ma: Observable<Et.Either<E, A>>) => Observable<Et.Either<never, B>>;
declare const fold: <E, A, B>(onError: (e: E) => B, onSuccess: (a: A) => B) => (ma: Stream<E, A>) => Stream<never, B>;
declare const getOrElseM: <E, A>(onError: (e: E) => Stream<never, A>) => (ma: Stream<E, A>) => Stream<never, A>;
declare const getOrElse: <E, A>(onError: (e: E) => A) => (ma: Stream<E, A>) => Stream<never, A>;
declare const orElse: <E, A, M>(onError: (e: E) => Observable<Et.Either<M, A>>) => (ma: Observable<Et.Either<E, A>>) => Observable<Et.Either<M, A>>;
declare const swap: <E, A>(ma: Stream<E, A>) => Stream<A, E>;
declare const tryCatch: <E, A>(f: Observable<A>, onError: (reason: unknown) => Observable<Et.Either<E, A>>) => Observable<Et.Either<E, A>>;
declare const foreachM: <R, E, A>(f: (a: A) => ZIO<R, E, any>) => (ma: Observable<Et.Either<E, A>>) => ZIO<R, E, void>;
declare const foreach: <R, E, A>(f: (a: A) => any) => (ma: Stream<E, A>) => ZIO<R, E, void>;
export declare function bracket<E, A, B>(acquire: Stream<E, A>, use: (a: A) => Stream<E, B>, release: (a: A, e: Either<E, B>) => Stream<E, void>): Stream<E, B>;
export declare const stream: Monad2<URI> & Bifunctor2<URI> & Alt2<URI> & MonadTask2<URI> & MonadThrow2<URI>;
export declare const streamSeq: typeof stream;
declare const alt: <E, A>(that: () => Observable<Et.Either<E, A>>) => (fa: Observable<Et.Either<E, A>>) => Observable<Et.Either<E, A>>, ap: <E, A>(fa: Observable<Et.Either<E, A>>) => <B>(fab: Observable<Et.Either<E, (a: A) => B>>) => Observable<Et.Either<E, B>>, apFirst: <E, B>(fb: Observable<Et.Either<E, B>>) => <A>(fa: Observable<Et.Either<E, A>>) => Observable<Et.Either<E, A>>, apSecond: <E, B>(fb: Observable<Et.Either<E, B>>) => <A>(fa: Observable<Et.Either<E, A>>) => Observable<Et.Either<E, B>>, bimap: <E, G, A, B>(f: (e: E) => G, g: (a: A) => B) => (fa: Observable<Et.Either<E, A>>) => Observable<Et.Either<G, B>>, chainFirst: <E, A, B>(f: (a: A) => Observable<Et.Either<E, B>>) => (ma: Observable<Et.Either<E, A>>) => Observable<Et.Either<E, A>>, flatten: <E, A>(mma: Observable<Et.Either<E, Observable<Et.Either<E, A>>>>) => Observable<Et.Either<E, A>>, map: <A, B>(f: (a: A) => B) => <E>(fa: Observable<Et.Either<E, A>>) => Observable<Et.Either<E, B>>, fromEither: <E, A>(ma: Et.Either<E, A>) => Observable<Et.Either<E, A>>, fromOption: <E>(onNone: () => E) => <A>(ma: import("fp-ts/lib/Option").Option<A>) => Observable<Et.Either<E, A>>, fromPredicate: {
    <E, A, B extends A>(refinement: import("fp-ts/lib/function").Refinement<A, B>, onFalse: (a: A) => E): (a: A) => Observable<Et.Either<E, B>>;
    <E_1, A_1>(predicate: import("fp-ts/lib/function").Predicate<A_1>, onFalse: (a: A_1) => E_1): (a: A_1) => Observable<Et.Either<E_1, A_1>>;
}, filterOrElse: {
    <E, A, B extends A>(refinement: import("fp-ts/lib/function").Refinement<A, B>, onFalse: (a: A) => E): (ma: Observable<Et.Either<E, A>>) => Observable<Et.Either<E, B>>;
    <E_1, A_1>(predicate: import("fp-ts/lib/function").Predicate<A_1>, onFalse: (a: A_1) => E_1): (ma: Observable<Et.Either<E_1, A_1>>) => Observable<Et.Either<E_1, A_1>>;
};
declare const mapError: <E, G>(f: (e: E) => G) => <A>(fa: Observable<Et.Either<E, A>>) => Observable<Et.Either<G, A>>;
declare const flatMap: <E, A, B>(f: (a: A) => Observable<Et.Either<E, B>>) => (ma: Observable<Et.Either<E, A>>) => Observable<Et.Either<E, B>>;
export { alt, ap, apFirst, apSecond, bimap, flatMap, chainFirst, flatten, map, mapError, fromEither, fromOption, fromPredicate, filterOrElse, fail, succeed, failObservable, succeedObservable, failLazy, succeedLazy, failPromise, succeedPromise, foldM, fold, getOrElseM, getOrElse, orElse, swap, tryCatch, foreachM, foreach };