Order
This module provides an implementation of the Order type class which is used to define a total ordering on some type A. An order is defined by a relation <=, which obeys the following laws:
- either x <= y or y <= x (totality) - if x <= y and y <= x, then x == y (antisymmetry) - if x <= y and y <= z, then x <= z (transitivity)
The truth table for compare is defined as follows:
| x <= y | x >= y | Ordering | | | -------- | -------- | -------- | --------------------- | | true | true | 0 | corresponds to x == y | | true | false | < 0 | corresponds to x < y | | false | true | > 0 | corresponds to x > y |
Combinators
Signature
declare function array<A>(O: Order<A>): Order<readonly Array<A>>This function creates and returns a new Order for a struct of values based on the given Orders for each property in the struct.
Signature
declare function struct<
R extends {
[x: string]: Order<any>;
},
>(fields: R): Order<{ [K in string | number | symbol]: [R[K]] extends [Order<A>] ? A : never }>;Similar to Promise.all but operates on Orders.
This function creates and returns a new Order for a tuple of values based on the given Orders for each element in the tuple. The returned Order compares two tuples of the same type by applying the corresponding Order to each element in the tuple. It is useful when you need to compare two tuples of the same type and you have a specific way of comparing each element of the tuple.
Signature
declare function tuple<T extends readonly Array<Order<any>>>(...elements: T): Order<Readonly<{ [I in string | number | symbol]: [T[I]] extends [Order<A>] ? A : never }>>Combining
Signature
declare function all<A>(collection: Iterable<Order<A>>): Order<readonly Array<A>>Signature
declare const combine: {
<A>(that: Order<A>): (self: Order<A>) => Order<A>;
<A>(self: Order<A>, that: Order<A>): Order<A>;
};combineAll
Signature
declare function combineAll<A>(collection: Iterable<Order<A>>): Order<A>;combineMany
Signature
declare const combineMany: {
<A>(collection: Iterable<Order<A>>): (self: Order<A>) => Order<A>;
<A>(self: Order<A>, collection: Iterable<Order<A>>): Order<A>;
};Signature
declare const product: {
<B>(that: Order<B>): <A>(self: Order<A>) => Order<readonly [A, B]>;
<A, B>(self: Order<A>, that: Order<B>): Order<readonly [A, B]>;
};productMany
Signature
declare const productMany: {
<A>(collection: Iterable<Order<A>>): (self: Order<A>) => Order<readonly [A, A]>;
<A>(self: Order<A>, collection: Iterable<Order<A>>): Order<readonly [A, A]>;
};Constructors
Instances
Signature
declare const bigint: Order<bigint>;Signature
declare const boolean: Order<boolean>;Signature
declare const Date: Order<Date>;Signature
declare const number: Order<number>;Signature
declare const string: Order<string>;Mapping
Other
Test whether a value is between a minimum and a maximum (inclusive).
Signature
declare function between<A>(O: Order<A>): {
(options: { maximum: A; minimum: A }): (self: A) => boolean;
(
self: A,
options: {
maximum: A;
minimum: A;
},
): boolean;
};Clamp a value between a minimum and a maximum.
Signature
declare function clamp<A>(O: Order<A>): {
(options: { maximum: A; minimum: A }): (self: A) => A;
(
self: A,
options: {
maximum: A;
minimum: A;
},
): A;
};Signature
declare function empty<A>(): Order<A>;greaterThan
Test whether one value is _strictly greater than_ another.
Signature
declare function greaterThan<A>(O: Order<A>): {
(that: A): (self: A) => boolean;
(self: A, that: A): boolean;
};greaterThanOrEqualTo
Test whether one value is _non-strictly greater than_ another.
Signature
declare function greaterThanOrEqualTo<A>(O: Order<A>): {
(that: A): (self: A) => boolean;
(self: A, that: A): boolean;
};Test whether one value is _strictly less than_ another.
Signature
declare function lessThan<A>(O: Order<A>): {
(that: A): (self: A) => boolean;
(self: A, that: A): boolean;
};lessThanOrEqualTo
Test whether one value is _non-strictly less than_ another.
Signature
declare function lessThanOrEqualTo<A>(O: Order<A>): {
(that: A): (self: A) => boolean;
(self: A, that: A): boolean;
};Take the maximum of two values. If they are considered equal, the first argument is chosen.
Signature
declare function max<A>(O: Order<A>): {
(that: A): (self: A) => A;
(self: A, that: A): A;
};Take the minimum of two values. If they are considered equal, the first argument is chosen.
Signature
declare function min<A>(O: Order<A>): {
(that: A): (self: A) => A;
(self: A, that: A): A;
};Signature
declare function reverse<A>(O: Order<A>): Order<A>;Type Class
Type Lambdas
OrderTypeLambda interface
Signature
interface OrderTypeLambda extends TypeLambda {
readonly type: Order<unknown>;
}
This function creates and returns a new
Orderfor an array of values based on a givenOrderfor the elements of the array. The returnedOrdercompares two arrays by applying the givenOrderto each element in the arrays. If all elements are equal, the arrays are then compared based on their length. It is useful when you need to compare two arrays of the same type and you have a specific way of comparing each element of the array.