fp-ts-fluture/lib/StateFuture.d.ts

fp-ts bindings for Fluture

/**
 * @since 0.6.5
 */
import { IO } from 'fp-ts/lib/IO'
import { Monad3 } from 'fp-ts/lib/Monad'
import { MonadThrow3 } from 'fp-ts/lib/MonadThrow'
import { State } from 'fp-ts/lib/State'
import { Task } from 'fp-ts/lib/Task'
import * as E from 'fp-ts/lib/Either'
import { Bifunctor3 } from 'fp-ts/lib/Bifunctor'
import { Alt3 } from 'fp-ts/lib/Alt'
import { MonadTask3 } from 'fp-ts/lib/MonadTask'
import * as F from './Future'
declare module 'fp-ts/lib/HKT' {
  interface URItoKind3<R, E, A> {
    StateFuture: StateFuture<R, E, A>
  }
}
/**
 * @since 0.6.5
 */
export declare const URI = 'StateFuture'
/**
 * @since 0.6.5
 */
export declare type URI = typeof URI
/**
 * @since 0.6.5
 */
export interface StateFuture<S, E, A> {
  (s: S): F.Future<E, [A, S]>
}
/**
 * @since 0.6.5
 */
export declare const evalState: <S, E, A>(ma: StateFuture<S, E, A>, s: S) => F.Future<E, A>
/**
 * @since 0.6.5
 */
export declare const execState: <S, E, A>(ma: StateFuture<S, E, A>, s: S) => F.Future<E, S>
/**
 * @since 0.6.5
 */
export declare function left<S, E, A = never>(e: E): StateFuture<S, E, A>
/**
 * @since 0.6.5
 */
export declare const right: <S, E = never, A = never>(a: A) => StateFuture<S, E, A>
/**
 * @since 0.6.5
 */
export declare function rightTask<S, E = never, A = never>(ma: Task<A>): StateFuture<S, E, A>
/**
 * @since 0.6.5
 */
export declare function leftTask<S, E, A = never>(me: Task<E>): StateFuture<S, E, A>
/**
 * @since 0.6.5
 */
export declare const fromFuture: <S, E, A>(ma: F.Future<E, A>) => StateFuture<S, E, A>
/**
 * @since 0.6.5
 */
export declare function rightIO<S, E = never, A = never>(ma: IO<A>): StateFuture<S, E, A>
/**
 * @since 0.6.5
 */
export declare function leftIO<S, E, A = never>(me: IO<E>): StateFuture<S, E, A>
/**
 * @since 0.6.5
 */
export declare const rightState: <S, E = never, A = never>(ma: State<S, A>) => StateFuture<S, E, A>
/**
 * @since 0.6.5
 */
export declare function leftState<S, E, A = never>(me: State<S, E>): StateFuture<S, E, A>
/**
 * @since 0.6.5
 */
export declare function orElse<S, E, M, A>(
  f: (e: E) => StateFuture<S, M, A>
): (ma: StateFuture<S, E, A>) => StateFuture<S, M, A>
/**
 * @since 0.6.5
 */
export declare const get: <S, E = never>() => StateFuture<S, E, S>
/**
 * @since 0.6.5
 */
export declare const put: <S, E = never>(s: S) => StateFuture<S, E, void>
/**
 * @since 0.6.5
 */
export declare const modify: <S, E = never>(f: (s: S) => S) => StateFuture<S, E, void>
/**
 * @since 0.6.5
 */
export declare const gets: <S, E = never, A = never>(f: (s: S) => A) => StateFuture<S, E, A>
/**
 * @since 0.6.5
 */
export declare function fromEitherK<E, A extends Array<unknown>, B>(
  f: (...a: A) => E.Either<E, B>
): <S>(...a: A) => StateFuture<S, E, B>
/**
 * @since 0.6.5
 */
export declare function chainEitherK<E, A, B>(
  f: (a: A) => E.Either<E, B>
): <S>(ma: StateFuture<S, E, A>) => StateFuture<S, E, B>
/**
 * @since 0.6.5
 */
export declare function fromFutureK<E, A extends Array<unknown>, B>(
  f: (...a: A) => F.Future<E, B>
): <S>(...a: A) => StateFuture<S, E, B>
/**
 * @since 0.6.5
 */
export declare function chainFutureK<E, A, B>(
  f: (a: A) => F.Future<E, B>
): <S>(ma: StateFuture<S, E, A>) => StateFuture<S, E, B>
/**
 * @since 0.6.5
 */
export declare const stateFuture: Monad3<URI> &
  MonadThrow3<URI> &
  Bifunctor3<URI> &
  Alt3<URI> &
  MonadThrow3<URI> &
  MonadTask3<URI>
declare const alt: <R, E, A>(that: () => StateFuture<R, E, A>) => (fa: StateFuture<R, E, A>) => StateFuture<R, E, A>,
  ap: <R, E, A>(fa: StateFuture<R, E, A>) => <B>(fab: StateFuture<R, E, (a: A) => B>) => StateFuture<R, E, B>,
  apFirst: <R, E, B>(fb: StateFuture<R, E, B>) => <A>(fa: StateFuture<R, E, A>) => StateFuture<R, E, A>,
  apSecond: <R, E, B>(fb: StateFuture<R, E, B>) => <A>(fa: StateFuture<R, E, A>) => StateFuture<R, E, B>,
  bimap: <E, G, A, B>(f: (e: E) => G, g: (a: A) => B) => <R>(fa: StateFuture<R, E, A>) => StateFuture<R, G, B>,
  chain: <R, E, A, B>(f: (a: A) => StateFuture<R, E, B>) => (ma: StateFuture<R, E, A>) => StateFuture<R, E, B>,
  chainFirst: <R, E, A, B>(f: (a: A) => StateFuture<R, E, B>) => (ma: StateFuture<R, E, A>) => StateFuture<R, E, A>,
  flatten: <R, E, A>(mma: StateFuture<R, E, StateFuture<R, E, A>>) => StateFuture<R, E, A>,
  map: <A, B>(f: (a: A) => B) => <R, E>(fa: StateFuture<R, E, A>) => StateFuture<R, E, B>,
  mapLeft: <E, G>(f: (e: E) => G) => <R, A>(fa: StateFuture<R, E, A>) => StateFuture<R, G, A>,
  filterOrElse: {
    <E, A, B extends A>(refinement: import('fp-ts/lib/function').Refinement<A, B>, onFalse: (a: A) => E): <R>(
      ma: StateFuture<R, E, A>
    ) => StateFuture<R, E, B>
    <E_1, A_1>(predicate: import('fp-ts/lib/function').Predicate<A_1>, onFalse: (a: A_1) => E_1): <R_1>(
      ma: StateFuture<R_1, E_1, A_1>
    ) => StateFuture<R_1, E_1, A_1>
  },
  fromEither: <R, E, A>(ma: E.Either<E, A>) => StateFuture<R, E, A>,
  fromOption: <E>(onNone: () => E) => <R, A>(ma: import('fp-ts/lib/Option').Option<A>) => StateFuture<R, E, A>,
  fromPredicate: {
    <E, A, B extends A>(refinement: import('fp-ts/lib/function').Refinement<A, B>, onFalse: (a: A) => E): <U>(
      a: A
    ) => StateFuture<U, E, B>
    <E_1, A_1>(predicate: import('fp-ts/lib/function').Predicate<A_1>, onFalse: (a: A_1) => E_1): <R>(
      a: A_1
    ) => StateFuture<R, E_1, A_1>
  }
export {
  /**
   * @since 0.6.5
   */
  alt,
  /**
   * @since 0.6.5
   */
  ap,
  /**
   * @since 0.6.5
   */
  apFirst,
  /**
   * @since 0.6.5
   */
  apSecond,
  /**
   * @since 0.6.5
   */
  bimap,
  /**
   * @since 0.6.5
   */
  chain,
  /**
   * @since 0.6.5
   */
  chainFirst,
  /**
   * @since 0.6.5
   */
  flatten,
  /**
   * @since 0.6.5
   */
  map,
  /**
   * @since 0.6.5
   */
  mapLeft,
  /**
   * @since 0.6.5
   */
  filterOrElse,
  /**
   * @since 0.6.5
   */
  fromEither,
  /**
   * @since 0.6.5
   */
  fromOption,
  /**
   * @since 0.6.5
   */
  fromPredicate
}