fp-ts
Version:
Functional programming in TypeScript
1,253 lines • 89.5 kB
TypeScript
/**
* @since 2.0.0
*/
import { Alt, Alt1, Alt2, Alt2C, Alt3, Alt3C, Alt4 } from './Alt'
import { Apply, Apply1, Apply2, Apply2C, Apply3, Apply3C, Apply4 } from './Apply'
import { Bifunctor, Bifunctor2, Bifunctor2C, Bifunctor3, Bifunctor3C, Bifunctor4 } from './Bifunctor'
import { Chain, Chain1, Chain2, Chain2C, Chain3, Chain3C, Chain4 } from './Chain'
import {
Compactable,
Compactable1,
Compactable2,
Compactable2C,
Compactable3,
Compactable3C,
Compactable4
} from './Compactable'
import {
Contravariant,
Contravariant1,
Contravariant2,
Contravariant2C,
Contravariant3,
Contravariant3C,
Contravariant4
} from './Contravariant'
import { Either } from './Either'
import { Extend, Extend1, Extend2, Extend2C, Extend3, Extend3C, Extend4 } from './Extend'
import {
Filterable,
Filterable1,
Filterable2,
Filterable2C,
Filterable3,
Filterable3C,
Filterable4
} from './Filterable'
import {
FilterableWithIndex,
FilterableWithIndex1,
FilterableWithIndex2,
FilterableWithIndex2C,
FilterableWithIndex3,
FilterableWithIndex3C,
FilterableWithIndex4,
PredicateWithIndex,
RefinementWithIndex
} from './FilterableWithIndex'
import { Foldable, Foldable1, Foldable2, Foldable2C, Foldable3, Foldable3C, Foldable4 } from './Foldable'
import {
FoldableWithIndex,
FoldableWithIndex1,
FoldableWithIndex2,
FoldableWithIndex2C,
FoldableWithIndex3,
FoldableWithIndex3C,
FoldableWithIndex4
} from './FoldableWithIndex'
import { LazyArg, pipe as pipeFromFunctionModule } from './function'
import { Functor, Functor1, Functor2, Functor2C, Functor3, Functor3C, Functor4 } from './Functor'
import {
FunctorWithIndex,
FunctorWithIndex1,
FunctorWithIndex2,
FunctorWithIndex2C,
FunctorWithIndex3,
FunctorWithIndex3C,
FunctorWithIndex4
} from './FunctorWithIndex'
import { HKT, HKT2, Kind, Kind2, Kind3, Kind4, URIS, URIS2, URIS3, URIS4 } from './HKT'
import {
MonadThrow,
MonadThrow1,
MonadThrow2,
MonadThrow2C,
MonadThrow3,
MonadThrow3C,
MonadThrow4
} from './MonadThrow'
import { Monoid } from './Monoid'
import { Option } from './Option'
import { Predicate } from './Predicate'
import { Profunctor, Profunctor2, Profunctor2C, Profunctor3, Profunctor3C, Profunctor4 } from './Profunctor'
import { Refinement } from './Refinement'
import {
Semigroupoid,
Semigroupoid2,
Semigroupoid2C,
Semigroupoid3,
Semigroupoid3C,
Semigroupoid4
} from './Semigroupoid'
import { Separated } from './Separated'
/**
* Returns a pipeable `map`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function map<F extends URIS4>(
F: Functor4<F>
): <A, B>(f: (a: A) => B) => <S, R, E>(fa: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, B>
export declare function map<F extends URIS3>(
F: Functor3<F>
): <A, B>(f: (a: A) => B) => <R, E>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
export declare function map<F extends URIS3, E>(
F: Functor3C<F, E>
): <A, B>(f: (a: A) => B) => <R>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
export declare function map<F extends URIS2>(
F: Functor2<F>
): <A, B>(f: (a: A) => B) => <E>(fa: Kind2<F, E, A>) => Kind2<F, E, B>
export declare function map<F extends URIS2, E>(
F: Functor2C<F, E>
): <A, B>(f: (a: A) => B) => (fa: Kind2<F, E, A>) => Kind2<F, E, B>
export declare function map<F extends URIS>(F: Functor1<F>): <A, B>(f: (a: A) => B) => (fa: Kind<F, A>) => Kind<F, B>
export declare function map<F>(F: Functor<F>): <A, B>(f: (a: A) => B) => (fa: HKT<F, A>) => HKT<F, B>
/**
* Returns a pipeable `contramap`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function contramap<F extends URIS4>(
F: Contravariant4<F>
): <A, B>(f: (b: B) => A) => <S, R, E>(fa: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, B>
export declare function contramap<F extends URIS3>(
F: Contravariant3<F>
): <A, B>(f: (b: B) => A) => <R, E>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
export declare function contramap<F extends URIS3, E>(
F: Contravariant3C<F, E>
): <A, B>(f: (b: B) => A) => <R>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
export declare function contramap<F extends URIS2>(
F: Contravariant2<F>
): <A, B>(f: (b: B) => A) => <E>(fa: Kind2<F, E, A>) => Kind2<F, E, B>
export declare function contramap<F extends URIS2, E>(
F: Contravariant2C<F, E>
): <A, B>(f: (b: B) => A) => (fa: Kind2<F, E, A>) => Kind2<F, E, B>
export declare function contramap<F extends URIS>(
F: Contravariant1<F>
): <A, B>(f: (b: B) => A) => (fa: Kind<F, A>) => Kind<F, B>
export declare function contramap<F>(F: Contravariant<F>): <A, B>(f: (b: B) => A) => (fa: HKT<F, A>) => HKT<F, B>
/**
* Returns a pipeable `mapWithIndex`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function mapWithIndex<F extends URIS4, I>(
F: FunctorWithIndex4<F, I>
): <A, B>(f: (i: I, a: A) => B) => <S, R, E>(fa: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, B>
export declare function mapWithIndex<F extends URIS3, I>(
F: FunctorWithIndex3<F, I>
): <A, B>(f: (i: I, a: A) => B) => <R, E>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
export declare function mapWithIndex<F extends URIS3, I, E>(
F: FunctorWithIndex3C<F, I, E>
): <A, B>(f: (i: I, a: A) => B) => <R>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
export declare function mapWithIndex<F extends URIS2, I>(
F: FunctorWithIndex2<F, I>
): <A, B>(f: (i: I, a: A) => B) => <E>(fa: Kind2<F, E, A>) => Kind2<F, E, B>
export declare function mapWithIndex<F extends URIS2, I, E>(
F: FunctorWithIndex2C<F, I, E>
): <A, B>(f: (i: I, a: A) => B) => (fa: Kind2<F, E, A>) => Kind2<F, E, B>
export declare function mapWithIndex<F extends URIS, I>(
F: FunctorWithIndex1<F, I>
): <A, B>(f: (i: I, a: A) => B) => (fa: Kind<F, A>) => Kind<F, B>
export declare function mapWithIndex<F, I>(
F: FunctorWithIndex<F, I>
): <A, B>(f: (i: I, a: A) => B) => (fa: HKT<F, A>) => HKT<F, B>
/**
* Returns a pipeable `ap`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function ap<F extends URIS4>(
F: Apply4<F>
): <S, R, E, A>(fa: Kind4<F, S, R, E, A>) => <B>(fab: Kind4<F, S, R, E, (a: A) => B>) => Kind4<F, S, R, E, B>
export declare function ap<F extends URIS3>(
F: Apply3<F>
): <R, E, A>(fa: Kind3<F, R, E, A>) => <B>(fab: Kind3<F, R, E, (a: A) => B>) => Kind3<F, R, E, B>
export declare function ap<F extends URIS3, E>(
F: Apply3C<F, E>
): <R, A>(fa: Kind3<F, R, E, A>) => <B>(fab: Kind3<F, R, E, (a: A) => B>) => Kind3<F, R, E, B>
export declare function ap<F extends URIS2>(
F: Apply2<F>
): <E, A>(fa: Kind2<F, E, A>) => <B>(fab: Kind2<F, E, (a: A) => B>) => Kind2<F, E, B>
export declare function ap<F extends URIS2, E>(
F: Apply2C<F, E>
): <A>(fa: Kind2<F, E, A>) => <B>(fab: Kind2<F, E, (a: A) => B>) => Kind2<F, E, B>
export declare function ap<F extends URIS>(
F: Apply1<F>
): <A>(fa: Kind<F, A>) => <B>(fab: Kind<F, (a: A) => B>) => Kind<F, B>
export declare function ap<F>(F: Apply<F>): <A>(fa: HKT<F, A>) => <B>(fab: HKT<F, (a: A) => B>) => HKT<F, B>
/**
* Returns a pipeable `chain`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function chain<F extends URIS4>(
F: Chain4<F>
): <A, S, R, E, B>(f: (a: A) => Kind4<F, S, R, E, B>) => (fa: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, B>
export declare function chain<F extends URIS3>(
F: Chain3<F>
): <A, R, E, B>(f: (a: A) => Kind3<F, R, E, B>) => (fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
export declare function chain<F extends URIS3, E>(
F: Chain3C<F, E>
): <A, R, B>(f: (a: A) => Kind3<F, R, E, B>) => (fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
export declare function chain<F extends URIS2>(
F: Chain2<F>
): <A, E, B>(f: (a: A) => Kind2<F, E, B>) => (fa: Kind2<F, E, A>) => Kind2<F, E, B>
export declare function chain<F extends URIS2, E>(
F: Chain2C<F, E>
): <A, B>(f: (a: A) => Kind2<F, E, B>) => (fa: Kind2<F, E, A>) => Kind2<F, E, B>
export declare function chain<F extends URIS>(
F: Chain1<F>
): <A, B>(f: (a: A) => Kind<F, B>) => (fa: Kind<F, A>) => Kind<F, B>
export declare function chain<F>(F: Chain<F>): <A, B>(f: (a: A) => HKT<F, B>) => (fa: HKT<F, A>) => HKT<F, B>
/**
* Returns a pipeable `bimap`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function bimap<F extends URIS4>(
F: Bifunctor4<F>
): <E, G, A, B>(f: (e: E) => G, g: (a: A) => B) => <S, R>(fea: Kind4<F, S, R, E, A>) => Kind4<F, S, R, G, B>
export declare function bimap<F extends URIS3>(
F: Bifunctor3<F>
): <E, G, A, B>(f: (e: E) => G, g: (a: A) => B) => <R>(fea: Kind3<F, R, E, A>) => Kind3<F, R, G, B>
export declare function bimap<F extends URIS3, E>(
F: Bifunctor3C<F, E>
): <G, A, B>(f: (e: E) => G, g: (a: A) => B) => <R>(fea: Kind3<F, R, E, A>) => Kind3<F, R, G, B>
export declare function bimap<F extends URIS2>(
F: Bifunctor2<F>
): <E, G, A, B>(f: (e: E) => G, g: (a: A) => B) => (fea: Kind2<F, E, A>) => Kind2<F, G, B>
export declare function bimap<F extends URIS2, E>(
F: Bifunctor2C<F, E>
): <G, A, B>(f: (e: E) => G, g: (a: A) => B) => (fea: Kind2<F, E, A>) => Kind2<F, G, B>
export declare function bimap<F>(
F: Bifunctor<F>
): <E, G, A, B>(f: (e: E) => G, g: (a: A) => B) => (fea: HKT2<F, E, A>) => HKT2<F, G, B>
/**
* Returns a pipeable `mapLeft`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function mapLeft<F extends URIS4>(
F: Bifunctor4<F>
): <E, G>(f: (e: E) => G) => <S, R, A>(fea: Kind4<F, S, R, E, A>) => Kind4<F, S, R, G, A>
export declare function mapLeft<F extends URIS3>(
F: Bifunctor3<F>
): <E, G>(f: (e: E) => G) => <R, A>(fea: Kind3<F, R, E, A>) => Kind3<F, R, G, A>
export declare function mapLeft<F extends URIS3, E>(
F: Bifunctor3C<F, E>
): <E, G>(f: (e: E) => G) => <R, A>(fea: Kind3<F, R, E, A>) => Kind3<F, R, G, A>
export declare function mapLeft<F extends URIS2>(
F: Bifunctor2<F>
): <E, G>(f: (e: E) => G) => <A>(fea: Kind2<F, E, A>) => Kind2<F, G, A>
export declare function mapLeft<F extends URIS2, E>(
F: Bifunctor2C<F, E>
): <E, G>(f: (e: E) => G) => <A>(fea: Kind2<F, E, A>) => Kind2<F, G, A>
export declare function mapLeft<F>(F: Bifunctor<F>): <E, G>(f: (e: E) => G) => <A>(fea: HKT2<F, E, A>) => HKT2<F, G, A>
/**
* Returns a pipeable `extend`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function extend<F extends URIS4>(
F: Extend4<F>
): <S, R, E, A, B>(f: (wa: Kind4<F, S, R, E, A>) => B) => (wa: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, B>
export declare function extend<F extends URIS3>(
F: Extend3<F>
): <R, E, A, B>(f: (wa: Kind3<F, R, E, A>) => B) => (wa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
export declare function extend<F extends URIS3, E>(
F: Extend3C<F, E>
): <R, A, B>(f: (wa: Kind3<F, R, E, A>) => B) => (wa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
export declare function extend<F extends URIS2>(
F: Extend2<F>
): <E, A, B>(f: (wa: Kind2<F, E, A>) => B) => (wa: Kind2<F, E, A>) => Kind2<F, E, B>
export declare function extend<F extends URIS2, E>(
F: Extend2C<F, E>
): <A, B>(f: (wa: Kind2<F, E, A>) => B) => (wa: Kind2<F, E, A>) => Kind2<F, E, B>
export declare function extend<F extends URIS>(
F: Extend1<F>
): <A, B>(f: (wa: Kind<F, A>) => B) => (wa: Kind<F, A>) => Kind<F, B>
export declare function extend<F>(F: Extend<F>): <A, B>(f: (wa: HKT<F, A>) => B) => (wa: HKT<F, A>) => HKT<F, B>
/**
* Returns a pipeable `reduce`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function reduce<F extends URIS4>(
F: Foldable4<F>
): <A, B>(b: B, f: (b: B, a: A) => B) => <S, R, E>(fa: Kind4<F, S, R, E, A>) => B
export declare function reduce<F extends URIS3>(
F: Foldable3<F>
): <A, B>(b: B, f: (b: B, a: A) => B) => <R, E>(fa: Kind3<F, R, E, A>) => B
export declare function reduce<F extends URIS3, E>(
F: Foldable3C<F, E>
): <A, B>(b: B, f: (b: B, a: A) => B) => <R>(fa: Kind3<F, R, E, A>) => B
export declare function reduce<F extends URIS2>(
F: Foldable2<F>
): <A, B>(b: B, f: (b: B, a: A) => B) => <E>(fa: Kind2<F, E, A>) => B
export declare function reduce<F extends URIS2, E>(
F: Foldable2C<F, E>
): <A, B>(b: B, f: (b: B, a: A) => B) => (fa: Kind2<F, E, A>) => B
export declare function reduce<F extends URIS>(
F: Foldable1<F>
): <A, B>(b: B, f: (b: B, a: A) => B) => (fa: Kind<F, A>) => B
export declare function reduce<F>(F: Foldable<F>): <A, B>(b: B, f: (b: B, a: A) => B) => (fa: HKT<F, A>) => B
/**
* Returns a pipeable `foldMap`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function foldMap<F extends URIS4>(
F: Foldable4<F>
): <M>(M: Monoid<M>) => <A>(f: (a: A) => M) => <S, R, E>(fa: Kind4<F, S, R, E, A>) => M
export declare function foldMap<F extends URIS3>(
F: Foldable3<F>
): <M>(M: Monoid<M>) => <A>(f: (a: A) => M) => <R, E>(fa: Kind3<F, R, E, A>) => M
export declare function foldMap<F extends URIS3, E>(
F: Foldable3C<F, E>
): <M>(M: Monoid<M>) => <A>(f: (a: A) => M) => <R>(fa: Kind3<F, R, E, A>) => M
export declare function foldMap<F extends URIS2>(
F: Foldable2<F>
): <M>(M: Monoid<M>) => <A>(f: (a: A) => M) => <E>(fa: Kind2<F, E, A>) => M
export declare function foldMap<F extends URIS2, E>(
F: Foldable2C<F, E>
): <M>(M: Monoid<M>) => <A>(f: (a: A) => M) => (fa: Kind2<F, E, A>) => M
export declare function foldMap<F extends URIS>(
F: Foldable1<F>
): <M>(M: Monoid<M>) => <A>(f: (a: A) => M) => (fa: Kind<F, A>) => M
export declare function foldMap<F>(F: Foldable<F>): <M>(M: Monoid<M>) => <A>(f: (a: A) => M) => (fa: HKT<F, A>) => M
/**
* Returns a pipeable `reduceRight`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function reduceRight<F extends URIS4>(
F: Foldable4<F>
): <A, B>(b: B, f: (a: A, b: B) => B) => <S, R, E>(fa: Kind4<F, S, R, E, A>) => B
export declare function reduceRight<F extends URIS3>(
F: Foldable3<F>
): <A, B>(b: B, f: (a: A, b: B) => B) => <R, E>(fa: Kind3<F, R, E, A>) => B
export declare function reduceRight<F extends URIS3, E>(
F: Foldable3C<F, E>
): <A, B>(b: B, f: (a: A, b: B) => B) => <R>(fa: Kind3<F, R, E, A>) => B
export declare function reduceRight<F extends URIS2>(
F: Foldable2<F>
): <A, B>(b: B, f: (a: A, b: B) => B) => <E>(fa: Kind2<F, E, A>) => B
export declare function reduceRight<F extends URIS2, E>(
F: Foldable2C<F, E>
): <A, B>(b: B, f: (a: A, b: B) => B) => (fa: Kind2<F, E, A>) => B
export declare function reduceRight<F extends URIS>(
F: Foldable1<F>
): <A, B>(b: B, f: (a: A, b: B) => B) => (fa: Kind<F, A>) => B
export declare function reduceRight<F>(F: Foldable<F>): <A, B>(b: B, f: (a: A, b: B) => B) => (fa: HKT<F, A>) => B
/**
* Returns a pipeable `reduceWithIndex`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function reduceWithIndex<F extends URIS4, I>(
F: FoldableWithIndex4<F, I>
): <A, B>(b: B, f: (i: I, b: B, a: A) => B) => <S, R, E>(fa: Kind4<F, S, R, E, A>) => B
export declare function reduceWithIndex<F extends URIS3, I>(
F: FoldableWithIndex3<F, I>
): <A, B>(b: B, f: (i: I, b: B, a: A) => B) => <R, E>(fa: Kind3<F, R, E, A>) => B
export declare function reduceWithIndex<F extends URIS3, I, E>(
F: FoldableWithIndex3C<F, I, E>
): <A, B>(b: B, f: (i: I, b: B, a: A) => B) => <R>(fa: Kind3<F, R, E, A>) => B
export declare function reduceWithIndex<F extends URIS2, I>(
F: FoldableWithIndex2<F, I>
): <A, B>(b: B, f: (i: I, b: B, a: A) => B) => <E>(fa: Kind2<F, E, A>) => B
export declare function reduceWithIndex<F extends URIS2, I, E>(
F: FoldableWithIndex2C<F, I, E>
): <A, B>(b: B, f: (i: I, b: B, a: A) => B) => (fa: Kind2<F, E, A>) => B
export declare function reduceWithIndex<F extends URIS, I>(
F: FoldableWithIndex1<F, I>
): <A, B>(b: B, f: (i: I, b: B, a: A) => B) => (fa: Kind<F, A>) => B
export declare function reduceWithIndex<F, I>(
F: FoldableWithIndex<F, I>
): <A, B>(b: B, f: (i: I, b: B, a: A) => B) => (fa: HKT<F, A>) => B
/**
* Returns a pipeable `foldMapWithIndex`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function foldMapWithIndex<F extends URIS4, I>(
F: FoldableWithIndex4<F, I>
): <M>(M: Monoid<M>) => <A>(f: (i: I, a: A) => M) => <S, R, E>(fa: Kind4<F, S, R, E, A>) => M
export declare function foldMapWithIndex<F extends URIS3, I>(
F: FoldableWithIndex3<F, I>
): <M>(M: Monoid<M>) => <A>(f: (i: I, a: A) => M) => <R, E>(fa: Kind3<F, R, E, A>) => M
export declare function foldMapWithIndex<F extends URIS3, I, E>(
F: FoldableWithIndex3C<F, I, E>
): <M>(M: Monoid<M>) => <A>(f: (i: I, a: A) => M) => <R>(fa: Kind3<F, R, E, A>) => M
export declare function foldMapWithIndex<F extends URIS2, I>(
F: FoldableWithIndex2<F, I>
): <M>(M: Monoid<M>) => <A>(f: (i: I, a: A) => M) => <E>(fa: Kind2<F, E, A>) => M
export declare function foldMapWithIndex<F extends URIS2, I, E>(
F: FoldableWithIndex2C<F, I, E>
): <M>(M: Monoid<M>) => <A>(f: (i: I, a: A) => M) => (fa: Kind2<F, E, A>) => M
export declare function foldMapWithIndex<F extends URIS, I>(
F: FoldableWithIndex1<F, I>
): <M>(M: Monoid<M>) => <A>(f: (i: I, a: A) => M) => (fa: Kind<F, A>) => M
export declare function foldMapWithIndex<F, I>(
F: FoldableWithIndex<F, I>
): <M>(M: Monoid<M>) => <A>(f: (i: I, a: A) => M) => (fa: HKT<F, A>) => M
/**
* Returns a pipeable `reduceRightWithIndex`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function reduceRightWithIndex<F extends URIS4, I>(
F: FoldableWithIndex4<F, I>
): <A, B>(b: B, f: (i: I, a: A, b: B) => B) => <S, R, E>(fa: Kind4<F, S, R, E, A>) => B
export declare function reduceRightWithIndex<F extends URIS3, I>(
F: FoldableWithIndex3<F, I>
): <A, B>(b: B, f: (i: I, a: A, b: B) => B) => <R, E>(fa: Kind3<F, R, E, A>) => B
export declare function reduceRightWithIndex<F extends URIS3, I, E>(
F: FoldableWithIndex3C<F, I, E>
): <A, B>(b: B, f: (i: I, a: A, b: B) => B) => <R>(fa: Kind3<F, R, E, A>) => B
export declare function reduceRightWithIndex<F extends URIS2, I>(
F: FoldableWithIndex2<F, I>
): <A, B>(b: B, f: (i: I, a: A, b: B) => B) => <E>(fa: Kind2<F, E, A>) => B
export declare function reduceRightWithIndex<F extends URIS2, I, E>(
F: FoldableWithIndex2C<F, I, E>
): <A, B>(b: B, f: (i: I, a: A, b: B) => B) => (fa: Kind2<F, E, A>) => B
export declare function reduceRightWithIndex<F extends URIS, I>(
F: FoldableWithIndex1<F, I>
): <A, B>(b: B, f: (i: I, a: A, b: B) => B) => (fa: Kind<F, A>) => B
export declare function reduceRightWithIndex<F, I>(
F: FoldableWithIndex<F, I>
): <A, B>(b: B, f: (i: I, a: A, b: B) => B) => (fa: HKT<F, A>) => B
/**
* Returns a pipeable `alt`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function alt<F extends URIS4>(
F: Alt4<F>
): <S, R, E, A>(that: LazyArg<Kind4<F, S, R, E, A>>) => (fa: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, A>
export declare function alt<F extends URIS3>(
F: Alt3<F>
): <R, E, A>(that: LazyArg<Kind3<F, R, E, A>>) => (fa: Kind3<F, R, E, A>) => Kind3<F, R, E, A>
export declare function alt<F extends URIS3, E>(
F: Alt3C<F, E>
): <R, A>(that: LazyArg<Kind3<F, R, E, A>>) => (fa: Kind3<F, R, E, A>) => Kind3<F, R, E, A>
export declare function alt<F extends URIS2>(
F: Alt2<F>
): <E, A>(that: LazyArg<Kind2<F, E, A>>) => (fa: Kind2<F, E, A>) => Kind2<F, E, A>
export declare function alt<F extends URIS2, E>(
F: Alt2C<F, E>
): <A>(that: LazyArg<Kind2<F, E, A>>) => (fa: Kind2<F, E, A>) => Kind2<F, E, A>
export declare function alt<F extends URIS>(
F: Alt1<F>
): <A>(that: LazyArg<Kind<F, A>>) => (fa: Kind<F, A>) => Kind<F, A>
export declare function alt<F>(F: Alt<F>): <A>(that: LazyArg<HKT<F, A>>) => (fa: HKT<F, A>) => HKT<F, A>
/**
* Returns a pipeable `filter`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function filter<F extends URIS4>(
F: Filterable4<F>
): {
<A, B extends A>(refinement: Refinement<A, B>): <S, R, E>(fa: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, B>
<A>(predicate: Predicate<A>): <S, R, E>(fa: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, A>
}
export declare function filter<F extends URIS3>(
F: Filterable3<F>
): {
<A, B extends A>(refinement: Refinement<A, B>): <R, E>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
<A>(predicate: Predicate<A>): <R, E>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, A>
}
export declare function filter<F extends URIS3, E>(
F: Filterable3C<F, E>
): {
<A, B extends A>(refinement: Refinement<A, B>): <R>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
<A>(predicate: Predicate<A>): <R>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, A>
}
export declare function filter<F extends URIS2>(
F: Filterable2<F>
): {
<A, B extends A>(refinement: Refinement<A, B>): <E>(fa: Kind2<F, E, A>) => Kind2<F, E, B>
<A>(predicate: Predicate<A>): <E>(fa: Kind2<F, E, A>) => Kind2<F, E, A>
}
export declare function filter<F extends URIS2, E>(
F: Filterable2C<F, E>
): {
<A, B extends A>(refinement: Refinement<A, B>): (fa: Kind2<F, E, A>) => Kind2<F, E, B>
<A>(predicate: Predicate<A>): (fa: Kind2<F, E, A>) => Kind2<F, E, A>
}
export declare function filter<F extends URIS>(
F: Filterable1<F>
): {
<A, B extends A>(refinement: Refinement<A, B>): (fa: Kind<F, A>) => Kind<F, B>
<A>(predicate: Predicate<A>): (fa: Kind<F, A>) => Kind<F, A>
}
export declare function filter<F>(F: Filterable<F>): {
<A, B extends A>(refinement: Refinement<A, B>): (fa: HKT<F, A>) => HKT<F, B>
<A>(predicate: Predicate<A>): (fa: HKT<F, A>) => HKT<F, A>
}
/**
* Returns a pipeable `filterMap`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function filterMap<F extends URIS4>(
F: Filterable4<F>
): <A, B>(f: (a: A) => Option<B>) => <S, R, E>(fa: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, B>
export declare function filterMap<F extends URIS3>(
F: Filterable3<F>
): <A, B>(f: (a: A) => Option<B>) => <R, E>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
export declare function filterMap<F extends URIS3, E>(
F: Filterable3C<F, E>
): <A, B>(f: (a: A) => Option<B>) => <R>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
export declare function filterMap<F extends URIS2>(
F: Filterable2<F>
): <A, B>(f: (a: A) => Option<B>) => <E>(fa: Kind2<F, E, A>) => Kind2<F, E, B>
export declare function filterMap<F extends URIS2, E>(
F: Filterable2C<F, E>
): <A, B>(f: (a: A) => Option<B>) => (fa: Kind2<F, E, A>) => Kind2<F, E, B>
export declare function filterMap<F extends URIS>(
F: Filterable1<F>
): <A, B>(f: (a: A) => Option<B>) => (fa: Kind<F, A>) => Kind<F, B>
export declare function filterMap<F>(F: Filterable<F>): <A, B>(f: (a: A) => Option<B>) => (fa: HKT<F, A>) => HKT<F, B>
/**
* Returns a pipeable `partition`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function partition<F extends URIS4>(
F: Filterable4<F>
): {
<A, B extends A>(refinement: Refinement<A, B>): <S, R, E>(
fa: Kind4<F, S, R, E, A>
) => Separated<Kind4<F, S, R, E, A>, Kind4<F, S, R, E, B>>
<A>(predicate: Predicate<A>): <S, R, E>(
fa: Kind4<F, S, R, E, A>
) => Separated<Kind4<F, S, R, E, A>, Kind4<F, S, R, E, A>>
}
export declare function partition<F extends URIS3>(
F: Filterable3<F>
): {
<A, B extends A>(refinement: Refinement<A, B>): <R, E>(
fa: Kind3<F, R, E, A>
) => Separated<Kind3<F, R, E, A>, Kind3<F, R, E, B>>
<A>(predicate: Predicate<A>): <R, E>(fa: Kind3<F, R, E, A>) => Separated<Kind3<F, R, E, A>, Kind3<F, R, E, A>>
}
export declare function partition<F extends URIS3, E>(
F: Filterable3C<F, E>
): {
<A, B extends A>(refinement: Refinement<A, B>): <R>(
fa: Kind3<F, R, E, A>
) => Separated<Kind3<F, R, E, A>, Kind3<F, R, E, B>>
<A>(predicate: Predicate<A>): <R>(fa: Kind3<F, R, E, A>) => Separated<Kind3<F, R, E, A>, Kind3<F, R, E, A>>
}
export declare function partition<F extends URIS2>(
F: Filterable2<F>
): {
<A, B extends A>(refinement: Refinement<A, B>): <E>(fa: Kind2<F, E, A>) => Separated<Kind2<F, E, A>, Kind2<F, E, B>>
<A>(predicate: Predicate<A>): <E>(fa: Kind2<F, E, A>) => Separated<Kind2<F, E, A>, Kind2<F, E, A>>
}
export declare function partition<F extends URIS2, E>(
F: Filterable2C<F, E>
): {
<A, B extends A>(refinement: Refinement<A, B>): (fa: Kind2<F, E, A>) => Separated<Kind2<F, E, A>, Kind2<F, E, B>>
<A>(predicate: Predicate<A>): (fa: Kind2<F, E, A>) => Separated<Kind2<F, E, A>, Kind2<F, E, A>>
}
export declare function partition<F extends URIS>(
F: Filterable1<F>
): {
<A, B extends A>(refinement: Refinement<A, B>): (fa: Kind<F, A>) => Separated<Kind<F, A>, Kind<F, B>>
<A>(predicate: Predicate<A>): (fa: Kind<F, A>) => Separated<Kind<F, A>, Kind<F, A>>
}
export declare function partition<F>(F: Filterable<F>): {
<A, B extends A>(refinement: Refinement<A, B>): (fa: HKT<F, A>) => Separated<HKT<F, A>, HKT<F, B>>
<A>(predicate: Predicate<A>): (fa: HKT<F, A>) => Separated<HKT<F, A>, HKT<F, A>>
}
/**
* Returns a pipeable `partitionMap`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function partitionMap<F extends URIS4>(
F: Filterable4<F>
): <A, B, C>(
f: (a: A) => Either<B, C>
) => <S, R, E>(fa: Kind4<F, S, R, E, A>) => Separated<Kind4<F, S, R, E, B>, Kind4<F, S, R, E, C>>
export declare function partitionMap<F extends URIS3>(
F: Filterable3<F>
): <A, B, C>(
f: (a: A) => Either<B, C>
) => <R, E>(fa: Kind3<F, R, E, A>) => Separated<Kind3<F, R, E, B>, Kind3<F, R, E, C>>
export declare function partitionMap<F extends URIS3, E>(
F: Filterable3C<F, E>
): <A, B, C>(f: (a: A) => Either<B, C>) => <R>(fa: Kind3<F, R, E, A>) => Separated<Kind3<F, R, E, B>, Kind3<F, R, E, C>>
export declare function partitionMap<F extends URIS2>(
F: Filterable2<F>
): <A, B, C>(f: (a: A) => Either<B, C>) => <E>(fa: Kind2<F, E, A>) => Separated<Kind2<F, E, B>, Kind2<F, E, C>>
export declare function partitionMap<F extends URIS2, E>(
F: Filterable2C<F, E>
): <A, B, C>(f: (a: A) => Either<B, C>) => (fa: Kind2<F, E, A>) => Separated<Kind2<F, E, B>, Kind2<F, E, C>>
export declare function partitionMap<F extends URIS>(
F: Filterable1<F>
): <A, B, C>(f: (a: A) => Either<B, C>) => (fa: Kind<F, A>) => Separated<Kind<F, B>, Kind<F, C>>
export declare function partitionMap<F>(
F: Filterable<F>
): <A, B, C>(f: (a: A) => Either<B, C>) => (fa: HKT<F, A>) => Separated<HKT<F, B>, HKT<F, C>>
/**
* Returns a pipeable `filterWithIndex`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function filterWithIndex<F extends URIS4, I>(
F: FilterableWithIndex4<F, I>
): {
<A, B extends A>(refinement: RefinementWithIndex<I, A, B>): <S, R, E>(
fa: Kind4<F, S, R, E, A>
) => Kind4<F, S, R, E, B>
<A>(predicate: PredicateWithIndex<I, A>): <S, R, E>(fa: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, A>
}
export declare function filterWithIndex<F extends URIS3, I>(
F: FilterableWithIndex3<F, I>
): {
<A, B extends A>(refinement: RefinementWithIndex<I, A, B>): <R, E>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
<A>(predicate: PredicateWithIndex<I, A>): <R, E>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, A>
}
export declare function filterWithIndex<F extends URIS3, I, E>(
F: FilterableWithIndex3C<F, I, E>
): {
<A, B extends A>(refinement: RefinementWithIndex<I, A, B>): <R>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
<A>(predicate: PredicateWithIndex<I, A>): <R>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, A>
}
export declare function filterWithIndex<F extends URIS2, I>(
F: FilterableWithIndex2<F, I>
): {
<A, B extends A>(refinement: RefinementWithIndex<I, A, B>): <E>(fa: Kind2<F, E, A>) => Kind2<F, E, B>
<A>(predicate: PredicateWithIndex<I, A>): <E>(fa: Kind2<F, E, A>) => Kind2<F, E, A>
}
export declare function filterWithIndex<F extends URIS2, E, I>(
F: FilterableWithIndex2C<F, I, E>
): {
<A, B extends A>(refinement: RefinementWithIndex<I, A, B>): (fa: Kind2<F, E, A>) => Kind2<F, E, B>
<A>(predicate: PredicateWithIndex<I, A>): (fa: Kind2<F, E, A>) => Kind2<F, E, A>
}
export declare function filterWithIndex<F extends URIS, I>(
F: FilterableWithIndex1<F, I>
): {
<A, B extends A>(refinement: RefinementWithIndex<I, A, B>): (fa: Kind<F, A>) => Kind<F, B>
<A>(predicate: PredicateWithIndex<I, A>): (fa: Kind<F, A>) => Kind<F, A>
}
export declare function filterWithIndex<F, I>(
F: FilterableWithIndex<F, I>
): {
<A, B extends A>(refinement: RefinementWithIndex<I, A, B>): (fa: HKT<F, A>) => HKT<F, B>
<A>(predicate: PredicateWithIndex<I, A>): (fa: HKT<F, A>) => HKT<F, A>
}
/**
* Returns a pipeable `filterMapWithIndex`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function filterMapWithIndex<F extends URIS4, I>(
F: FilterableWithIndex4<F, I>
): <A, B>(f: (i: I, a: A) => Option<B>) => <S, R, E>(fa: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, B>
export declare function filterMapWithIndex<F extends URIS3, I>(
F: FilterableWithIndex3<F, I>
): <A, B>(f: (i: I, a: A) => Option<B>) => <R, E>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
export declare function filterMapWithIndex<F extends URIS3, I, E>(
F: FilterableWithIndex3C<F, I, E>
): <A, B>(f: (i: I, a: A) => Option<B>) => <R>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
export declare function filterMapWithIndex<F extends URIS2, I>(
F: FilterableWithIndex2<F, I>
): <A, B>(f: (i: I, a: A) => Option<B>) => <E>(fa: Kind2<F, E, A>) => Kind2<F, E, B>
export declare function filterMapWithIndex<F extends URIS2, I, E>(
F: FilterableWithIndex2C<F, I, E>
): <A, B>(f: (i: I, a: A) => Option<B>) => (fa: Kind2<F, E, A>) => Kind2<F, E, B>
export declare function filterMapWithIndex<F extends URIS, I>(
F: FilterableWithIndex1<F, I>
): <A, B>(f: (i: I, a: A) => Option<B>) => (fa: Kind<F, A>) => Kind<F, B>
export declare function filterMapWithIndex<F, I>(
F: FilterableWithIndex<F, I>
): <A, B>(f: (i: I, a: A) => Option<B>) => (fa: HKT<F, A>) => HKT<F, B>
/**
* Returns a pipeable `partitionWithIndex`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function partitionWithIndex<F extends URIS4, I>(
F: FilterableWithIndex4<F, I>
): {
<A, B extends A>(refinement: RefinementWithIndex<I, A, B>): <S, R, E>(
fa: Kind4<F, S, R, E, A>
) => Separated<Kind4<F, S, R, E, A>, Kind4<F, S, R, E, B>>
<A>(predicate: PredicateWithIndex<I, A>): <S, R, E>(
fa: Kind4<F, S, R, E, A>
) => Separated<Kind4<F, S, R, E, A>, Kind4<F, S, R, E, A>>
}
export declare function partitionWithIndex<F extends URIS3, I>(
F: FilterableWithIndex3<F, I>
): {
<A, B extends A>(refinement: RefinementWithIndex<I, A, B>): <R, E>(
fa: Kind3<F, R, E, A>
) => Separated<Kind3<F, R, E, A>, Kind3<F, R, E, B>>
<A>(predicate: PredicateWithIndex<I, A>): <R, E>(
fa: Kind3<F, R, E, A>
) => Separated<Kind3<F, R, E, A>, Kind3<F, R, E, A>>
}
export declare function partitionWithIndex<F extends URIS3, I, E>(
F: FilterableWithIndex3C<F, I, E>
): {
<A, B extends A>(refinement: RefinementWithIndex<I, A, B>): <R>(
fa: Kind3<F, R, E, A>
) => Separated<Kind3<F, R, E, A>, Kind3<F, R, E, B>>
<A>(predicate: PredicateWithIndex<I, A>): <R>(
fa: Kind3<F, R, E, A>
) => Separated<Kind3<F, R, E, A>, Kind3<F, R, E, A>>
}
export declare function partitionWithIndex<F extends URIS2, I>(
F: FilterableWithIndex2<F, I>
): {
<A, B extends A>(refinement: RefinementWithIndex<I, A, B>): <E>(
fa: Kind2<F, E, A>
) => Separated<Kind2<F, E, A>, Kind2<F, E, B>>
<A>(predicate: PredicateWithIndex<I, A>): <E>(fa: Kind2<F, E, A>) => Separated<Kind2<F, E, A>, Kind2<F, E, A>>
}
export declare function partitionWithIndex<F extends URIS2, I, E>(
F: FilterableWithIndex2C<F, I, E>
): {
<A, B extends A>(refinement: RefinementWithIndex<I, A, B>): (
fa: Kind2<F, E, A>
) => Separated<Kind2<F, E, A>, Kind2<F, E, B>>
<A>(predicate: PredicateWithIndex<I, A>): (fa: Kind2<F, E, A>) => Separated<Kind2<F, E, A>, Kind2<F, E, A>>
}
export declare function partitionWithIndex<F extends URIS, I>(
F: FilterableWithIndex1<F, I>
): {
<A, B extends A>(refinement: RefinementWithIndex<I, A, B>): (fa: Kind<F, A>) => Separated<Kind<F, A>, Kind<F, B>>
<A>(predicate: PredicateWithIndex<I, A>): (fa: Kind<F, A>) => Separated<Kind<F, A>, Kind<F, A>>
}
export declare function partitionWithIndex<F, I>(
F: FilterableWithIndex<F, I>
): {
<A, B extends A>(refinement: RefinementWithIndex<I, A, B>): (fa: HKT<F, A>) => Separated<HKT<F, A>, HKT<F, B>>
<A>(predicate: PredicateWithIndex<I, A>): (fa: HKT<F, A>) => Separated<HKT<F, A>, HKT<F, A>>
}
/**
* Returns a pipeable `partitionMapWithIndex`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function partitionMapWithIndex<F extends URIS4, I>(
F: FilterableWithIndex4<F, I>
): <A, B, C>(
f: (i: I, a: A) => Either<B, C>
) => <S, R, E>(fa: Kind4<F, S, R, E, A>) => Separated<Kind4<F, S, R, E, B>, Kind4<F, S, R, E, C>>
export declare function partitionMapWithIndex<F extends URIS3, I>(
F: FilterableWithIndex3<F, I>
): <A, B, C>(
f: (i: I, a: A) => Either<B, C>
) => <R, E>(fa: Kind3<F, R, E, A>) => Separated<Kind3<F, R, E, B>, Kind3<F, R, E, C>>
export declare function partitionMapWithIndex<F extends URIS3, I, E>(
F: FilterableWithIndex3C<F, I, E>
): <A, B, C>(
f: (i: I, a: A) => Either<B, C>
) => <R>(fa: Kind3<F, R, E, A>) => Separated<Kind3<F, R, E, B>, Kind3<F, R, E, C>>
export declare function partitionMapWithIndex<F extends URIS2, I>(
F: FilterableWithIndex2<F, I>
): <A, B, C>(f: (i: I, a: A) => Either<B, C>) => <E>(fa: Kind2<F, E, A>) => Separated<Kind2<F, E, B>, Kind2<F, E, C>>
export declare function partitionMapWithIndex<F extends URIS2, I, E>(
F: FilterableWithIndex2C<F, I, E>
): <A, B, C>(f: (i: I, a: A) => Either<B, C>) => (fa: Kind2<F, E, A>) => Separated<Kind2<F, E, B>, Kind2<F, E, C>>
export declare function partitionMapWithIndex<F extends URIS, I>(
F: FilterableWithIndex1<F, I>
): <A, B, C>(f: (i: I, a: A) => Either<B, C>) => (fa: Kind<F, A>) => Separated<Kind<F, B>, Kind<F, C>>
export declare function partitionMapWithIndex<F, I>(
F: FilterableWithIndex<F, I>
): <A, B, C>(f: (i: I, a: A) => Either<B, C>) => (fa: HKT<F, A>) => Separated<HKT<F, B>, HKT<F, C>>
/**
* Returns a pipeable `promap`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function promap<F extends URIS4>(
F: Profunctor4<F>
): <E, A, D, B>(f: (d: D) => E, g: (a: A) => B) => <S, R>(fbc: Kind4<F, S, R, E, A>) => Kind4<F, S, R, D, B>
export declare function promap<F extends URIS3>(
F: Profunctor3<F>
): <E, A, D, B>(f: (d: D) => E, g: (a: A) => B) => <R>(fbc: Kind3<F, R, E, A>) => Kind3<F, R, D, B>
export declare function promap<F extends URIS3, E>(
F: Profunctor3C<F, E>
): <A, D, B>(f: (d: D) => E, g: (a: A) => B) => <R>(fbc: Kind3<F, R, E, A>) => Kind3<F, R, D, B>
export declare function promap<F extends URIS2>(
F: Profunctor2<F>
): <E, A, D, B>(f: (d: D) => E, g: (a: A) => B) => (fbc: Kind2<F, E, A>) => Kind2<F, D, B>
export declare function promap<F extends URIS2, E>(
F: Profunctor2C<F, E>
): <A, D, B>(f: (d: D) => E, g: (a: A) => B) => (fbc: Kind2<F, E, A>) => Kind2<F, D, B>
export declare function promap<F>(
F: Profunctor<F>
): <E, A, D, B>(f: (d: D) => E, g: (a: A) => B) => (fbc: HKT2<F, E, A>) => HKT2<F, D, B>
/**
* Returns a pipeable `compose`
*
* @category pipeable helper
* @since 2.13.0
*/
export declare function compose<F extends URIS4>(
F: Semigroupoid4<F>
): <S, R, E, A>(ea: Kind4<F, S, R, E, A>) => <B>(ab: Kind4<F, S, R, A, B>) => Kind4<F, S, R, E, B>
export declare function compose<F extends URIS3>(
F: Semigroupoid3<F>
): <R, E, A>(ea: Kind3<F, R, E, A>) => <B>(ab: Kind3<F, R, A, B>) => Kind3<F, R, E, B>
export declare function compose<F extends URIS3, E>(
F: Semigroupoid3C<F, E>
): <R, A>(ea: Kind3<F, R, E, A>) => <B>(ab: Kind3<F, R, A, B>) => Kind3<F, R, E, B>
export declare function compose<F extends URIS2>(
F: Semigroupoid2<F>
): <E, A>(ea: Kind2<F, E, A>) => <B>(ab: Kind2<F, A, B>) => Kind2<F, E, B>
export declare function compose<F extends URIS2, E>(
F: Semigroupoid2C<F, E>
): <A>(ea: Kind2<F, E, A>) => <B>(ab: Kind2<F, A, B>) => Kind2<F, E, B>
export declare function compose<F>(
F: Semigroupoid<F>
): <E, A>(ea: HKT2<F, E, A>) => <B>(ab: HKT2<F, A, B>) => HKT2<F, E, B>
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableFunctor<F> {
readonly map: <A, B>(f: (a: A) => B) => (fa: HKT<F, A>) => HKT<F, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableFunctor1<F extends URIS> {
readonly map: <A, B>(f: (a: A) => B) => (fa: Kind<F, A>) => Kind<F, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableFunctor2<F extends URIS2> {
readonly map: <A, B>(f: (a: A) => B) => <E>(fa: Kind2<F, E, A>) => Kind2<F, E, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableFunctor2C<F extends URIS2, E> {
readonly map: <A, B>(f: (a: A) => B) => (fa: Kind2<F, E, A>) => Kind2<F, E, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableFunctor3<F extends URIS3> {
readonly map: <A, B>(f: (a: A) => B) => <R, E>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
}
/**
* @since 2.2.0
* @deprecated
*/
export interface PipeableFunctor3C<F extends URIS3, E> {
readonly map: <A, B>(f: (a: A) => B) => <R>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableFunctor4<F extends URIS4> {
readonly map: <A, B>(f: (a: A) => B) => <S, R, E>(fa: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableContravariant<F> {
readonly contramap: <A, B>(f: (b: B) => A) => (fa: HKT<F, A>) => HKT<F, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableContravariant1<F extends URIS> {
readonly contramap: <A, B>(f: (b: B) => A) => (fa: Kind<F, A>) => Kind<F, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableContravariant2<F extends URIS2> {
readonly contramap: <A, B>(f: (b: B) => A) => <E>(fa: Kind2<F, E, A>) => Kind2<F, E, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableContravariant2C<F extends URIS2, E> {
readonly contramap: <A, B>(f: (b: B) => A) => (fa: Kind2<F, E, A>) => Kind2<F, E, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableContravariant3<F extends URIS3> {
readonly contramap: <A, B>(f: (b: B) => A) => <R, E>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
}
/**
* @since 2.2.0
* @deprecated
*/
export interface PipeableContravariant3C<F extends URIS3, E> {
readonly contramap: <A, B>(f: (b: B) => A) => <R>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableContravariant4<F extends URIS4> {
readonly contramap: <A, B>(f: (b: B) => A) => <S, R, E>(fa: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableFunctorWithIndex<F, I> extends PipeableFunctor<F> {
readonly mapWithIndex: <A, B>(f: (i: I, a: A) => B) => (fa: HKT<F, A>) => HKT<F, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableFunctorWithIndex1<F extends URIS, I> extends PipeableFunctor1<F> {
readonly mapWithIndex: <A, B>(f: (i: I, a: A) => B) => (fa: Kind<F, A>) => Kind<F, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableFunctorWithIndex2<F extends URIS2, I> extends PipeableFunctor2<F> {
readonly mapWithIndex: <A, B>(f: (i: I, a: A) => B) => <E>(fa: Kind2<F, E, A>) => Kind2<F, E, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableFunctorWithIndex2C<F extends URIS2, I, E> extends PipeableFunctor2C<F, E> {
readonly mapWithIndex: <A, B>(f: (i: I, a: A) => B) => (fa: Kind2<F, E, A>) => Kind2<F, E, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableFunctorWithIndex3<F extends URIS3, I> extends PipeableFunctor3<F> {
readonly mapWithIndex: <A, B>(f: (i: I, a: A) => B) => <R, E>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
}
/**
* @since 2.2.0
* @deprecated
*/
export interface PipeableFunctorWithIndex3C<F extends URIS3, I, E> extends PipeableFunctor3C<F, E> {
readonly mapWithIndex: <A, B>(f: (i: I, a: A) => B) => <R>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableFunctorWithIndex4<F extends URIS4, I> extends PipeableFunctor4<F> {
readonly mapWithIndex: <A, B>(f: (i: I, a: A) => B) => <S, R, E>(fa: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableApply<F> extends PipeableFunctor<F> {
readonly ap: <A>(fa: HKT<F, A>) => <B>(fab: HKT<F, (a: A) => B>) => HKT<F, B>
readonly apFirst: <B>(fb: HKT<F, B>) => <A>(fa: HKT<F, A>) => HKT<F, A>
readonly apSecond: <B>(fb: HKT<F, B>) => <A>(fa: HKT<F, A>) => HKT<F, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableApply1<F extends URIS> extends PipeableFunctor1<F> {
readonly ap: <A>(fa: Kind<F, A>) => <B>(fab: Kind<F, (a: A) => B>) => Kind<F, B>
readonly apFirst: <B>(fb: Kind<F, B>) => <A>(fa: Kind<F, A>) => Kind<F, A>
readonly apSecond: <B>(fb: Kind<F, B>) => <A>(fa: Kind<F, A>) => Kind<F, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableApply2<F extends URIS2> extends PipeableFunctor2<F> {
readonly ap: <E, A>(fa: Kind2<F, E, A>) => <B>(fab: Kind2<F, E, (a: A) => B>) => Kind2<F, E, B>
readonly apFirst: <E, B>(fb: Kind2<F, E, B>) => <A>(fa: Kind2<F, E, A>) => Kind2<F, E, A>
readonly apSecond: <E, B>(fb: Kind2<F, E, B>) => <A>(fa: Kind2<F, E, A>) => Kind2<F, E, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableApply2C<F extends URIS2, E> extends PipeableFunctor2C<F, E> {
readonly ap: <A>(fa: Kind2<F, E, A>) => <B>(fab: Kind2<F, E, (a: A) => B>) => Kind2<F, E, B>
readonly apFirst: <B>(fb: Kind2<F, E, B>) => <A>(fa: Kind2<F, E, A>) => Kind2<F, E, A>
readonly apSecond: <B>(fb: Kind2<F, E, B>) => <A>(fa: Kind2<F, E, A>) => Kind2<F, E, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableApply3<F extends URIS3> extends PipeableFunctor3<F> {
readonly ap: <R, E, A>(fa: Kind3<F, R, E, A>) => <B>(fab: Kind3<F, R, E, (a: A) => B>) => Kind3<F, R, E, B>
readonly apFirst: <R, E, B>(fb: Kind3<F, R, E, B>) => <A>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, A>
readonly apSecond: <R, E, B>(fb: Kind3<F, R, E, B>) => <A>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
}
/**
* @since 2.2.0
* @deprecated
*/
export interface PipeableApply3C<F extends URIS3, E> extends PipeableFunctor3C<F, E> {
readonly ap: <R, A>(fa: Kind3<F, R, E, A>) => <B>(fab: Kind3<F, R, E, (a: A) => B>) => Kind3<F, R, E, B>
readonly apFirst: <R, B>(fb: Kind3<F, R, E, B>) => <A>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, A>
readonly apSecond: <R, B>(fb: Kind3<F, R, E, B>) => <A>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableApply4<F extends URIS4> extends PipeableFunctor4<F> {
readonly ap: <S, R, E, A>(
fa: Kind4<F, S, R, E, A>
) => <B>(fab: Kind4<F, S, R, E, (a: A) => B>) => Kind4<F, S, R, E, B>
readonly apFirst: <S, R, E, B>(fb: Kind4<F, S, R, E, B>) => <A>(fa: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, A>
readonly apSecond: <S, R, E, B>(fb: Kind4<F, S, R, E, B>) => <A>(fa: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, B>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableChain<F> extends PipeableApply<F> {
readonly chain: <A, B>(f: (a: A) => HKT<F, B>) => (ma: HKT<F, A>) => HKT<F, B>
readonly chainFirst: <A, B>(f: (a: A) => HKT<F, B>) => (ma: HKT<F, A>) => HKT<F, A>
readonly flatten: <A>(mma: HKT<F, HKT<F, A>>) => HKT<F, A>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableChain1<F extends URIS> extends PipeableApply1<F> {
readonly chain: <A, B>(f: (a: A) => Kind<F, B>) => (ma: Kind<F, A>) => Kind<F, B>
readonly chainFirst: <A, B>(f: (a: A) => Kind<F, B>) => (ma: Kind<F, A>) => Kind<F, A>
readonly flatten: <A>(mma: Kind<F, Kind<F, A>>) => Kind<F, A>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableChain2<F extends URIS2> extends PipeableApply2<F> {
readonly chain: <E, A, B>(f: (a: A) => Kind2<F, E, B>) => (ma: Kind2<F, E, A>) => Kind2<F, E, B>
readonly chainFirst: <E, A, B>(f: (a: A) => Kind2<F, E, B>) => (ma: Kind2<F, E, A>) => Kind2<F, E, A>
readonly flatten: <E, A>(mma: Kind2<F, E, Kind2<F, E, A>>) => Kind2<F, E, A>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableChain2C<F extends URIS2, E> extends PipeableApply2C<F, E> {
readonly chain: <A, B>(f: (a: A) => Kind2<F, E, B>) => (ma: Kind2<F, E, A>) => Kind2<F, E, B>
readonly chainFirst: <A, B>(f: (a: A) => Kind2<F, E, B>) => (ma: Kind2<F, E, A>) => Kind2<F, E, A>
readonly flatten: <A>(mma: Kind2<F, E, Kind2<F, E, A>>) => Kind2<F, E, A>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableChain3<F extends URIS3> extends PipeableApply3<F> {
readonly chain: <R, E, A, B>(f: (a: A) => Kind3<F, R, E, B>) => (ma: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
readonly chainFirst: <R, E, A, B>(f: (a: A) => Kind3<F, R, E, B>) => (ma: Kind3<F, R, E, A>) => Kind3<F, R, E, A>
readonly flatten: <R, E, A>(mma: Kind3<F, R, E, Kind3<F, R, E, A>>) => Kind3<F, R, E, A>
}
/**
* @since 2.2.0
* @deprecated
*/
export interface PipeableChain3C<F extends URIS3, E> extends PipeableApply3C<F, E> {
readonly chain: <R, A, B>(f: (a: A) => Kind3<F, R, E, B>) => (ma: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
readonly chainFirst: <R, A, B>(f: (a: A) => Kind3<F, R, E, B>) => (ma: Kind3<F, R, E, A>) => Kind3<F, R, E, A>
readonly flatten: <R, A>(mma: Kind3<F, R, E, Kind3<F, R, E, A>>) => Kind3<F, R, E, A>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableChain4<F extends URIS4> extends PipeableApply4<F> {
readonly chain: <S, R, E, A, B>(
f: (a: A) => Kind4<F, S, R, E, B>
) => (ma: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, B>
readonly chainFirst: <S, R, E, A, B>(
f: (a: A) => Kind4<F, S, R, E, B>
) => (ma: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, A>
readonly flatten: <S, R, E, A>(mma: Kind4<F, S, R, E, Kind4<F, S, R, E, A>>) => Kind4<F, S, R, E, A>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableExtend<F> extends PipeableFunctor<F> {
readonly extend: <A, B>(f: (wa: HKT<F, A>) => B) => (wa: HKT<F, A>) => HKT<F, B>
readonly duplicate: <A>(wa: HKT<F, A>) => HKT<F, HKT<F, A>>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableExtend1<F extends URIS> extends PipeableFunctor1<F> {
readonly extend: <A, B>(f: (wa: Kind<F, A>) => B) => (wa: Kind<F, A>) => Kind<F, B>
readonly duplicate: <A>(wa: Kind<F, A>) => Kind<F, Kind<F, A>>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableExtend2<F extends URIS2> extends PipeableFunctor2<F> {
readonly extend: <E, A, B>(f: (wa: Kind2<F, E, A>) => B) => (wa: Kind2<F, E, A>) => Kind2<F, E, B>
readonly duplicate: <E, A>(wa: Kind2<F, E, A>) => Kind2<F, E, Kind2<F, E, A>>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableExtend2C<F extends URIS2, E> extends PipeableFunctor2C<F, E> {
readonly extend: <A, B>(f: (wa: Kind2<F, E, A>) => B) => (wa: Kind2<F, E, A>) => Kind2<F, E, B>
readonly duplicate: <A>(wa: Kind2<F, E, A>) => Kind2<F, E, Kind2<F, E, A>>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableExtend3<F extends URIS3> extends PipeableFunctor3<F> {
readonly extend: <R, E, A, B>(f: (wa: Kind3<F, R, E, A>) => B) => (wa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
readonly duplicate: <R, E, A>(wa: Kind3<F, R, E, A>) => Kind3<F, R, E, Kind3<F, R, E, A>>
}
/**
* @since 2.2.0
* @deprecated
*/
export interface PipeableExtend3C<F extends URIS3, E> extends PipeableFunctor3C<F, E> {
readonly extend: <R, A, B>(f: (wa: Kind3<F, R, E, A>) => B) => (wa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
readonly duplicate: <R, A>(wa: Kind3<F, R, E, A>) => Kind3<F, R, E, Kind3<F, R, E, A>>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableExtend4<F extends URIS4> extends PipeableFunctor4<F> {
readonly extend: <S, R, E, A, B>(
f: (wa: Kind4<F, S, R, E, A>) => B
) => (wa: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, B>
readonly duplicate: <S, R, E, A>(wa: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, Kind4<F, S, R, E, A>>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableBifunctor<F> {
readonly bimap: <E, G, A, B>(f: (e: E) => G, g: (a: A) => B) => (fa: HKT2<F, E, A>) => HKT2<F, G, B>
readonly mapLeft: <E, G>(f: (e: E) => G) => <A>(fa: HKT2<F, E, A>) => HKT2<F, G, A>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableBifunctor2<F extends URIS2> {
readonly bimap: <E, G, A, B>(f: (e: E) => G, g: (a: A) => B) => (fa: Kind2<F, E, A>) => Kind2<F, G, B>
readonly mapLeft: <E, G>(f: (e: E) => G) => <A>(fa: Kind2<F, E, A>) => Kind2<F, G, A>
}
/**
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export interface PipeableBifunctor3<F extends URIS3> {
readonly bimap: <E, G, A, B>(f: (e: E) => G, g: (a: A) => B) => <R>(fa: Kind3<F, R, E, A>) => Kind3<F, R, G, B>
readonly mapLeft: <E, G>(f: (e: E) => G) => <R, A>(fa: Kind3<F, R, E, A>) => Kind3<F, R, G, A>
}
/**
* @since 2.2.0
* @deprecated
*/
export interface PipeableBifunctor3C<F extends URIS3, E> {
readonly bimap: <G, A, B>(f: (e: E) => G, g: (a: A) => B)