/** * @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>>