fp-ts-wonka

/** * A “[source](https://wonka.kitten.sh/api/sources)" in Wonka is a provider of * data. It provides data to a “sink” when the “sink” requests it. This is * called a pull signal and for synchronous sources no time will pass between * the sink pulling a new value and a source sending it. For asynchronous * sources, the source may either ignore pull signals and just push values or * send one some time after the pull signal. * * @since 0.1.0 */ import { Alt1 } from 'fp-ts/Alt'; import { Alternative1 } from 'fp-ts/Alternative'; import { Applicative1 } from 'fp-ts/Applicative'; import { Apply1 } from 'fp-ts/Apply'; import { Compactable1 } from 'fp-ts/Compactable'; import { Separated } from 'fp-ts/Separated'; import * as E from 'fp-ts/Either'; import { Filterable1 } from 'fp-ts/Filterable'; import { Predicate } from 'fp-ts/Predicate'; import { Refinement } from 'fp-ts/Refinement'; import { Functor1 } from 'fp-ts/Functor'; import { Chain1 } from 'fp-ts/Chain'; import { Monad1 } from 'fp-ts/Monad'; import { MonadIO1 } from 'fp-ts/MonadIO'; import { MonadTask1 } from 'fp-ts/MonadTask'; import { Monoid } from 'fp-ts/Monoid'; import * as O from 'fp-ts/Option'; import * as Wonka from 'wonka'; import { MonadSource1 } from './MonadSource'; import { Task } from 'fp-ts/lib/Task'; import { Pointed1 } from 'fp-ts/lib/Pointed'; /** * @since 0.1.0 * @category Model */ export declare type Source<A> = Wonka.Source<A>; /** * @since 0.1.0 * @category Natural transformations */ export declare const fromOption: <A>(o: O.Option<A>) => Wonka.Source<A>; /** * @since 0.1.0 * @category Natural transformations */ export declare const fromIO: MonadIO1<URI>['fromIO']; /** * @since 0.1.0 * @category Natural transformations */ export declare const fromTask: MonadTask1<URI>['fromTask']; /** * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) * => F` whose argument and return types use the type constructor `F` to * represent some computational context. * * @since 0.1.0 * @category Functor */ export declare const map: <A, B>(f: (a: A) => B) => (fa: Wonka.Source<A>) => Wonka.Source; /** * Apply a function to an argument under a type constructor. * * @since 0.1.0 * @category Apply */ export declare const ap: <A>(fa: Wonka.Source<A>) => (fab: Wonka.Source<(a: A) => B>) => Wonka.Source; /** * Apply a function to an argument under a type constructor. * * @since 0.1.0 * @category Apply */ export declare const apW: <A>(fa: Source<A>) => (fab: Source<(a: A) => B>) => Source; /** * Combine two effectful actions, keeping only the result of the first. * * Derivable from `Apply`. * * @since 0.1.0 * @category Combinators */ export declare const apFirst: (fb: Wonka.Source) => <A>(fa: Wonka.Source<A>) => Wonka.Source<A>; /** * Combine two effectful actions, keeping only the result of the second. * * Derivable from `Apply`. * * @since 0.1.0 * @category Combinators */ export declare const apSecond: (fb: Wonka.Source) => <A>(fa: Wonka.Source<A>) => Wonka.Source; /** * @since 0.1.0 * @category Pointed */ export declare const of: Pointed1<URI>['of']; /** * Composes computations in sequence, using the return value of one computation * to determine the next computation. * * @since 0.1.0 * @category Monad */ export declare const chain: <A, B>(f: (a: A) => Wonka.Source) => (ma: Wonka.Source<A>) => Wonka.Source; /** * Derivable from `Monad`. * * @since 0.1.0 * @category Combinators */ export declare const flatten: <A>(mma: Wonka.Source<Wonka.Source<A>>) => Wonka.Source<A>; /** * Identifies an associative operation on a type constructor. It is similar to * `Semigroup`, except that it applies to types of kind `* -> *`. * * @since 0.1.0 * @category Alt */ export declare const alt: <A>(that: () => Wonka.Source<A>) => (fa: Wonka.Source<A>) => Wonka.Source<A>; /** * @since 0.1.0 * @category Filterable */ export declare const filterMap: <A, B>(f: (a: A) => O.Option) => (fa: Wonka.Source<A>) => Wonka.Source; /** * @since 0.1.0 * @category Compactable */ export declare const compact: <A>(fa: Wonka.Source<O.Option<A>>) => Wonka.Source<A>; /** * @since 0.1.0 * @category Filterable */ export declare const partitionMap: <A, B, C>(f: (a: A) => E.Either<B, C>) => (fa: Wonka.Source<A>) => Separated<Wonka.Source, Wonka.Source<C>>; /** * @since 0.1.0 * @category Compactable */ export declare const separate: <A, B>(fa: Wonka.Source<E.Either<A, B>>) => Separated<Wonka.Source<A>, Wonka.Source>; /** * @since 0.1.0 * @category Filterable */ export declare const filter: { <A, B extends A>(refinement: Refinement<A, B>): (fa: Wonka.Source<A>) => Wonka.Source; <A>(predicate: Predicate<A>): (fa: Wonka.Source<A>) => Wonka.Source<A>; }; /** * @since 0.1.0 * @category Filterable */ export declare const partition: { <A, B extends A>(refinement: Refinement<A, B>): (fa: Wonka.Source<A>) => Separated<Wonka.Source<A>, Wonka.Source>; <A>(predicate: Predicate<A>): (fa: Wonka.Source<A>) => Separated<Wonka.Source<A>, Wonka.Source<A>>; }; /** * @since 0.1.0 * @category Alternative */ export declare const zero: Alternative1<URI>['zero']; /** * @since 0.1.0 * @category Instances */ export declare const URI = "wonka/Source"; /** * @since 0.1.0 * @category Instances */ export declare type URI = typeof URI; declare module 'fp-ts/lib/HKT' { interface URItoKind<A> { readonly [URI]: Wonka.Source<A>; } } /** * @since 0.1.0 * @category Instances */ export declare const getMonoid: <A = never>() => Monoid<Wonka.Source<A>>; /** * @since 0.1.0 * @category Instances */ export declare const Functor: Functor1<URI>; /** * @since 0.1.0 * @category Instances */ export declare const Pointed: Pointed1<URI>; /** * Derivable from `Functor`. * * @since 0.1.0 * @category Combinators */ export declare const flap: <A>(a: A) => (fab: Wonka.Source<(a: A) => B>) => Wonka.Source; /** * @since 0.1.0 * @category Instances */ export declare const Apply: Apply1<URI>; /** * @since 0.1.0 * @category Instances */ export declare const Applicative: Applicative1<URI>; /** * @since 0.1.0 * @category Instances */ export declare const Chain: Chain1<URI>; /** * Composes computations in sequence, using the return value of one computation * to determine the next computation and keeping only the result of the first. * * Derivable from `Monad`. * * @since 0.1.0 * @category Combinators */ export declare const chainFirst: <A, B>(f: (a: A) => Wonka.Source) => (ma: Wonka.Source<A>) => Wonka.Source<A>; /** * @since 0.1.0 * @category Instances */ export declare const Monad: Monad1<URI>; /** * @since 0.1.0 * @category Instances */ export declare const Alt: Alt1<URI>; /** * @since 0.1.0 * @category Instances */ export declare const Alternative: Alternative1<URI>; /** * @since 0.1.0 * @category Instances */ export declare const Compactable: Compactable1<URI>; /** * @since 0.1.0 * @category Instances */ export declare const Filterable: Filterable1<URI>; /** * @since 0.1.0 * @category Instances */ export declare const MonadIO: MonadIO1<URI>; /** * @since 0.1.0 * @category Instances */ export declare const MonadTask: MonadTask1<URI>; /** * @since 0.1.0 * @category Instances */ export declare const MonadSource: MonadSource1<URI>; /** @since 0.1.0 */ export declare const Do: Wonka.Source<Record<PropertyKey, unknown>>; /** @since 0.1.0 */ export declare const bindTo: <N extends string>(name: N) => <A>(fa: Wonka.Source<A>) => Wonka.Source<{ readonly [K in N]: A; }>; /** @since 0.1.0 */ export declare const bind: <N extends string, A, B>(name: Exclude<N, keyof A>, f: (a: A) => Wonka.Source) => (ma: Wonka.Source<A>) => Wonka.Source<{ readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>; /** @since 0.1.0 */ export declare const apS: <N extends string, A, B>(name: Exclude<N, keyof A>, fb: Wonka.Source) => (fa: Wonka.Source<A>) => Wonka.Source<{ readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>; /** @since 0.1.0 */ export declare const apSW: <A, N extends string, B>(name: Exclude<N, keyof A>, fb: Source) => (fa: Source<A>) => Source<{ readonly [K in keyof A | N]: K extends keyof A ? A[K] : B; }>; /** @since 0.1.0 */ export declare const toTask: <A>(s: Wonka.Source<A>) => Task<A>;