# Int

Signed integer numbers with infinite precision (also called big integers).

Most operations on integer numbers (e.g. addition) are available as built-in operators (e.g. `-1 + 1`

).
This module provides equivalent functions and `Text`

conversion.

Import from the base library to use this module.

`import Int "mo:base/Int";`

## Type `Int`

`type Int = Prim.Types.Int`

Infinite precision signed integers.

## Function `abs`

`func abs(x : Int) : Nat`

Returns the absolute value of `x`

.

Example:

`Int.abs(-12) // => 12`

## Function `toText`

`func toText(x : Int) : Text`

Converts an integer number to its textual representation. Textual
representation *do not* contain underscores to represent commas.

Example:

`Int.toText(-1234) // => "-1234"`

## Function `min`

`func min(x : Int, y : Int) : Int`

Returns the minimum of `x`

and `y`

.

Example:

`Int.min(2, -3) // => -3`

## Function `max`

`func max(x : Int, y : Int) : Int`

Returns the maximum of `x`

and `y`

.

Example:

`Int.max(2, -3) // => 2`

## Function `hash`

`func hash(i : Int) : Hash.Hash`

Computes a hash from the least significant 32-bits of `i`

, ignoring other bits.
@deprecated For large `Int`

values consider using a bespoke hash function that considers all of the argument's bits.

## Function `hashAcc`

`func hashAcc(h1 : Hash.Hash, i : Int) : Hash.Hash`

Computes an accumulated hash from `h1`

and the least significant 32-bits of `i`

, ignoring other bits in `i`

.
@deprecated For large `Int`

values consider using a bespoke hash function that considers all of the argument's bits.

## Function `equal`

`func equal(x : Int, y : Int) : Bool`

Equality function for Int types.
This is equivalent to `x == y`

.

Example:

`Int.equal(-1, -1); // => true`

Note: The reason why this function is defined in this library (in addition
to the existing `==`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `==`

as a function value at the moment.

Example:

`import Buffer "mo:base/Buffer";`

let buffer1 = Buffer.Buffer<Int>(1);

buffer1.add(-3);

let buffer2 = Buffer.Buffer<Int>(1);

buffer2.add(-3);

Buffer.equal(buffer1, buffer2, Int.equal) // => true

## Function `notEqual`

`func notEqual(x : Int, y : Int) : Bool`

Inequality function for Int types.
This is equivalent to `x != y`

.

Example:

`Int.notEqual(-1, -2); // => true`

Note: The reason why this function is defined in this library (in addition
to the existing `!=`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `!=`

as a function value at the moment.

## Function `less`

`func less(x : Int, y : Int) : Bool`

"Less than" function for Int types.
This is equivalent to `x < y`

.

Example:

`Int.less(-2, 1); // => true`

Note: The reason why this function is defined in this library (in addition
to the existing `<`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `<`

as a function value at the moment.

## Function `lessOrEqual`

`func lessOrEqual(x : Int, y : Int) : Bool`

"Less than or equal" function for Int types.
This is equivalent to `x <= y`

.

Example:

`Int.lessOrEqual(-2, 1); // => true`

Note: The reason why this function is defined in this library (in addition
to the existing `<=`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `<=`

as a function value at the moment.

## Function `greater`

`func greater(x : Int, y : Int) : Bool`

"Greater than" function for Int types.
This is equivalent to `x > y`

.

Example:

`Int.greater(1, -2); // => true`

Note: The reason why this function is defined in this library (in addition
to the existing `>`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `>`

as a function value at the moment.

## Function `greaterOrEqual`

`func greaterOrEqual(x : Int, y : Int) : Bool`

"Greater than or equal" function for Int types.
This is equivalent to `x >= y`

.

Example:

`Int.greaterOrEqual(1, -2); // => true`

Note: The reason why this function is defined in this library (in addition
to the existing `>=`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `>=`

as a function value at the moment.

## Function `compare`

`func compare(x : Int, y : Int) : {#less; #equal; #greater}`

General-purpose comparison function for `Int`

. Returns the `Order`

(
either `#less`

, `#equal`

, or `#greater`

) of comparing `x`

with `y`

.

Example:

`Int.compare(-3, 2) // => #less`

This function can be used as value for a high order function, such as a sort function.

Example:

`import Array "mo:base/Array";`

Array.sort([1, -2, -3], Int.compare) // => [-3, -2, 1]

## Function `neg`

`func neg(x : Int) : Int`

Returns the negation of `x`

, `-x`

.

Example:

`Int.neg(123) // => -123`

Note: The reason why this function is defined in this library (in addition
to the existing `-`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `-`

as a function value at the moment.

## Function `add`

`func add(x : Int, y : Int) : Int`

Returns the sum of `x`

and `y`

, `x + y`

.

No overflow since `Int`

has infinite precision.

Example:

`Int.add(1, -2); // => -1`

Note: The reason why this function is defined in this library (in addition
to the existing `+`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `+`

as a function value at the moment.

Example:

`import Array "mo:base/Array";`

Array.foldLeft([1, -2, -3], 0, Int.add) // => -4

## Function `sub`

`func sub(x : Int, y : Int) : Int`

Returns the difference of `x`

and `y`

, `x - y`

.

No overflow since `Int`

has infinite precision.

Example:

`Int.sub(1, 2); // => -1`

Note: The reason why this function is defined in this library (in addition
to the existing `-`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `-`

as a function value at the moment.

Example:

`import Array "mo:base/Array";`

Array.foldLeft([1, -2, -3], 0, Int.sub) // => 4

## Function `mul`

`func mul(x : Int, y : Int) : Int`

Returns the product of `x`

and `y`

, `x * y`

.

No overflow since `Int`

has infinite precision.

Example:

`Int.mul(-2, 3); // => -6`

Note: The reason why this function is defined in this library (in addition
to the existing `*`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `*`

as a function value at the moment.

Example:

`import Array "mo:base/Array";`

Array.foldLeft([1, -2, -3], 1, Int.mul) // => 6

## Function `div`

`func div(x : Int, y : Int) : Int`

Returns the signed integer division of `x`

by `y`

, `x / y`

.
Rounds the quotient towards zero, which is the same as truncating the decimal places of the quotient.

Traps when `y`

is zero.

Example:

`Int.div(6, -2); // => -3`

Note: The reason why this function is defined in this library (in addition
to the existing `/`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `/`

as a function value at the moment.

## Function `rem`

`func rem(x : Int, y : Int) : Int`

Returns the remainder of the signed integer division of `x`

by `y`

, `x % y`

,
which is defined as `x - x / y * y`

.

Traps when `y`

is zero.

Example:

`Int.rem(6, -4); // => 2`

Note: The reason why this function is defined in this library (in addition
to the existing `%`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `%`

as a function value at the moment.

## Function `pow`

`func pow(x : Int, y : Int) : Int`

Returns `x`

to the power of `y`

, `x ** y`

.

Traps when `y`

is negative or `y > 2 ** 32 - 1`

.
No overflow since `Int`

has infinite precision.

Example:

`Int.pow(-2, 3); // => -8`

Note: The reason why this function is defined in this library (in addition
to the existing `**`

operator) is so that you can use it as a function
value to pass to a higher order function. It is not possible to use `**`

as a function value at the moment.