# Ord overview

The `Ord` type class represents types which support comparisons with a total order.

Instances should satisfy the laws of total orderings:

1. Reflexivity: `S.compare(a, a) <= 0`
2. Antisymmetry: if `S.compare(a, b) <= 0` and `S.compare(b, a) <= 0` then `a <-> b`
3. Transitivity: if `S.compare(a, b) <= 0` and `S.compare(b, c) <= 0` then `S.compare(a, c) <= 0`

# Ord (interface)

Signature

``````export interface Ord<A> extends Eq<A> {
readonly compare: (x: A, y: A) => Ordering
}
``````

# URI (type alias)

Signature

``````export type URI = typeof URI
``````

# URI

Signature

``````export const URI: "Ord" = ...
``````

# between

Test whether a value is between a minimum and a maximum (inclusive)

Signature

``````export function between<A>(O: Ord<A>): (low: A, hi: A) => (x: A) => boolean { ... }
``````

# clamp

Clamp a value between a minimum and a maximum

Signature

``````export function clamp<A>(O: Ord<A>): (low: A, hi: A) => (x: A) => A { ... }
``````

# contramap

Signature

``````<A, B>(f: (b: B) => A) => (fa: Ord<A>) => Ord<B>
``````

# fromCompare

Signature

``````export function fromCompare<A>(compare: (x: A, y: A) => Ordering): Ord<A> { ... }
``````

# geq

Test whether one value is non-strictly greater than another

Signature

``````export function geq<A>(O: Ord<A>): (x: A, y: A) => boolean { ... }
``````

# getDualOrd

Signature

``````export function getDualOrd<A>(O: Ord<A>): Ord<A> { ... }
``````

# getMonoid

Returns a `Monoid` such that:

• its `concat(ord1, ord2)` operation will order first by `ord1`, and then by `ord2`
• its `empty` value is an `Ord` that always considers compared elements equal

Signature

``````export function getMonoid<A = never>(): Monoid<Ord<A>> { ... }
``````

Example

``````import { sort } from 'fp-ts/lib/Array'
import { contramap, getDualOrd, getMonoid, ordBoolean, ordNumber, ordString } from 'fp-ts/lib/Ord'
import { pipe } from 'fp-ts/lib/pipeable'
import { fold } from 'fp-ts/lib/Monoid'

interface User {
id: number
name: string
age: number
rememberMe: boolean
}

const byName = pipe(
ordString,
contramap((p: User) => p.name)
)

const byAge = pipe(
ordNumber,
contramap((p: User) => p.age)
)

const byRememberMe = pipe(
ordBoolean,
contramap((p: User) => p.rememberMe)
)

const M = getMonoid<User>()

const users: Array<User> = [
{ id: 1, name: 'Guido', age: 47, rememberMe: false },
{ id: 2, name: 'Guido', age: 46, rememberMe: true },
{ id: 3, name: 'Giulio', age: 44, rememberMe: false },
{ id: 4, name: 'Giulio', age: 44, rememberMe: true }
]

// sort by name, then by age, then by `rememberMe`
const O1 = fold(M)([byName, byAge, byRememberMe])
assert.deepStrictEqual(sort(O1)(users), [
{ id: 3, name: 'Giulio', age: 44, rememberMe: false },
{ id: 4, name: 'Giulio', age: 44, rememberMe: true },
{ id: 2, name: 'Guido', age: 46, rememberMe: true },
{ id: 1, name: 'Guido', age: 47, rememberMe: false }
])

// now `rememberMe = true` first, then by name, then by age
const O2 = fold(M)([getDualOrd(byRememberMe), byName, byAge])
assert.deepStrictEqual(sort(O2)(users), [
{ id: 4, name: 'Giulio', age: 44, rememberMe: true },
{ id: 2, name: 'Guido', age: 46, rememberMe: true },
{ id: 3, name: 'Giulio', age: 44, rememberMe: false },
{ id: 1, name: 'Guido', age: 47, rememberMe: false }
])
``````

# getTupleOrd

Given a tuple of `Ord`s returns an `Ord` for the tuple

Signature

``````export function getTupleOrd<T extends ReadonlyArray<Ord<any>>>(
...ords: T
): Ord<{ [K in keyof T]: T[K] extends Ord<infer A> ? A : never }> { ... }
``````

Example

``````import { getTupleOrd, ordString, ordNumber, ordBoolean } from 'fp-ts/lib/Ord'

const O = getTupleOrd(ordString, ordNumber, ordBoolean)
assert.strictEqual(O.compare(['a', 1, true], ['b', 2, true]), -1)
assert.strictEqual(O.compare(['a', 1, true], ['a', 2, true]), -1)
assert.strictEqual(O.compare(['a', 1, true], ['a', 1, false]), 1)
``````

# gt

Test whether one value is strictly greater than another

Signature

``````export function gt<A>(O: Ord<A>): (x: A, y: A) => boolean { ... }
``````

# leq

Test whether one value is non-strictly less than another

Signature

``````export function leq<A>(O: Ord<A>): (x: A, y: A) => boolean { ... }
``````

# lt

Test whether one value is strictly less than another

Signature

``````export function lt<A>(O: Ord<A>): (x: A, y: A) => boolean { ... }
``````

# max

Take the maximum of two values. If they are considered equal, the first argument is chosen

Signature

``````export function max<A>(O: Ord<A>): (x: A, y: A) => A { ... }
``````

# min

Take the minimum of two values. If they are considered equal, the first argument is chosen

Signature

``````export function min<A>(O: Ord<A>): (x: A, y: A) => A { ... }
``````

# ord

Signature

``````export const ord: Contravariant1<URI> = ...
``````

# ordBoolean

Signature

``````export const ordBoolean: Ord<boolean> = ...
``````

# ordDate

Signature

``````export const ordDate: Ord<Date> = ...
``````

# ordNumber

Signature

``````export const ordNumber: Ord<number> = ...
``````

# ordString

Signature

``````export const ordString: Ord<string> = ...
``````

Use `getMonoid` instead
``````export function getSemigroup<A = never>(): Semigroup<Ord<A>> { ... }