Type Alias GreaterThan<A, B>

GreaterThan: A extends number
    ? B extends number
        ? number extends A
        | B
            ? boolean
            : [
                IsEqual<A, PositiveInfinity>,
                IsEqual<A, NegativeInfinity>,
                IsEqual<B, PositiveInfinity>,
                IsEqual<B, NegativeInfinity>,
            ] extends infer R extends [boolean, boolean, boolean, boolean]
                ? Or<
                    And<IsEqual<R[0], true>, IsEqual<R[2], false>>,
                    And<IsEqual<R[3], true>, IsEqual<R[1], false>>,
                > extends true
                    ? true
                    : Or<
                        And<IsEqual<R[1], true>, IsEqual<R[3], false>>,
                        And<IsEqual<R[2], true>, IsEqual<R[0], false>>,
                    > extends true
                        ? false
                        : true extends R[number]
                            ? false
                            : [IsNegative<A>, IsNegative<B>] extends infer R extends
                                [boolean, boolean]
                                ? [true, false] extends R
                                    ? false
                                    : [(...), (...)] extends R
                                        ? true
                                        : (...) extends (...) ? (...) : (...)
                                : never
                : never
        : never
    : never

Returns a boolean for whether a given number is greater than another number.

Type Parameters

A extends number
B extends number

Example

import type {GreaterThan} from 'type-fest';

type A = GreaterThan<1, -5>;
//=> true

type B = GreaterThan<1, 1>;
//=> false

type C = GreaterThan<1, 5>;
//=> false

Note: If either argument is the non-literal number type, the result is boolean.

Example

import type {GreaterThan} from 'type-fest';

type A = GreaterThan<number, 1>;
//=> boolean

type B = GreaterThan<1, number>;
//=> boolean

type C = GreaterThan<number, number>;
//=> boolean

Example

import type {GreaterThan} from 'type-fest';

// Use `GreaterThan` to constrain a function parameter to positive numbers.
declare function setPositive<N extends number>(value: GreaterThan<N, 0> extends true ? N : never): void;

setPositive(1); // ✅ Allowed
setPositive(2); // ✅ Allowed

// @ts-expect-error
setPositive(0);

// @ts-expect-error
setPositive(-1);

Type Alias GreaterThan<A, B>

Type Parameters

Example

Example

Example

Settings