Numbers

Natural numbers

The Nat type represents natural numbers, which are all non-negative integers (i.e., 0 and positive numbers).

let n : Nat = 42;
let zero : Nat = 0;

Defining a Nat with a negative value is a compile time error:

let negative : Nat = -1; // Error: Cannot assign a negative value to Nat

Unbounded natural numbers

Like Int, the Nat type is unbounded by default, allowing extremely large values without overflow.

let hugeNat : Nat = 1_000_000_000_000_000;

Bounded natural numbers

Motoko also provides bounded natural number types.

Nat8 (8-bit unsigned integer, range: 0 to 255)
Nat16 (16-bit unsigned integer, range: 0 to 65,535)
Nat32 (32-bit unsigned integer, range: 0 to 4,294,967,295)
Nat64 (64-bit unsigned integer, range: 0 to 18,446,744,073,709,551,615)

Bounded Nat types are ideal when working with binary protocols, embedded systems, or hardware where size constraints matter.

let trappingNat8 : Nat8 = 255+1; // trap: arithmetic overflow

Integers

Int represents all integers, both positive and negative (e.g., -2, -1, 0, 1, 2).

For scenarios requiring fixed-size integers, Motoko offers bounded variants with specific bit-widths (Int8, Int16, Int32, Int64). These types can overflow if their limits are exceeded, resulting in a runtime error.

let a : Int = -42;
let b : Int = 0;
let c : Int = 12345;

Unbounded integers

The Int is unbounded, meaning its values can grow as large (or as small) as needed without causing over- or underflow.

let bigNumber : Int = 999_999_999_999_999;

Bounded integers

Int8 (8-bit signed integer)
Int16 (16-bit signed integer)
Int32 (32-bit signed integer)
Int64 (64-bit signed integer)

Arithmetic on bounded integers can overflow if their limits are exceeded, resulting in a runtime error.

let trappingInt8 : Int8 = 127+1; // trap: arithmetic overflow

Comparing `Int` and `Nat`

Feature	`Int`	`Nat`
Values supported	Positive & negative	Only non-negative
Default behavior	Unbounded	Unbounded
Bounded variants	`Int8`, `Int16`, `Int32`…	`Nat8`, `Nat16`, `Nat32`…
Overflow possibility	Yes (for bounded types)	Yes (for bounded types)

Floats

Floating-point numbers in Motoko are represented using the Float type, which corresponds to a 64-bit double-precision floating-point number in IEEE 754 representation.

let pi : Float = 3.14159;
let exp : Float = 2.71828;
let goldenRatio = 1.61803;