Number

A collection of functions to manipulate number

@example

import { Number } from '@w5s/core';

const total = [1, 1.5, 2].reduce(Number['+'], 0);// 4.5
Number['=='](total, 4.5);// true

Index

Bound

Codec

Comparator

Formatting

asString

Numeric

Type

Other

Bound

readonlymaxValue

maxValue: number

Maximum value for this type

@example

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

readonlyminValue

minValue: number

Minimum value for this type

@example

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

Codec

decode

__decode__(this: void, input: unknown, context: Context<number>): Result<number, 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: number): 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: number, right: number): boolean

"Not equal to" operator

@example

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

＜

＜(this: void, left: number, right: number): 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: number, right: number): 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: number, right: number): boolean

"Equal to" operator

@example

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

＞

＞(this: void, left: number, right: number): 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: number, right: number): 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: number, minValue: number, maxValue: number): number

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: number, right: number): 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: number, right: number): 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: number, right: number): number

"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: number, right: number): number

"minimum" operator

@example

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

Formatting

asString

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

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

Numeric

*

*(left: number, right: number): number

Multiplication operator

@example

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

+

+(left: number, right: number): number

Addition operator

@example

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

-

-(left: number, right: number): number

Subtraction operator

@example

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

/?

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

Division operator

@example

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

abs

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

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: number): boolean

Returns true if the number is negative and false if the number is zero or positive.

isPositive

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

Returns true if the number is positive and false if the number is zero or negative.

isZero

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

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

negate

negate(self: number): number

Negates the given value.

@example

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

sign

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

Sign of a number. It should satisfy TSigned['*'](TSigned.abs(x), TSigned.sign(x)) == x

zero

zero(this: void): number

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

Type

inspect

__inspect__: Option<(anyValue: number, 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(anyValue: unknown): Option<number>

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(anyValue: unknown): anyValue is number

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

Other

typeName

Re-exports typeName

format

format(numberValue: number, radix?: Radix36): string

Return string representation of number
@example
Number.format(1.1);// '1.1'

parse

parse(expression: string): Option<number>

Parses a string argument and returns an number If the expression is not valid, it returns Option.None
@example
Number.parse('1');// Option.Some(1) Number.parse('invalid');// Option.None

Index

Bound

Codec

Comparator

Formatting

Numeric

Type

Other

Bound

readonlymaxValue

readonlyminValue

Codec

__decode__

__encode__

__schema__

Comparator

!=

＜

＜=

==

＞

＞=

clamp

compare

equals

max

min

Formatting

asString

Numeric

*

+

-

/?

abs

isNegative

isPositive

isZero

negate

sign

zero

Type

__inspect__

asInstance

hasInstance

Other

typeName

format

parse

decode

encode

schema

inspect