@typed/fp/cjs/RefAdapter.d.ts

Data Structures and Resources for fp-ts

import { Functor4 } from 'fp-ts/Functor';
import { Profunctor4 } from 'fp-ts/Profunctor';
import * as A from './Adapter';
import * as E from './Env';
import * as RS from './ReaderStream';
import * as Ref from './Ref';
/**
 * RefAdapter is an abstraction of Refs that will output an Adapter to send and receive events through.
 * It utilizes the output of its Ref instead of the input so you will not find any combinators for
 * updating the Adapter in-place. This allows for creating a Functor + Profunctor instances
 * @since 0.11.0
 * @category Model
 */
export interface RefAdapter<E, I, A, B = A> extends Ref.Ref<E, I, A.Adapter<A, B>> {
}
/**
 * @since 0.12.0
 * @category Combinator
 */
export declare function sendEvent<A>(event: A): <E, B, C>(ra: RefAdapter<E, B, A, C>) => E.Env<E, void>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare function getSendEvent<E, A, B, C>(ra: RefAdapter<E, A, B, C>): E.Env<E, (event: B) => void>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare function getEvents<E, A, B, C>(ra: RefAdapter<E, A, B, C>): RS.ReaderStream<E, C>;
/**
 * @since 0.12.0
 * @category Combinator
 */
export declare function listenToEvents<A, E1, B>(f: (value: A) => E.Env<E1, B>): <E2, C>(ra: RefAdapter<E2, C, B, A>) => RS.ReaderStream<E1 & E2, B>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare function map<A, B>(f: (value: A) => B): <E, C, D>(ra: RefAdapter<E, C, D, A>) => RefAdapter<E, C, D, B>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare function local<A, B>(f: (value: A) => B): <E, C, D>(ra: RefAdapter<E, C, B, D>) => RefAdapter<E, C, A, D>;
/**
 * @since 0.11.0
 * @category Combinator
 */
export declare const promap: <B, A, C, D>(f: (value: B) => A, g: (value: C) => D) => <E, I>(adapter: RefAdapter<E, I, A, C>) => RefAdapter<E, I, B, D>;
/**
 * @since 0.11.0
 * @category URI
 */
export declare const URI = "@typed/fp/RefAdapter";
/**
 * @since 0.11.0
 * @category URI
 */
export declare type URI = typeof URI;
declare module 'fp-ts/HKT' {
    interface URItoKind4<S, R, E, A> {
        [URI]: RefAdapter<S, R, E, A>;
    }
}
declare module './HKT' {
    interface URItoVariance {
        [URI]: V<S, Contravariant> & V<R, Contravariant>;
    }
}
/**
 * @since 0.11.0
 * @category Instance
 */
export declare const Functor: Functor4<URI>;
/**
 * @since 0.11.0
 * @category Instance
 */
export declare const Profunctor: Profunctor4<URI>;
/**
 * @since 0.13.5
 * @category Instance
 */
export declare function wrap<E, I, A, B>(ra: RefAdapter<E, I, A, B>): {
    readonly sendEvent: (event: A) => E.Env<E, void>;
    readonly getSendEvent: E.Env<E, (event: A) => void>;
    readonly events: RS.ReaderStream<E, B>;
    readonly listenToEvents: <E2>(f: (value: B) => E.Env<E2, A>) => RS.ReaderStream<E2 & E, A>;
    readonly get: E.Env<E, readonly [(event: A) => void, import("@most/types").Stream<B>]>;
    readonly has: E.Env<E, boolean>;
    readonly set: (input: I) => E.Env<E, readonly [(event: A) => void, import("@most/types").Stream<B>]>;
    readonly update: <E2_1>(f: (value: readonly [(event: A) => void, import("@most/types").Stream<B>]) => E.Env<E2_1, I>) => E.Env<E & E2_1, readonly [(event: A) => void, import("@most/types").Stream<B>]>;
    readonly remove: E.Env<E, import("fp-ts/Option").Option<readonly [(event: A) => void, import("@most/types").Stream<B>]>>;
    readonly values: RS.ReaderStream<E, import("fp-ts/Option").Option<readonly [(event: A) => void, import("@most/types").Stream<B>]>>;
};
//# sourceMappingURL=RefAdapter.d.ts.map