Ord

Instances

• Contravariant
• getMonoid
• getSemigroup

Constructors

• fromCompare

Defaults

• equalsDefault

Model

• Ord

Type lambdas

• URI
• URI

Utilities

• between
• clamp
• contramap
• equals
• geq
• getDualOrd (deprecated)
• getTupleOrd (deprecated)
• gt
• leq
• lt
• max
• min
• ord (deprecated)
• ordBoolean (deprecated)
• ordDate (deprecated)
• ordNumber (deprecated)
• ordString (deprecated)
• reverse
• trivial
• tuple

Instances

Contravariant

Signature

export declare const Contravariant: Contravariant1<URI>

Details

• Added in 0.1.0

License

• MIT – Copyright (c) 2017-present Giulio Canti

---

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 declare const getMonoid: <A = never>() => Monoid<Ord<A>>

Details

• Added in 0.1.0

Example

import { sort } from '@fp-tx/core/Array'
import { contramap, reverse, getMonoid } from '@fp-tx/core/Ord'
import * as S from '@fp-tx/core/string'
import * as B from '@fp-tx/core/boolean'
import { pipe } from '@fp-tx/core/function'
import { concatAll } from '@fp-tx/core/Monoid'
import * as N from '@fp-tx/core/number'

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

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

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

const byRememberMe = pipe(
  B.Ord,
  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 = concatAll(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 = concatAll(M)([reverse(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 },
])

License

• MIT – Copyright (c) 2017-present Giulio Canti

---

getSemigroup

A typical use case for the Semigroup instance of Ord is merging two or more orderings.

For example the following snippet builds an Ord for a type User which sorts by created date descending, and then lastName

Signature

export declare const getSemigroup: <A = never>() => Semigroup<Ord<A>>

Details

• Added in 0.1.0

Example

import * as D from '@fp-tx/core/Date'
import { pipe } from '@fp-tx/core/function'
import { contramap, getSemigroup, Ord, reverse } from '@fp-tx/core/Ord'
import * as RA from '@fp-tx/core/ReadonlyArray'
import * as S from '@fp-tx/core/string'

interface User {
  readonly id: string
  readonly lastName: string
  readonly created: Date
}

const ordByLastName: Ord<User> = pipe(
  S.Ord,
  contramap(user => user.lastName),
)

const ordByCreated: Ord<User> = pipe(
  D.Ord,
  contramap(user => user.created),
)

const ordUserByCreatedDescThenLastName = getSemigroup<User>().concat(reverse(ordByCreated), ordByLastName)

assert.deepStrictEqual(
  RA.sort(ordUserByCreatedDescThenLastName)([
    { id: 'c', lastName: 'd', created: new Date(1973, 10, 30) },
    { id: 'a', lastName: 'b', created: new Date(1973, 10, 30) },
    { id: 'e', lastName: 'f', created: new Date(1980, 10, 30) },
  ]),
  [
    { id: 'e', lastName: 'f', created: new Date(1980, 10, 30) },
    { id: 'a', lastName: 'b', created: new Date(1973, 10, 30) },
    { id: 'c', lastName: 'd', created: new Date(1973, 10, 30) },
  ],
)

License

• MIT – Copyright (c) 2017-present Giulio Canti

Constructors

fromCompare

Signature

export declare const fromCompare: <A>(compare: (first: A, second: A) => Ordering) => Ord<A>

Details

• Added in 0.1.0

License

• MIT – Copyright (c) 2017-present Giulio Canti

Defaults

equalsDefault

Signature

export declare const equalsDefault: <A>(compare: (first: A, second: A) => Ordering) => (x: A, y: A) => boolean

Details

• Added in 0.1.0

License

• MIT – Copyright (c) 2017-present Giulio Canti

Model

Ord

Signature

export interface Ord<A> extends Eq<A> {
  readonly compare: (first: A, second: A) => Ordering
}

Details

• Added in 0.1.0

License

• MIT – Copyright (c) 2017-present Giulio Canti

Type lambdas

URI

Signature

export type URI = typeof URI

Details

• Added in 0.1.0

License

• MIT – Copyright (c) 2017-present Giulio Canti

---

URI

Signature

export declare const URI = 'Ord'

Details

• Added in 0.1.0

License

• MIT – Copyright (c) 2017-present Giulio Canti

Utilities

between

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

Signature

export declare const between: <A>(O: Ord<A>) => (low: A, hi: A) => (a: A) => boolean

Details

• Added in 0.1.0

License

• MIT – Copyright (c) 2017-present Giulio Canti

---

clamp

Clamp a value between a minimum and a maximum

Signature

export declare const clamp: <A>(O: Ord<A>) => (low: A, hi: A) => (a: A) => A

Details

• Added in 0.1.0

License

• MIT – Copyright (c) 2017-present Giulio Canti

---

contramap

A typical use case for contramap would be like, given some User type, to construct an Ord<User>.

We can do so with a function from User -> X where X is some value that we know how to compare for ordering (meaning we have an Ord<X>)

Signature

export declare const contramap: <A, B>(f: (b: B) => A) => (fa: Ord<A>) => Ord<B>

Details

• Added in 0.1.0

Example

import { pipe } from '@fp-tx/core/function'
import { contramap, Ord } from '@fp-tx/core/Ord'
import * as RA from '@fp-tx/core/ReadonlyArray'
import * as S from '@fp-tx/core/string'

interface User {
  readonly firstName: string
  readonly lastName: string
}

const ordLastName: Ord<string> = S.Ord

const ordByLastName: Ord<User> = pipe(
  ordLastName,
  contramap(user => user.lastName),
)

assert.deepStrictEqual(
  RA.sort(ordByLastName)([
    { firstName: 'a', lastName: 'd' },
    { firstName: 'c', lastName: 'b' },
  ]),
  [
    { firstName: 'c', lastName: 'b' },
    { firstName: 'a', lastName: 'd' },
  ],
)

License

• MIT – Copyright (c) 2017-present Giulio Canti

---

equals

Signature

export declare const equals: <A>(O: Ord<A>) => (second: A) => (first: A) => boolean

Details

• Added in 0.1.0

License

• MIT – Copyright (c) 2017-present Giulio Canti

---

geq

Test whether one value is non-strictly greater than another

Signature

export declare const geq: <A>(O: Ord<A>) => (first: A, second: A) => boolean

Details

• Added in 0.1.0

License

• MIT – Copyright (c) 2017-present Giulio Canti

---

getDualOrd

Use reverse instead.

Signature

export declare const getDualOrd: <A>(O: Ord<A>) => Ord<A>

Details

• Added in 0.1.0
• Deprecated

License

• MIT – Copyright (c) 2017-present Giulio Canti

---

getTupleOrd

Use tuple instead.

Signature

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

Details

• Added in 0.1.0
• Deprecated

License

• MIT – Copyright (c) 2017-present Giulio Canti

---

gt

Test whether one value is strictly greater than another

Signature

export declare const gt: <A>(O: Ord<A>) => (first: A, second: A) => boolean

Details

• Added in 0.1.0

License

• MIT – Copyright (c) 2017-present Giulio Canti

---

leq

Test whether one value is non-strictly less than another

Signature

export declare const leq: <A>(O: Ord<A>) => (first: A, second: A) => boolean

Details

• Added in 0.1.0

License

• MIT – Copyright (c) 2017-present Giulio Canti

---

lt

Test whether one value is strictly less than another

Signature

export declare const lt: <A>(O: Ord<A>) => (first: A, second: A) => boolean

Details

• Added in 0.1.0

License

• MIT – Copyright (c) 2017-present Giulio Canti

---

max

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

Signature

export declare const max: <A>(O: Ord<A>) => (first: A, second: A) => A

Details

• Added in 0.1.0

License

• MIT – Copyright (c) 2017-present Giulio Canti

---

min

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

Signature

export declare const min: <A>(O: Ord<A>) => (first: A, second: A) => A

Details

• Added in 0.1.0

License

• MIT – Copyright (c) 2017-present Giulio Canti

---

ord

Use Contravariant instead.

Signature

export declare const ord: Contravariant1<URI>

Details

• Added in 0.1.0
• Deprecated

License

• MIT – Copyright (c) 2017-present Giulio Canti

---

ordBoolean

Use Ord instead.

Signature

export declare const ordBoolean: Ord<boolean>

Details

• Added in 0.1.0
• Deprecated

License

• MIT – Copyright (c) 2017-present Giulio Canti

---

ordDate

Use Ord instead.

Signature

export declare const ordDate: Ord<Date>

Details

• Added in 0.1.0
• Deprecated

License

• MIT – Copyright (c) 2017-present Giulio Canti

---

ordNumber

Use Ord instead.

Signature

export declare const ordNumber: Ord<number>

Details

• Added in 0.1.0
• Deprecated

License

• MIT – Copyright (c) 2017-present Giulio Canti

---

ordString

Use Ord instead.

Signature

export declare const ordString: Ord<string>

Details

• Added in 0.1.0
• Deprecated

License

• MIT – Copyright (c) 2017-present Giulio Canti

---

reverse

Signature

export declare const reverse: <A>(O: Ord<A>) => Ord<A>

Details

• Added in 0.1.0

License

• MIT – Copyright (c) 2017-present Giulio Canti

---

trivial

Signature

export declare const trivial: Ord<unknown>

Details

• Added in 0.1.0

License

• MIT – Copyright (c) 2017-present Giulio Canti

---

tuple

Given a tuple of Ords returns an Ord for the tuple.

Signature

export declare const tuple: <A extends readonly unknown[]>(...ords: { [K in keyof A]: Ord<A[K]> }) => Ord<Readonly<A>>

Details

• Added in 0.1.0

Example

import { tuple } from '@fp-tx/core/Ord'
import * as B from '@fp-tx/core/boolean'
import * as S from '@fp-tx/core/string'
import * as N from '@fp-tx/core/number'

const O = tuple(S.Ord, N.Ord, B.Ord)
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)

License

• MIT – Copyright (c) 2017-present Giulio Canti