571 lines
13 KiB
TypeScript
571 lines
13 KiB
TypeScript
|
/**
|
||
|
|
* @since 2.0.0
|
||
|
|
*/
|
||
|
|
import { BooleanAlgebra } from './BooleanAlgebra'
|
||
|
|
import { Monoid } from './Monoid'
|
||
|
|
import { Ring } from './Ring'
|
||
|
|
import { Semigroup } from './Semigroup'
|
||
|
|
import { Semiring } from './Semiring'
|
||
|
|
/**
|
||
|
|
* @category instances
|
||
|
|
* @since 2.10.0
|
||
|
|
*/
|
||
|
|
export declare const getBooleanAlgebra: <B>(B: BooleanAlgebra<B>) => <A = never>() => BooleanAlgebra<(a: A) => B>
|
||
|
|
/**
|
||
|
|
* Unary functions form a semigroup as long as you can provide a semigroup for the codomain.
|
||
|
|
*
|
||
|
|
* @example
|
||
|
|
* import { Predicate, getSemigroup } from 'fp-ts/function'
|
||
|
|
* import * as B from 'fp-ts/boolean'
|
||
|
|
*
|
||
|
|
* const f: Predicate<number> = (n) => n <= 2
|
||
|
|
* const g: Predicate<number> = (n) => n >= 0
|
||
|
|
*
|
||
|
|
* const S1 = getSemigroup(B.SemigroupAll)<number>()
|
||
|
|
*
|
||
|
|
* assert.deepStrictEqual(S1.concat(f, g)(1), true)
|
||
|
|
* assert.deepStrictEqual(S1.concat(f, g)(3), false)
|
||
|
|
*
|
||
|
|
* const S2 = getSemigroup(B.SemigroupAny)<number>()
|
||
|
|
*
|
||
|
|
* assert.deepStrictEqual(S2.concat(f, g)(1), true)
|
||
|
|
* assert.deepStrictEqual(S2.concat(f, g)(3), true)
|
||
|
|
*
|
||
|
|
* @category instances
|
||
|
|
* @since 2.10.0
|
||
|
|
*/
|
||
|
|
export declare const getSemigroup: <S>(S: Semigroup<S>) => <A = never>() => Semigroup<(a: A) => S>
|
||
|
|
/**
|
||
|
|
* Unary functions form a monoid as long as you can provide a monoid for the codomain.
|
||
|
|
*
|
||
|
|
* @example
|
||
|
|
* import { Predicate } from 'fp-ts/Predicate'
|
||
|
|
* import { getMonoid } from 'fp-ts/function'
|
||
|
|
* import * as B from 'fp-ts/boolean'
|
||
|
|
*
|
||
|
|
* const f: Predicate<number> = (n) => n <= 2
|
||
|
|
* const g: Predicate<number> = (n) => n >= 0
|
||
|
|
*
|
||
|
|
* const M1 = getMonoid(B.MonoidAll)<number>()
|
||
|
|
*
|
||
|
|
* assert.deepStrictEqual(M1.concat(f, g)(1), true)
|
||
|
|
* assert.deepStrictEqual(M1.concat(f, g)(3), false)
|
||
|
|
*
|
||
|
|
* const M2 = getMonoid(B.MonoidAny)<number>()
|
||
|
|
*
|
||
|
|
* assert.deepStrictEqual(M2.concat(f, g)(1), true)
|
||
|
|
* assert.deepStrictEqual(M2.concat(f, g)(3), true)
|
||
|
|
*
|
||
|
|
* @category instances
|
||
|
|
* @since 2.10.0
|
||
|
|
*/
|
||
|
|
export declare const getMonoid: <M>(M: Monoid<M>) => <A = never>() => Monoid<(a: A) => M>
|
||
|
|
/**
|
||
|
|
* @category instances
|
||
|
|
* @since 2.10.0
|
||
|
|
*/
|
||
|
|
export declare const getSemiring: <A, B>(S: Semiring<B>) => Semiring<(a: A) => B>
|
||
|
|
/**
|
||
|
|
* @category instances
|
||
|
|
* @since 2.10.0
|
||
|
|
*/
|
||
|
|
export declare const getRing: <A, B>(R: Ring<B>) => Ring<(a: A) => B>
|
||
|
|
/**
|
||
|
|
* @since 2.11.0
|
||
|
|
*/
|
||
|
|
export declare const apply: <A>(a: A) => <B>(f: (a: A) => B) => B
|
||
|
|
/**
|
||
|
|
* A *thunk*
|
||
|
|
*
|
||
|
|
* @since 2.0.0
|
||
|
|
*/
|
||
|
|
export interface Lazy<A> {
|
||
|
|
(): A
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @example
|
||
|
|
* import { FunctionN } from 'fp-ts/function'
|
||
|
|
*
|
||
|
|
* export const sum: FunctionN<[number, number], number> = (a, b) => a + b
|
||
|
|
*
|
||
|
|
* @since 2.0.0
|
||
|
|
*/
|
||
|
|
export interface FunctionN<A extends ReadonlyArray<unknown>, B> {
|
||
|
|
(...args: A): B
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @since 2.0.0
|
||
|
|
*/
|
||
|
|
export declare function identity<A>(a: A): A
|
||
|
|
/**
|
||
|
|
* @since 2.0.0
|
||
|
|
*/
|
||
|
|
export declare const unsafeCoerce: <A, B>(a: A) => B
|
||
|
|
/**
|
||
|
|
* @since 2.0.0
|
||
|
|
*/
|
||
|
|
export declare function constant<A>(a: A): Lazy<A>
|
||
|
|
/**
|
||
|
|
* A thunk that returns always `true`.
|
||
|
|
*
|
||
|
|
* @since 2.0.0
|
||
|
|
*/
|
||
|
|
export declare const constTrue: Lazy<boolean>
|
||
|
|
/**
|
||
|
|
* A thunk that returns always `false`.
|
||
|
|
*
|
||
|
|
* @since 2.0.0
|
||
|
|
*/
|
||
|
|
export declare const constFalse: Lazy<boolean>
|
||
|
|
/**
|
||
|
|
* A thunk that returns always `null`.
|
||
|
|
*
|
||
|
|
* @since 2.0.0
|
||
|
|
*/
|
||
|
|
export declare const constNull: Lazy<null>
|
||
|
|
/**
|
||
|
|
* A thunk that returns always `undefined`.
|
||
|
|
*
|
||
|
|
* @since 2.0.0
|
||
|
|
*/
|
||
|
|
export declare const constUndefined: Lazy<undefined>
|
||
|
|
/**
|
||
|
|
* A thunk that returns always `void`.
|
||
|
|
*
|
||
|
|
* @since 2.0.0
|
||
|
|
*/
|
||
|
|
export declare const constVoid: Lazy<void>
|
||
|
|
/**
|
||
|
|
* Flips the arguments of a curried function.
|
||
|
|
*
|
||
|
|
* @example
|
||
|
|
* import { flip } from 'fp-ts/function'
|
||
|
|
*
|
||
|
|
* const f = (a: number) => (b: string) => a - b.length
|
||
|
|
*
|
||
|
|
* assert.strictEqual(flip(f)('aaa')(2), -1)
|
||
|
|
*
|
||
|
|
* @since 2.0.0
|
||
|
|
*/
|
||
|
|
export declare function flip<A, B, C>(f: (a: A) => (b: B) => C): (b: B) => (a: A) => C
|
||
|
|
/** @deprecated */
|
||
|
|
export declare function flip<A, B, C>(f: (a: A, b: B) => C): (b: B, a: A) => C
|
||
|
|
/**
|
||
|
|
* Performs left-to-right function composition. The first argument may have any arity, the remaining arguments must be unary.
|
||
|
|
*
|
||
|
|
* See also [`pipe`](#pipe).
|
||
|
|
*
|
||
|
|
* @example
|
||
|
|
* import { flow } from 'fp-ts/function'
|
||
|
|
*
|
||
|
|
* const len = (s: string): number => s.length
|
||
|
|
* const double = (n: number): number => n * 2
|
||
|
|
*
|
||
|
|
* const f = flow(len, double)
|
||
|
|
*
|
||
|
|
* assert.strictEqual(f('aaa'), 6)
|
||
|
|
*
|
||
|
|
* @since 2.0.0
|
||
|
|
*/
|
||
|
|
export declare function flow<A extends ReadonlyArray<unknown>, B>(ab: (...a: A) => B): (...a: A) => B
|
||
|
|
export declare function flow<A extends ReadonlyArray<unknown>, B, C>(
|
||
|
|
ab: (...a: A) => B,
|
||
|
|
bc: (b: B) => C
|
||
|
|
): (...a: A) => C
|
||
|
|
export declare function flow<A extends ReadonlyArray<unknown>, B, C, D>(
|
||
|
|
ab: (...a: A) => B,
|
||
|
|
bc: (b: B) => C,
|
||
|
|
cd: (c: C) => D
|
||
|
|
): (...a: A) => D
|
||
|
|
export declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E>(
|
||
|
|
ab: (...a: A) => B,
|
||
|
|
bc: (b: B) => C,
|
||
|
|
cd: (c: C) => D,
|
||
|
|
de: (d: D) => E
|
||
|
|
): (...a: A) => E
|
||
|
|
export declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F>(
|
||
|
|
ab: (...a: A) => B,
|
||
|
|
bc: (b: B) => C,
|
||
|
|
cd: (c: C) => D,
|
||
|
|
de: (d: D) => E,
|
||
|
|
ef: (e: E) => F
|
||
|
|
): (...a: A) => F
|
||
|
|
export declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F, G>(
|
||
|
|
ab: (...a: A) => B,
|
||
|
|
bc: (b: B) => C,
|
||
|
|
cd: (c: C) => D,
|
||
|
|
de: (d: D) => E,
|
||
|
|
ef: (e: E) => F,
|
||
|
|
fg: (f: F) => G
|
||
|
|
): (...a: A) => G
|
||
|
|
export declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F, G, H>(
|
||
|
|
ab: (...a: A) => B,
|
||
|
|
bc: (b: B) => C,
|
||
|
|
cd: (c: C) => D,
|
||
|
|
de: (d: D) => E,
|
||
|
|
ef: (e: E) => F,
|
||
|
|
fg: (f: F) => G,
|
||
|
|
gh: (g: G) => H
|
||
|
|
): (...a: A) => H
|
||
|
|
export declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F, G, H, I>(
|
||
|
|
ab: (...a: A) => B,
|
||
|
|
bc: (b: B) => C,
|
||
|
|
cd: (c: C) => D,
|
||
|
|
de: (d: D) => E,
|
||
|
|
ef: (e: E) => F,
|
||
|
|
fg: (f: F) => G,
|
||
|
|
gh: (g: G) => H,
|
||
|
|
hi: (h: H) => I
|
||
|
|
): (...a: A) => I
|
||
|
|
export declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F, G, H, I, J>(
|
||
|
|
ab: (...a: A) => B,
|
||
|
|
bc: (b: B) => C,
|
||
|
|
cd: (c: C) => D,
|
||
|
|
de: (d: D) => E,
|
||
|
|
ef: (e: E) => F,
|
||
|
|
fg: (f: F) => G,
|
||
|
|
gh: (g: G) => H,
|
||
|
|
hi: (h: H) => I,
|
||
|
|
ij: (i: I) => J
|
||
|
|
): (...a: A) => J
|
||
|
|
/**
|
||
|
|
* @since 2.0.0
|
||
|
|
*/
|
||
|
|
export declare function tuple<T extends ReadonlyArray<any>>(...t: T): T
|
||
|
|
/**
|
||
|
|
* @since 2.0.0
|
||
|
|
*/
|
||
|
|
export declare function increment(n: number): number
|
||
|
|
/**
|
||
|
|
* @since 2.0.0
|
||
|
|
*/
|
||
|
|
export declare function decrement(n: number): number
|
||
|
|
/**
|
||
|
|
* @since 2.0.0
|
||
|
|
*/
|
||
|
|
export declare function absurd<A>(_: never): A
|
||
|
|
/**
|
||
|
|
* Creates a tupled version of this function: instead of `n` arguments, it accepts a single tuple argument.
|
||
|
|
*
|
||
|
|
* @example
|
||
|
|
* import { tupled } from 'fp-ts/function'
|
||
|
|
*
|
||
|
|
* const add = tupled((x: number, y: number): number => x + y)
|
||
|
|
*
|
||
|
|
* assert.strictEqual(add([1, 2]), 3)
|
||
|
|
*
|
||
|
|
* @since 2.4.0
|
||
|
|
*/
|
||
|
|
export declare function tupled<A extends ReadonlyArray<unknown>, B>(f: (...a: A) => B): (a: A) => B
|
||
|
|
/**
|
||
|
|
* Inverse function of `tupled`
|
||
|
|
*
|
||
|
|
* @since 2.4.0
|
||
|
|
*/
|
||
|
|
export declare function untupled<A extends ReadonlyArray<unknown>, B>(f: (a: A) => B): (...a: A) => B
|
||
|
|
/**
|
||
|
|
* Pipes the value of an expression into a pipeline of functions.
|
||
|
|
*
|
||
|
|
* See also [`flow`](#flow).
|
||
|
|
*
|
||
|
|
* @example
|
||
|
|
* import { pipe } from 'fp-ts/function'
|
||
|
|
*
|
||
|
|
* const len = (s: string): number => s.length
|
||
|
|
* const double = (n: number): number => n * 2
|
||
|
|
*
|
||
|
|
* // without pipe
|
||
|
|
* assert.strictEqual(double(len('aaa')), 6)
|
||
|
|
*
|
||
|
|
* // with pipe
|
||
|
|
* assert.strictEqual(pipe('aaa', len, double), 6)
|
||
|
|
*
|
||
|
|
* @since 2.6.3
|
||
|
|
*/
|
||
|
|
export declare function pipe<A>(a: A): A
|
||
|
|
export declare function pipe<A, B>(a: A, ab: (a: A) => B): B
|
||
|
|
export declare function pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C
|
||
|
|
export declare function pipe<A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D
|
||
|
|
export declare function pipe<A, B, C, D, E>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E
|
||
|
|
export declare function pipe<A, B, C, D, E, F>(
|
||
|
|
a: A,
|
||
|
|
ab: (a: A) => B,
|
||
|
|
bc: (b: B) => C,
|
||
|
|
cd: (c: C) => D,
|
||
|
|
de: (d: D) => E,
|
||
|
|
ef: (e: E) => F
|
||
|
|
): F
|
||
|
|
export declare function pipe<A, B, C, D, E, F, G>(
|
||
|
|
a: A,
|
||
|
|
ab: (a: A) => B,
|
||
|
|
bc: (b: B) => C,
|
||
|
|
cd: (c: C) => D,
|
||
|
|
de: (d: D) => E,
|
||
|
|
ef: (e: E) => F,
|
||
|
|
fg: (f: F) => G
|
||
|
|
): G
|
||
|
|
export declare function pipe<A, B, C, D, E, F, G, H>(
|
||
|
|
a: A,
|
||
|
|
ab: (a: A) => B,
|
||
|
|
bc: (b: B) => C,
|
||
|
|
cd: (c: C) => D,
|
||
|
|
de: (d: D) => E,
|
||
|
|
ef: (e: E) => F,
|
||
|
|
fg: (f: F) => G,
|
||
|
|
gh: (g: G) => H
|
||
|
|
): H
|
||
|
|
export declare function pipe<A, B, C, D, E, F, G, H, I>(
|
||
|
|
a: A,
|
||
|
|
ab: (a: A) => B,
|
||
|
|
bc: (b: B) => C,
|
||
|
|
cd: (c: C) => D,
|
||
|
|
de: (d: D) => E,
|
||
|
|
ef: (e: E) => F,
|
||
|
|
fg: (f: F) => G,
|
||
|
|
gh: (g: G) => H,
|
||
|
|
hi: (h: H) => I
|
||
|
|
): I
|
||
|
|
export declare function pipe<A, B, C, D, E, F, G, H, I, J>(
|
||
|
|
a: A,
|
||
|
|
ab: (a: A) => B,
|
||
|
|
bc: (b: B) => C,
|
||
|
|
cd: (c: C) => D,
|
||
|
|
de: (d: D) => E,
|
||
|
|
ef: (e: E) => F,
|
||
|
|
fg: (f: F) => G,
|
||
|
|
gh: (g: G) => H,
|
||
|
|
hi: (h: H) => I,
|
||
|
|
ij: (i: I) => J
|
||
|
|
): J
|
||
|
|
export declare function pipe<A, B, C, D, E, F, G, H, I, J, K>(
|
||
|
|
a: A,
|
||
|
|
ab: (a: A) => B,
|
||
|
|
bc: (b: B) => C,
|
||
|
|
cd: (c: C) => D,
|
||
|
|
de: (d: D) => E,
|
||
|
|
ef: (e: E) => F,
|
||
|
|
fg: (f: F) => G,
|
||
|
|
gh: (g: G) => H,
|
||
|
|
hi: (h: H) => I,
|
||
|
|
ij: (i: I) => J,
|
||
|
|
jk: (j: J) => K
|
||
|
|
): K
|
||
|
|
export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(
|
||
|
|
a: A,
|
||
|
|
ab: (a: A) => B,
|
||
|
|
bc: (b: B) => C,
|
||
|
|
cd: (c: C) => D,
|
||
|
|
de: (d: D) => E,
|
||
|
|
ef: (e: E) => F,
|
||
|
|
fg: (f: F) => G,
|
||
|
|
gh: (g: G) => H,
|
||
|
|
hi: (h: H) => I,
|
||
|
|
ij: (i: I) => J,
|
||
|
|
jk: (j: J) => K,
|
||
|
|
kl: (k: K) => L
|
||
|
|
): L
|
||
|
|
export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(
|
||
|
|
a: A,
|
||
|
|
ab: (a: A) => B,
|
||
|
|
bc: (b: B) => C,
|
||
|
|
cd: (c: C) => D,
|
||
|
|
de: (d: D) => E,
|
||
|
|
ef: (e: E) => F,
|
||
|
|
fg: (f: F) => G,
|
||
|
|
gh: (g: G) => H,
|
||
|
|
hi: (h: H) => I,
|
||
|
|
ij: (i: I) => J,
|
||
|
|
jk: (j: J) => K,
|
||
|
|
kl: (k: K) => L,
|
||
|
|
lm: (l: L) => M
|
||
|
|
): M
|
||
|
|
export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(
|
||
|
|
a: A,
|
||
|
|
ab: (a: A) => B,
|
||
|
|
bc: (b: B) => C,
|
||
|
|
cd: (c: C) => D,
|
||
|
|
de: (d: D) => E,
|
||
|
|
ef: (e: E) => F,
|
||
|
|
fg: (f: F) => G,
|
||
|
|
gh: (g: G) => H,
|
||
|
|
hi: (h: H) => I,
|
||
|
|
ij: (i: I) => J,
|
||
|
|
jk: (j: J) => K,
|
||
|
|
kl: (k: K) => L,
|
||
|
|
lm: (l: L) => M,
|
||
|
|
mn: (m: M) => N
|
||
|
|
): N
|
||
|
|
export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(
|
||
|
|
a: A,
|
||
|
|
ab: (a: A) => B,
|
||
|
|
bc: (b: B) => C,
|
||
|
|
cd: (c: C) => D,
|
||
|
|
de: (d: D) => E,
|
||
|
|
ef: (e: E) => F,
|
||
|
|
fg: (f: F) => G,
|
||
|
|
gh: (g: G) => H,
|
||
|
|
hi: (h: H) => I,
|
||
|
|
ij: (i: I) => J,
|
||
|
|
jk: (j: J) => K,
|
||
|
|
kl: (k: K) => L,
|
||
|
|
lm: (l: L) => M,
|
||
|
|
mn: (m: M) => N,
|
||
|
|
no: (n: N) => O
|
||
|
|
): O
|
||
|
|
export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(
|
||
|
|
a: A,
|
||
|
|
ab: (a: A) => B,
|
||
|
|
bc: (b: B) => C,
|
||
|
|
cd: (c: C) => D,
|
||
|
|
de: (d: D) => E,
|
||
|
|
ef: (e: E) => F,
|
||
|
|
fg: (f: F) => G,
|
||
|
|
gh: (g: G) => H,
|
||
|
|
hi: (h: H) => I,
|
||
|
|
ij: (i: I) => J,
|
||
|
|
jk: (j: J) => K,
|
||
|
|
kl: (k: K) => L,
|
||
|
|
lm: (l: L) => M,
|
||
|
|
mn: (m: M) => N,
|
||
|
|
no: (n: N) => O,
|
||
|
|
op: (o: O) => P
|
||
|
|
): P
|
||
|
|
export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(
|
||
|
|
a: A,
|
||
|
|
ab: (a: A) => B,
|
||
|
|
bc: (b: B) => C,
|
||
|
|
cd: (c: C) => D,
|
||
|
|
de: (d: D) => E,
|
||
|
|
ef: (e: E) => F,
|
||
|
|
fg: (f: F) => G,
|
||
|
|
gh: (g: G) => H,
|
||
|
|
hi: (h: H) => I,
|
||
|
|
ij: (i: I) => J,
|
||
|
|
jk: (j: J) => K,
|
||
|
|
kl: (k: K) => L,
|
||
|
|
lm: (l: L) => M,
|
||
|
|
mn: (m: M) => N,
|
||
|
|
no: (n: N) => O,
|
||
|
|
op: (o: O) => P,
|
||
|
|
pq: (p: P) => Q
|
||
|
|
): Q
|
||
|
|
export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(
|
||
|
|
a: A,
|
||
|
|
ab: (a: A) => B,
|
||
|
|
bc: (b: B) => C,
|
||
|
|
cd: (c: C) => D,
|
||
|
|
de: (d: D) => E,
|
||
|
|
ef: (e: E) => F,
|
||
|
|
fg: (f: F) => G,
|
||
|
|
gh: (g: G) => H,
|
||
|
|
hi: (h: H) => I,
|
||
|
|
ij: (i: I) => J,
|
||
|
|
jk: (j: J) => K,
|
||
|
|
kl: (k: K) => L,
|
||
|
|
lm: (l: L) => M,
|
||
|
|
mn: (m: M) => N,
|
||
|
|
no: (n: N) => O,
|
||
|
|
op: (o: O) => P,
|
||
|
|
pq: (p: P) => Q,
|
||
|
|
qr: (q: Q) => R
|
||
|
|
): R
|
||
|
|
export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(
|
||
|
|
a: A,
|
||
|
|
ab: (a: A) => B,
|
||
|
|
bc: (b: B) => C,
|
||
|
|
cd: (c: C) => D,
|
||
|
|
de: (d: D) => E,
|
||
|
|
ef: (e: E) => F,
|
||
|
|
fg: (f: F) => G,
|
||
|
|
gh: (g: G) => H,
|
||
|
|
hi: (h: H) => I,
|
||
|
|
ij: (i: I) => J,
|
||
|
|
jk: (j: J) => K,
|
||
|
|
kl: (k: K) => L,
|
||
|
|
lm: (l: L) => M,
|
||
|
|
mn: (m: M) => N,
|
||
|
|
no: (n: N) => O,
|
||
|
|
op: (o: O) => P,
|
||
|
|
pq: (p: P) => Q,
|
||
|
|
qr: (q: Q) => R,
|
||
|
|
rs: (r: R) => S
|
||
|
|
): S
|
||
|
|
export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(
|
||
|
|
a: A,
|
||
|
|
ab: (a: A) => B,
|
||
|
|
bc: (b: B) => C,
|
||
|
|
cd: (c: C) => D,
|
||
|
|
de: (d: D) => E,
|
||
|
|
ef: (e: E) => F,
|
||
|
|
fg: (f: F) => G,
|
||
|
|
gh: (g: G) => H,
|
||
|
|
hi: (h: H) => I,
|
||
|
|
ij: (i: I) => J,
|
||
|
|
jk: (j: J) => K,
|
||
|
|
kl: (k: K) => L,
|
||
|
|
lm: (l: L) => M,
|
||
|
|
mn: (m: M) => N,
|
||
|
|
no: (n: N) => O,
|
||
|
|
op: (o: O) => P,
|
||
|
|
pq: (p: P) => Q,
|
||
|
|
qr: (q: Q) => R,
|
||
|
|
rs: (r: R) => S,
|
||
|
|
st: (s: S) => T
|
||
|
|
): T
|
||
|
|
/**
|
||
|
|
* Type hole simulation
|
||
|
|
*
|
||
|
|
* @since 2.7.0
|
||
|
|
*/
|
||
|
|
export declare const hole: <T>() => T
|
||
|
|
/**
|
||
|
|
* @since 2.11.0
|
||
|
|
*/
|
||
|
|
export declare const SK: <A, B>(_: A, b: B) => B
|
||
|
|
/**
|
||
|
|
* Use `Refinement` module instead.
|
||
|
|
*
|
||
|
|
* @category zone of death
|
||
|
|
* @since 2.0.0
|
||
|
|
* @deprecated
|
||
|
|
*/
|
||
|
|
export interface Refinement<A, B extends A> {
|
||
|
|
(a: A): a is B
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Use `Predicate` module instead.
|
||
|
|
*
|
||
|
|
* @category zone of death
|
||
|
|
* @since 2.0.0
|
||
|
|
* @deprecated
|
||
|
|
*/
|
||
|
|
export interface Predicate<A> {
|
||
|
|
(a: A): boolean
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Use `Predicate` module instead.
|
||
|
|
*
|
||
|
|
* @category zone of death
|
||
|
|
* @since 2.0.0
|
||
|
|
* @deprecated
|
||
|
|
*/
|
||
|
|
export declare function not<A>(predicate: Predicate<A>): Predicate<A>
|
||
|
|
/**
|
||
|
|
* Use `Endomorphism` module instead.
|
||
|
|
*
|
||
|
|
* @category zone of death
|
||
|
|
* @since 2.0.0
|
||
|
|
* @deprecated
|
||
|
|
*/
|
||
|
|
export interface Endomorphism<A> {
|
||
|
|
(a: A): A
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Use `Endomorphism` module instead.
|
||
|
|
*
|
||
|
|
* @category zone of death
|
||
|
|
* @since 2.10.0
|
||
|
|
* @deprecated
|
||
|
|
*/
|
||
|
|
export declare const getEndomorphismMonoid: <A = never>() => Monoid<Endomorphism<A>>
|