# fp-ts

← Back

Source

## unsafeCoerce

``````const unsafeCoerce: <A, B>(a: A) => B
``````

## and

``````<A>(p1: Predicate<A>, p2: Predicate<A>): Predicate<A>
``````

## apply

``````<A, B>(f: (a: A) => B) => (a: A): B
``````

Applies a function to an argument (\$)

## applyFlipped

``````<A>(a: A) => <B>(f: (a: A) => B): B
``````

Applies an argument to a function (#)

## compose

``````compose(...fns: Array<Function>): Function
``````

## concat

``````<A>(x: Array<A>, y: Array<A>): Array<A>
``````

## constFalse

``````(): boolean
``````

A thunk that returns always `false`

## constIdentity

``````(): (<A>(a: A) => A)
``````

A thunk that returns always the `identity` function. For use with `applySecond` methods.

## constNull

``````(): null
``````

A thunk that returns always `null`

## constTrue

``````(): boolean
``````

A thunk that returns always `true`

## constUndefined

``````(): undefined
``````

A thunk that returns always `undefined`

## constant

``````<A>(a: A): Lazy<A>
``````

## curry

``````curry(f: Function)
``````

## decrement

``````(n: number): number
``````

## flip

``````<A, B, C>(f: Curried2<A, B, C>): Curried2<B, A, C>
``````

Flips the order of the arguments to a function of two arguments.

## identity

``````<A>(a: A): A
``````

## increment

``````(n: number): number
``````

## not

``````<A>(predicate: Predicate<A>): Predicate<A>
``````

## on

``````<B, C>(op: BinaryOperation<B, C>) => <A>(f: (a: A) => B): BinaryOperation<A, C>
``````

The `on` function is used to change the domain of a binary operator.

## or

``````or<A>(p1: Predicate<A>, p2: Predicate<A>): Predicate<A>
``````

## pipe

``````pipe(...fns: Array<Function>): Function
``````

## toString

``````(x: any): string
``````

## tuple

``````<A, B>(a: A, b: B): [A, B]
``````

``````<A>(a: A) => <B>(b: B): [A, B]