rivo/Num/index.d.ts

🤖 The ultimate library you need for composable type-level programming in TypeScript, powered by HKT.

import type AbsFn from "./Abs";
import type AddFn from "./Add";
import type CompareFn from "./Compare";
import type GTFn from "./GT";
import type GTEFn from "./GTE";
import type IsDigitFn from "./IsDigit";
import type IsNatFn from "./IsNat";
import type IsNegFn from "./IsNeg";
import type IsPosFn from "./IsPos";
import type LTFn from "./LT";
import type LTEFn from "./LTE";
// @ts-ignore - Only used in doc comments
import type { Nat } from "./Nat";
import type SubFn from "./Sub";
import type ToStrFn from "./ToStr";
import type { Flip, PartialApply } from "../HKT";

/**
 * Digit type.
 */
export type Digit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
/**
 * String representation of {@link Digit}.
 */
export type SDigit = `${Digit}`;

/***********
 * Methods *
 ***********/
/**
 * Methods for `number`.
 */
export namespace Num {
  /**
   * [Fn] Convert a `number` to a string.
   *
   * Sig: `(n: number) => string`
   */
  export type ToStr = ToStrFn;

  /**
   * [Fn] Check if a `number` is positive.
   *
   * Sig: `(n: number) => boolean`
   */
  export type IsPos = IsPosFn;

  /**
   * [Fn] Check if a `number` is negative.
   *
   * Sig: `(n: number) => boolean`
   */
  export type IsNeg = IsNegFn;

  /**
   * [Fn] Check if a value is {@link Nat}.
   *
   * Sig: `(n: number) => boolean`
   */
  export type IsNat = IsNatFn;

  /**
   * [Fn] Check if a `number` is a {@link Digit}.
   *
   * Sig: `(n: number) => boolean`
   */
  export type IsDigit = IsDigitFn;

  /**
   * [Fn] Get the absolute value of a `number`.
   *
   * Sig: `(n: number) => number`
   */
  export type Abs = AbsFn;

  /**
   * [Fn] Add two `number`s.
   *
   * Sig: `(n: number, m: number) => number`
   */
  export type Add2 = AddFn;
  /**
   * [Fn] Add two `number`s.
   *
   * Sig: `[m: number](n: number) => number`
   */
  export type Add<M extends number> = PartialApply<AddFn, [M], "_1">;

  /**
   * [Fn] Subtract two `number`s.
   *
   * Sig: `(n: number, m: number) => number`
   */
  export type Sub2 = SubFn;
  /**
   * [Fn] The flipped version of {@link Sub2}.
   *
   * Sig: `(m: number, n: number) => number`
   *
   * The `R` suffix (short for **R**ight or **R**everse) means that the arguments are flipped.
   */
  export type Sub2R = Flip<SubFn>;
  /**
   * [Fn] Subtract `m` from `n`.
   *
   * Sig: `[m: number](n: number) => number`
   */
  export type Sub<M extends number> = PartialApply<SubFn, [M], "_1">;
  /**
   * [Fn] Subtract `m` from `n`.
   *
   * Sig: `[n: number](m: number) => number`
   */
  export type SubFrom<N extends number> = PartialApply<SubFn, [N]>;

  /**
   * [Fn] Compare two `number`s.
   *
   * Sig: `(n: number, m: number) => Ordering`
   */
  export type Compare = CompareFn;
  /**
   * [Fn] The flipped version of {@link Compare}.
   *
   * Sig: `(m: number, n: number) => Ordering`
   *
   * The `R` suffix (short for **R**ight or **R**everse) means that the arguments are flipped.
   */
  export type CompareR = Flip<CompareFn>;
  /**
   * [Fn] Compare a `number` with another `number`.
   *
   * Sig: `[m: number](n: number) => Ordering`
   */
  export type CompareWith<M extends number> = PartialApply<CompareFn, [M], "_1">;
  /**
   * [Fn] Compare a `number` against another `number`.
   *
   * Sig: `[n: number](m: number) => Ordering`
   */
  export type CompareAgainst<N extends number> = PartialApply<CompareFn, [N]>;

  /**
   * [Fn] Check if `n` is less than `m`.
   *
   * Sig: `[m: number](n: number) => boolean`
   */
  export type LT<M extends number> = PartialApply<LTFn, [M], "_1">;
  /**
   * [Fn] Check if `n` is less than or equal to `m`.
   *
   * Sig: `[m: number](n: number) => boolean`
   */
  export type LTE<M extends number> = PartialApply<LTEFn, [M], "_1">;
  /**
   * [Fn] Check if `n` is greater than `m`.
   *
   * Sig: `[m: number](n: number) => boolean`
   */
  export type GT<M extends number> = PartialApply<GTFn, [M], "_1">;
  /**
   * [Fn] Check if `n` is greater than or equal to `m`.
   *
   * Sig: `[m: number](n: number) => boolean`
   */
  export type GTE<M extends number> = PartialApply<GTEFn, [M], "_1">;
}

/****************
 * Type classes *
 ****************/
export type { Num$$Ord } from "./Ord";
export type { Num$$Show } from "./Show";

/***************
 * Sub modules *
 ***************/
export type * from "./Int";
export type * from "./Nat";