The Ord
type class represents types which support comparisons with a total order.
Instances should satisfy the laws of total orderings:
S.compare(a, a) <= 0
S.compare(a, b) <= 0
and S.compare(b, a) <= 0
then a <-> b
S.compare(a, b) <= 0
and S.compare(b, c) <= 0
then S.compare(a, c) <= 0
Added in v2.0.0
Signature
export declare const contramap: <A, B>(f: (b: B) => A) => (fa: Ord<A>) => Ord<B>
Added in v2.0.0
Signature
export declare function getDualOrd<A>(O: Ord<A>): Ord<A>
Added in v2.0.0
Signature
export declare function fromCompare<A>(compare: (x: A, y: A) => Ordering): Ord<A>
Added in v2.0.0
Signature
export declare const Contravariant: Contravariant1<'Ord'>
Added in v2.7.0
Signature
export declare const URI: 'Ord'
Added in v2.0.0
Signature
export type URI = typeof URI
Added in v2.0.0
Returns a Monoid
such that:
concat(ord1, ord2)
operation will order first by ord1
, and then by ord2
empty
value is an Ord
that always considers compared elements equalSignature
export declare function getMonoid<A = never>(): Monoid<Ord<A>>
Example
import { sort } from 'fp-ts/Array'
import { contramap, getDualOrd, getMonoid, ordBoolean, ordNumber, ordString } from 'fp-ts/Ord'
import { pipe } from 'fp-ts/function'
import { fold } from 'fp-ts/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 },
])
Added in v2.4.0
Given a tuple of Ord
s returns an Ord
for the tuple
Signature
export declare 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/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)
Added in v2.0.0
Signature
export declare const ord: Contravariant1<'Ord'>
Added in v2.0.0
Signature
export declare const ordBoolean: Ord<boolean>
Added in v2.0.0
Signature
export declare const ordDate: Ord<Date>
Added in v2.0.0
Signature
export declare const ordNumber: Ord<number>
Added in v2.0.0
Signature
export declare const ordString: Ord<string>
Added in v2.0.0
Use getMonoid
instead
Signature
export declare function getSemigroup<A = never>(): Semigroup<Ord<A>>
Added in v2.0.0
Signature
export interface Ord<A> extends Eq<A> {
readonly compare: (x: A, y: A) => Ordering
}
Added in v2.0.0
Test whether a value is between a minimum and a maximum (inclusive)
Signature
export declare function between<A>(O: Ord<A>): (low: A, hi: A) => (x: A) => boolean
Added in v2.0.0
Clamp a value between a minimum and a maximum
Signature
export declare function clamp<A>(O: Ord<A>): (low: A, hi: A) => (x: A) => A
Added in v2.0.0
Test whether one value is non-strictly greater than another
Signature
export declare function geq<A>(O: Ord<A>): (x: A, y: A) => boolean
Added in v2.0.0
Test whether one value is strictly greater than another
Signature
export declare function gt<A>(O: Ord<A>): (x: A, y: A) => boolean
Added in v2.0.0
Test whether one value is non-strictly less than another
Signature
export declare function leq<A>(O: Ord<A>): (x: A, y: A) => boolean
Added in v2.0.0
Test whether one value is strictly less than another
Signature
export declare function lt<A>(O: Ord<A>): (x: A, y: A) => boolean
Added in v2.0.0
Take the maximum of two values. If they are considered equal, the first argument is chosen
Signature
export declare function max<A>(O: Ord<A>): (x: A, y: A) => A
Added in v2.0.0
Take the minimum of two values. If they are considered equal, the first argument is chosen
Signature
export declare function min<A>(O: Ord<A>): (x: A, y: A) => A
Added in v2.0.0