Ordering

Ordering: object

Defined in: Core/Ordering.ts:17

Type Declaration

by

by: <A, B>(f) => (ord) => Ordering<B>

Adapts an ordering for type A into an ordering for type B by extracting a field. Read as “ordering by this field”: pipe(Ordering.number, Ordering.by(p => p.price)).

Type Parameters

A

A

B

B

Parameters

f

(b) => A

Returns

(ord) => Ordering<B>

Example

type Product = { name: string; price: number };
const byPrice = pipe(Ordering.number, Ordering.by((p: Product) => p.price));
pipe(products, Arr.sortWith(byPrice));

byFields

byFields: <A>(orderings) => Ordering<A>

Combines a list of orderings into a single composite comparator. Evaluates each ordering in sequence until a non-zero comparison result is found.

Type Parameters

A

A

Parameters

orderings

readonly Ordering<A>[]

Returns

Ordering<A>

Example

const byName = pipe(Ordering.string, Ordering.by((u: User) => u.name));
const byAge  = pipe(Ordering.number, Ordering.by((u: User) => u.age));
const sortUsers = Ordering.byFields([byName, byAge]);

date

date: Ordering<Date> = dateOrd

Ordering for Date values by numeric time value.

Example

pipe(dates, Arr.sortWith(Ordering.date)); // earliest first

number

number: Ordering<number> = numberOrd

Numeric ordering. Equivalent to (a, b) => a - b.

Example

pipe([3, 1, 2], Arr.sortWith(Ordering.number)); // [1, 2, 3]

reverse

reverse: <A>(ord) => Ordering<A>

Flips the direction of an ordering.

Type Parameters

A

A

Parameters

ord

Ordering<A>

Returns

Ordering<A>

Example

pipe([3, 1, 2], Arr.sortWith(Ordering.reverse(Ordering.number))); // [3, 2, 1]

string

string: Ordering<string> = stringOrd

Alphabetical ordering for strings.

Example

Ordering.string("apple", "banana"); // negative

thenBy

thenBy: <A>(ord2) => (ord1) => Ordering<A>

Chains two orderings: the second is used only when the first returns 0. Data-last: the first ordering is the data being piped.

Type Parameters

A

A

Parameters

ord2

Ordering<A>

Returns

(ord1) => Ordering<A>

Example

const byDeptThenSalary = pipe(byDept, Ordering.thenBy(bySalary));

tuple

tuple: <T>(…orderings) => Ordering<T>

Derives a lexicographical tuple ordering from positional Ordering comparators.

Type Parameters

T

T extends readonly unknown[]

Parameters

orderings

…{ [K in string | number | symbol]: Ordering<T[K]> }

Returns

Ordering<T>

Example

const pairOrd = Ordering.tuple(Ordering.string, Ordering.number);
pairOrd(["a", 1], ["a", 2]); // negative