Int

A collection of functions to manipulate integer values

Index

Bound

Codec

Comparator

Constructor

fromNumber

Formatting

asString

Indexable

Numeric

Type

Other

Bound

readonlymaxValue

maxValue: Int

Maximum value for this type

@example

const anyNumber: number
anyNumber < Number.maxValue // true

readonlyminValue

minValue: Int

Minimum value for this type

@example

const anyNumber: number
anyNumber > Number.minValue // true

Codec

decode

__decode__(this: void, input: unknown, context: Context<Int>): Result<Int, CodecError>

Returns the decoded input, Result.Ok or Result.Error()

@example

interface SomeObject {
  foo: string
}
const someCodec: Codec<SomeObject> = ...;
const input: unknown = ...;
const decoded = Codec.decode(someCodec, input);

encode

__encode__(this: void, input: Int): unknown

Returns the encoded input

@example

interface SomeObject {
  foo: string
}
const someCodec: Codec<SomeObject> = ...;
const someObject: SomeObject = { foo: "bar" }
const encoded = Codec.decode(someCodec, someObject);

schema

__schema__(this: void): JSONValue

Returns the JSONSchema corresponding to the decoded type

@example

const someCodec: Codec<unknown> = ...;
const jsonSchema = Codec.schema(someCodec);

Comparator

!=

!=(this: void, left: Int, right: Int): boolean

"Not equal to" operator

@example

const TEqual: Equal<T>;
TEqual['!='](value, otherValue); // true
TEqual['!='](value, value); // false

＜

＜(this: void, left: Int, right: Int): boolean

"Less than" operator

@example

type T;
const TCompare: Comparable<T>;
const smallerT: T;
const greaterT: T;
TCompare['<'](smallerT, smallerT); // false
TCompare['<'](smallerT, greaterT); // true
TCompare['<'](greaterT, smallerT); // false

＜=

＜=(this: void, left: Int, right: Int): boolean

"Less than or equal to" operator

@example

type T;
const TCompare: Comparable<T>;
const smallerT: T;
const greaterT: T;
TCompare['<='](smallerT, smallerT); // true
TCompare['<='](smallerT, greaterT); // true
TCompare['<='](greaterT, smallerT); // false

==

==(this: void, left: Int, right: Int): boolean

"Equal to" operator

@example

type T = // ...
const TEqual: Equal<T>;
TEqual['=='](value, value); // true
TEqual['=='](value, otherValue); // false

＞

＞(this: void, left: Int, right: Int): boolean

"Greater than" operator

@example

type T;
const TCompare: Comparable<T>;
const smallerT: T;
const greaterT: T;
TCompare['>'](smallerT, smallerT); // false
TCompare['>'](smallerT, greaterT); // false
TCompare['>'](greaterT, smallerT); // true

＞=

＞=(this: void, left: Int, right: Int): boolean

"Greater than or equal to" operator

@example

type T;
const TCompare: Comparable<T>;
const smallerT: T;
const greaterT: T;
TCompare['>='](smallerT, smallerT); // true
TCompare['>='](smallerT, greaterT); // false
TCompare['>='](greaterT, smallerT); // true

clamp

clamp(this: void, value: Int, minValue: Int, maxValue: Int): Int

Clamp value between minValue and maxValue

@example

type T;
const TCompare: Comparable<T>;
TCompare.clamp(value, min, max); // min if value < min, max if value > max, otherwise value itself

compare

compare(this: void, left: Int, right: Int): Ordering

Return an Ordering that represents comparison result

@see

Order

@example

type T;
const TCompare: Comparable<T>;
const sorted = [3, 1, 1].sort(TCompare.compare);

equals

equals(this: void, left: Int, right: Int): boolean

Alias to '=='

@example

type T = // ...
const TEqual: Equal<T>;
TEqual.equals(value, value); // true
TEqual.equals(value, otherValue); // false

max

max(this: void, left: Int, right: Int): Int

"maximum" operator

@example

type T;
const TCompare: Comparable<T>;
const smallerT: T;
const greaterT: T;
TCompare.max(smallerT, greaterT); // greaterT

min

min(this: void, left: Int, right: Int): Int

"minimum" operator

@example

type T;
const TCompare: Comparable<T>;
const smallerT: T;
const greaterT: T;
TCompare.min(smallerT, greaterT); // smallerT

Constructor

fromNumber

fromNumber(value: number): Option<Int>

Return a new integer from value

@example

const intValue = Int.fromNumber(0.5);// 0

Formatting

asString

asString(this: void, self: Int): string

Converts the given value to a String.
@example
Number.asString(123); // '123'

Indexable

indexType

indexType: number

Index type

at

at(index: Int): Option<Int>

Returns the value at the index

indexOf

indexOf(value: Int): Option<Int>

Returns the integer index of a value

range

range(start: Int, end: Int): Range<Int>

Returns an Iterable starting from start to end. If start or end is not in range then returns an empty iterable.

rangeSize

rangeSize(start: Int, end: Int): Int

Returns the size of a range. If start or end is not in range then returns 0.

Numeric

%

%(left: Int, right: Int): Int

Remainder operator

@example

type T = ...;
const TNumeric: Numeric.Remainder<T> = ...;
const result = Numeric['%'](left, right);// represents (left % right)

*

*(left: Int, right: Int): Int

Multiplication operator

@example

type T = ...;
const TNumeric: Numeric.Multiply<T> = ...;
const result = Numeric['*'](left, right);// represents (left * right)

**

**(left: Int, right: Int): Int

Power operator

@example

type T = ...;
const TNumeric: Numeric.Power<T> = ...;
const result = Numeric['**'](left, right);// represents (left ** right)

+

+(left: Int, right: Int): Int

Addition operator

@example

type T = ...;
const TNumeric: Numeric.Add<T> = ...;
const result = TNumeric['+'](left, right);// represents (left + right)

-

-(left: Int, right: Int): Int

Subtraction operator

@example

type T = ...;
const TNumeric: Numeric.Subtract<T> = ...;
const result = Numeric['-'](left, right);// represents (left - right)

/?

/?(left: Int, right: Int): Option<Int>

Division operator

@example

type T = ...;
const TNumeric: Numeric.CheckedDivide<T> = ...;
const result = Numeric['/?'](left, right);// represents (left / right)

abs

abs(this: void, value: Int): Int

Absolute value. It should satisfy Numeric['*'](Numeric.abs(x), Numeric.sign(x)) == x

@example

type T = ...;
const TSigned: Numeric.Signed<T> = ...;
const result = TSigned.abs(value);// absolute value of (value)

isNegative

isNegative(this: void, self: Int): boolean

Returns true if the number is negative and false if the number is zero or positive.
@example
Number.isPositive(-1);// true Number.isPositive(0);// false Number.isPositive(1);// false

isPositive

isPositive(this: void, self: Int): boolean

Returns true if the number is positive and false if the number is zero or negative.
@example
Number.isPositive(-1);// false Number.isPositive(0);// false Number.isPositive(1);// true

isZero

isZero(this: void, self: Int): boolean

Returns true if self is equal to the additive identity.
@example
Number.isZero(0); // true Number.isZero(1); // false

negate

negate(self: Int): Int

Negates the given value.

@example

Number.negate(5); // -5
Number.negate(Number.negate(5)); // 5

sign

sign(this: void, value: Int): Int

Sign of a number. It should satisfy TSigned['*'](TSigned.abs(x), TSigned.sign(x)) == x
@example
Number.sign(-2.5);// -1 Number.sign(0);// 0 Number.sign(2.5);// 1

zero

zero(this: void): Int

Returns the additive identity element of T, 0.
@example
Number.zero(); // 0

Type

inspect

__inspect__: Option<(anyValue: Int, depth: number, options: InspectOptions, inspect: InspectFunction) => string>

When defined, returns a custom string representation. To be useful, it should be bound to a prototype (ex: Struct)

@example

import { inspect } from 'node:util';

interface Foo {
  foo: boolean;
}
const Foo = Struct.define<Foo>({
  typeName: 'Foo',
  __inspect__: (self) => `Foo { ${String(self.foo)} }`,
});
const myStruct = Struct.create(Foo, { foo: true });// 'Foo { true }'
inspect(myStruct);// 'Foo { true }'

@param

asInstance

asInstance(this: void, anyValue: unknown): Option<Int>

Try to convert anyValue to enum value or else returns Option.None

@example

const StringType: Type<string>;
StringType.asInstance('foo'); // Option.Some('foo')
StringType.asInstance(12); // Option.None

hasInstance

hasInstance(this: void, anyValue: unknown): anyValue is Int

Return true if the given value is an instance of the class.

@example

const StringType: Type<string>;
StringType.hasInstance('foo'); // true
StringType.hasInstance(42); // false

unwrap

unwrap(value: Int): number

Convert a tagged value to the underlying type

wrap

wrap(value: number): Int

Convert an underlying type to a tagged type

Other

typeName

Re-exports typeName

Module

Module<T>:

Type parameters

T: number

readonlymaxValue

maxValue: T

Maximum value for this type

@example

const anyNumber: number
anyNumber < Number.maxValue // true

readonlyminValue

minValue: T

Minimum value for this type

@example

const anyNumber: number
anyNumber > Number.minValue // true

!=

!=(this: void, left: T, right: T): boolean

"Not equal to" operator

@example

const TEqual: Equal<T>;
TEqual['!='](value, otherValue); // true
TEqual['!='](value, value); // false

%

%(left: T, right: T): T

Remainder operator

@example

type T = ...;
const TNumeric: Numeric.Remainder<T> = ...;
const result = Numeric['%'](left, right);// represents (left % right)

*

*(left: T, right: T): T

Multiplication operator

@example

type T = ...;
const TNumeric: Numeric.Multiply<T> = ...;
const result = Numeric['*'](left, right);// represents (left * right)

**

**(left: T, right: T): T

Power operator

@example

type T = ...;
const TNumeric: Numeric.Power<T> = ...;
const result = Numeric['**'](left, right);// represents (left ** right)

+

+(left: T, right: T): T

Addition operator

@example

type T = ...;
const TNumeric: Numeric.Add<T> = ...;
const result = TNumeric['+'](left, right);// represents (left + right)

-

-(left: T, right: T): T

Subtraction operator

@example

type T = ...;
const TNumeric: Numeric.Subtract<T> = ...;
const result = Numeric['-'](left, right);// represents (left - right)

/?

/?(left: T, right: T): Option<T>

Division operator

@example

type T = ...;
const TNumeric: Numeric.CheckedDivide<T> = ...;
const result = Numeric['/?'](left, right);// represents (left / right)

＜

＜(this: void, left: T, right: T): boolean

"Less than" operator

@example

type T;
const TCompare: Comparable<T>;
const smallerT: T;
const greaterT: T;
TCompare['<'](smallerT, smallerT); // false
TCompare['<'](smallerT, greaterT); // true
TCompare['<'](greaterT, smallerT); // false

＜=

＜=(this: void, left: T, right: T): boolean

"Less than or equal to" operator

@example

type T;
const TCompare: Comparable<T>;
const smallerT: T;
const greaterT: T;
TCompare['<='](smallerT, smallerT); // true
TCompare['<='](smallerT, greaterT); // true
TCompare['<='](greaterT, smallerT); // false

==

==(this: void, left: T, right: T): boolean

"Equal to" operator

@example

type T = // ...
const TEqual: Equal<T>;
TEqual['=='](value, value); // true
TEqual['=='](value, otherValue); // false

＞

＞(this: void, left: T, right: T): boolean

"Greater than" operator

@example

type T;
const TCompare: Comparable<T>;
const smallerT: T;
const greaterT: T;
TCompare['>'](smallerT, smallerT); // false
TCompare['>'](smallerT, greaterT); // false
TCompare['>'](greaterT, smallerT); // true

＞=

＞=(this: void, left: T, right: T): boolean

"Greater than or equal to" operator

@example

type T;
const TCompare: Comparable<T>;
const smallerT: T;
const greaterT: T;
TCompare['>='](smallerT, smallerT); // true
TCompare['>='](smallerT, greaterT); // false
TCompare['>='](greaterT, smallerT); // true

abs

abs(this: void, value: T): T

Absolute value. It should satisfy Numeric['*'](Numeric.abs(x), Numeric.sign(x)) == x

@example

type T = ...;
const TSigned: Numeric.Signed<T> = ...;
const result = TSigned.abs(value);// absolute value of (value)

clamp

clamp(this: void, value: T, minValue: T, maxValue: T): T

Clamp value between minValue and maxValue

@example

type T;
const TCompare: Comparable<T>;
TCompare.clamp(value, min, max); // min if value < min, max if value > max, otherwise value itself

compare

compare(this: void, left: T, right: T): Ordering

Inherited from ComparableInterface.compare
Return an Ordering that represents comparison result
@see
Order
@example
type T; const TCompare: Comparable<T>; const sorted = [3, 1, 1].sort(TCompare.compare);

equals

equals(this: void, left: T, right: T): boolean

Alias to '=='

@example

type T = // ...
const TEqual: Equal<T>;
TEqual.equals(value, value); // true
TEqual.equals(value, otherValue); // false

isNegative

isNegative(this: void, self: T): boolean

Inherited from Numeric.Signed.isNegative
Returns true if the number is negative and false if the number is zero or positive.
@example
Number.isPositive(-1);// true Number.isPositive(0);// false Number.isPositive(1);// false

isPositive

isPositive(this: void, self: T): boolean

Inherited from Numeric.Signed.isPositive
Returns true if the number is positive and false if the number is zero or negative.
@example
Number.isPositive(-1);// false Number.isPositive(0);// false Number.isPositive(1);// true

isZero

isZero(this: void, self: T): boolean

Inherited from Numeric.Zero.isZero
Returns true if self is equal to the additive identity.
@example
Number.isZero(0); // true Number.isZero(1); // false

max

max(this: void, left: T, right: T): T

"maximum" operator

@example

type T;
const TCompare: Comparable<T>;
const smallerT: T;
const greaterT: T;
TCompare.max(smallerT, greaterT); // greaterT

min

min(this: void, left: T, right: T): T

"minimum" operator

@example

type T;
const TCompare: Comparable<T>;
const smallerT: T;
const greaterT: T;
TCompare.min(smallerT, greaterT); // smallerT

negate

negate(self: T): T

Inherited from Numeric.Negate.negate
Negates the given value.
@example
Number.negate(5); // -5 Number.negate(Number.negate(5)); // 5

sign

sign(this: void, value: T): T

Inherited from Numeric.Signed.sign
Sign of a number. It should satisfy TSigned['*'](TSigned.abs(x), TSigned.sign(x)) == x
@example
Number.sign(-2.5);// -1 Number.sign(0);// 0 Number.sign(2.5);// 1

zero

zero(this: void): T

Inherited from Numeric.Zero.zero
Returns the additive identity element of T, 0.
@example
Number.zero(); // 0

Make

Make<T>(): Int.Module<T>

Create a module number type
@example
Type parameters
- T: number

call

__call__(value: number): Int

format

format(intValue: Int, radix?: Radix36): string

Return string representation of integer

@example

Int.format(Int(1), 10);// '1'
Int.format(Int(10), 16);// 'A'

parse

parse(expression: string, radix?: Radix36): Option<Int>

Parses a string argument and returns an integer of the specified radix (the base in mathematical numeral systems). If the expression is not valid, it returns Option.None
@example
Int.parse('1');// Option.Some(1) Int.parse('invalid');// Option.None

Index

Bound

Codec

Comparator

Constructor

Formatting

Indexable

Numeric

Type

Other

Bound

readonlymaxValue

readonlyminValue

Codec

__decode__

__encode__

__schema__

Comparator

!=

＜

＜=

==

＞

＞=

clamp

compare

equals

max

min

Constructor

fromNumber

Formatting

asString

Indexable

indexType

at

indexOf

range

rangeSize

Numeric

%

*

**

+

-

/?

abs

isNegative

isPositive

isZero

negate

sign

zero

Type

__inspect__

asInstance

hasInstance

unwrap

wrap

Other

typeName

Module

Type parameters

readonlymaxValue

readonlyminValue

!=

%

*

**

+

-

/?

＜

＜=

==

＞

＞=

abs

clamp

compare

decode

encode

schema

inspect

call