<A, B, C = B>(options: {
readonly onLessThan: LazyArg<A>
readonly onEqual: LazyArg<B>
readonly onGreaterThan: LazyArg<C>
}): (self: Ordering) => A | B | C
<A, B, C = B>(
o: Ordering,
options: {
readonly onLessThan: LazyArg<A>
readonly onEqual: LazyArg<B>
readonly onGreaterThan: LazyArg<C>
}
): A | B | CMatches an Ordering value and returns the branch selected by that ordering.
When to use
Use to branch on the three possible comparison outcomes in one expression.
Example (Pattern matching on orderings)
import { Function, Ordering } from "effect"
import * as assert from "node:assert"
const toMessage = Ordering.match({
onLessThan: Function.constant("less than"),
onEqual: Function.constant("equal"),
onGreaterThan: Function.constant("greater than")
})
assert.deepStrictEqual(toMessage(-1), "less than")
assert.deepStrictEqual(toMessage(0), "equal")
assert.deepStrictEqual(toMessage(1), "greater than")pattern matching
Source effect/Ordering.ts:12424 lines
export const const match: {
<A, B, C = B>(options: {
readonly onLessThan: LazyArg<A>
readonly onEqual: LazyArg<B>
readonly onGreaterThan: LazyArg<C>
}): (self: Ordering) => A | B | C
<A, B, C = B>(
o: Ordering,
options: {
readonly onLessThan: LazyArg<A>
readonly onEqual: LazyArg<B>
readonly onGreaterThan: LazyArg<C>
}
): A | B | C
}
Matches an Ordering value and returns the branch selected by that ordering.
When to use
Use to branch on the three possible comparison outcomes in one expression.
Example (Pattern matching on orderings)
import { Function, Ordering } from "effect"
import * as assert from "node:assert"
const toMessage = Ordering.match({
onLessThan: Function.constant("less than"),
onEqual: Function.constant("equal"),
onGreaterThan: Function.constant("greater than")
})
assert.deepStrictEqual(toMessage(-1), "less than")
assert.deepStrictEqual(toMessage(0), "equal")
assert.deepStrictEqual(toMessage(1), "greater than")
match: {
<function (type parameter) A in <A, B, C = B>(options: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): (self: Ordering) => A | B | C
function (type parameter) B in <A, B, C = B>(options: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): (self: Ordering) => A | B | C
function (type parameter) C in <A, B, C = B>(options: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): (self: Ordering) => A | B | C
function (type parameter) B in <A, B, C = B>(options: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): (self: Ordering) => A | B | C
options: {
readonly onLessThan: LazyArg<A>
readonly onEqual: LazyArg<B>
readonly onGreaterThan: LazyArg<C>
}
onLessThan: LazyArg<A>onLessThan: import LazyArgLazyArg<function (type parameter) A in <A, B, C = B>(options: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): (self: Ordering) => A | B | C
onEqual: LazyArg<B>onEqual: import LazyArgLazyArg<function (type parameter) B in <A, B, C = B>(options: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): (self: Ordering) => A | B | C
onGreaterThan: LazyArg<C>onGreaterThan: import LazyArgLazyArg<function (type parameter) C in <A, B, C = B>(options: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): (self: Ordering) => A | B | C
self: Orderingself: type Ordering = 0 | 1 | -1Represents the result of comparing two values.
When to use
Use to model a normalized comparison result that is exactly less than,
equal to, or greater than.
Details
-1 indicates the first value is less than the second0 indicates the values are equal1 indicates the first value is greater than the second
Example (Defining comparison results)
import type { Ordering } from "effect"
// Custom comparison function
const compareNumbers = (a: number, b: number): Ordering.Ordering => {
if (a < b) return -1
if (a > b) return 1
return 0
}
console.log(compareNumbers(5, 10)) // -1 (5 < 10)
console.log(compareNumbers(10, 5)) // 1 (10 > 5)
console.log(compareNumbers(5, 5)) // 0 (5 == 5)
// Using with string comparison
const compareStrings = (a: string, b: string): Ordering.Ordering => {
return a.localeCompare(b) as Ordering.Ordering
}
Ordering) => function (type parameter) A in <A, B, C = B>(options: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): (self: Ordering) => A | B | C
function (type parameter) B in <A, B, C = B>(options: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): (self: Ordering) => A | B | C
function (type parameter) C in <A, B, C = B>(options: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): (self: Ordering) => A | B | C
function (type parameter) A in <A, B, C = B>(o: Ordering, options: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): A | B | C
function (type parameter) B in <A, B, C = B>(o: Ordering, options: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): A | B | C
function (type parameter) C in <A, B, C = B>(o: Ordering, options: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): A | B | C
function (type parameter) B in <A, B, C = B>(o: Ordering, options: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): A | B | C
o: Orderingo: type Ordering = 0 | 1 | -1Represents the result of comparing two values.
When to use
Use to model a normalized comparison result that is exactly less than,
equal to, or greater than.
Details
-1 indicates the first value is less than the second0 indicates the values are equal1 indicates the first value is greater than the second
Example (Defining comparison results)
import type { Ordering } from "effect"
// Custom comparison function
const compareNumbers = (a: number, b: number): Ordering.Ordering => {
if (a < b) return -1
if (a > b) return 1
return 0
}
console.log(compareNumbers(5, 10)) // -1 (5 < 10)
console.log(compareNumbers(10, 5)) // 1 (10 > 5)
console.log(compareNumbers(5, 5)) // 0 (5 == 5)
// Using with string comparison
const compareStrings = (a: string, b: string): Ordering.Ordering => {
return a.localeCompare(b) as Ordering.Ordering
}
Ordering,
options: {
readonly onLessThan: LazyArg<A>
readonly onEqual: LazyArg<B>
readonly onGreaterThan: LazyArg<C>
}
onLessThan: LazyArg<A>onLessThan: import LazyArgLazyArg<function (type parameter) A in <A, B, C = B>(o: Ordering, options: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): A | B | C
onEqual: LazyArg<B>onEqual: import LazyArgLazyArg<function (type parameter) B in <A, B, C = B>(o: Ordering, options: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): A | B | C
onGreaterThan: LazyArg<C>onGreaterThan: import LazyArgLazyArg<function (type parameter) C in <A, B, C = B>(o: Ordering, options: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): A | B | C
function (type parameter) A in <A, B, C = B>(o: Ordering, options: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): A | B | C
function (type parameter) B in <A, B, C = B>(o: Ordering, options: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): A | B | C
function (type parameter) C in <A, B, C = B>(o: Ordering, options: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): A | B | C
import dualdual(2, <function (type parameter) A in <A, B, C = B>(self: Ordering, { onEqual, onGreaterThan, onLessThan }: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): A | B | C
function (type parameter) B in <A, B, C = B>(self: Ordering, { onEqual, onGreaterThan, onLessThan }: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): A | B | C
function (type parameter) C in <A, B, C = B>(self: Ordering, { onEqual, onGreaterThan, onLessThan }: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): A | B | C
function (type parameter) B in <A, B, C = B>(self: Ordering, { onEqual, onGreaterThan, onLessThan }: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): A | B | C
self: Orderingself: type Ordering = 0 | 1 | -1Represents the result of comparing two values.
When to use
Use to model a normalized comparison result that is exactly less than,
equal to, or greater than.
Details
-1 indicates the first value is less than the second0 indicates the values are equal1 indicates the first value is greater than the second
Example (Defining comparison results)
import type { Ordering } from "effect"
// Custom comparison function
const compareNumbers = (a: number, b: number): Ordering.Ordering => {
if (a < b) return -1
if (a > b) return 1
return 0
}
console.log(compareNumbers(5, 10)) // -1 (5 < 10)
console.log(compareNumbers(10, 5)) // 1 (10 > 5)
console.log(compareNumbers(5, 5)) // 0 (5 == 5)
// Using with string comparison
const compareStrings = (a: string, b: string): Ordering.Ordering => {
return a.localeCompare(b) as Ordering.Ordering
}
Ordering,
{ onEqual: LazyArg<B>onEqual, onGreaterThan: LazyArg<C>onGreaterThan, onLessThan: LazyArg<A>onLessThan }: {
readonly onLessThan: LazyArg<A>onLessThan: import LazyArgLazyArg<function (type parameter) A in <A, B, C = B>(self: Ordering, { onEqual, onGreaterThan, onLessThan }: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): A | B | C
onEqual: LazyArg<B>onEqual: import LazyArgLazyArg<function (type parameter) B in <A, B, C = B>(self: Ordering, { onEqual, onGreaterThan, onLessThan }: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): A | B | C
onGreaterThan: LazyArg<C>onGreaterThan: import LazyArgLazyArg<function (type parameter) C in <A, B, C = B>(self: Ordering, { onEqual, onGreaterThan, onLessThan }: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): A | B | C
function (type parameter) A in <A, B, C = B>(self: Ordering, { onEqual, onGreaterThan, onLessThan }: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): A | B | C
function (type parameter) B in <A, B, C = B>(self: Ordering, { onEqual, onGreaterThan, onLessThan }: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): A | B | C
function (type parameter) C in <A, B, C = B>(self: Ordering, { onEqual, onGreaterThan, onLessThan }: {
readonly onLessThan: LazyArg<A>;
readonly onEqual: LazyArg<B>;
readonly onGreaterThan: LazyArg<C>;
}): A | B | C
self: Orderingself === -1 ? onLessThan: LazyArg<A>onLessThan() : self: Orderingself === 0 ? onEqual: LazyArg<B>onEqual() : onGreaterThan: LazyArg<C>onGreaterThan())