The compiler depends on the System module to work properly and the System module depends on the compiler. Most of the routines listed here use special compiler magic.

Each module implicitly imports the System module; it must not be listed explicitly. Because of this there cannot be a user-defined module named system.

System module

The System module imports several separate modules, and their documentation is in separate files:

Here is a short overview of the most commonly used functions from the system module. Function names in the tables below are clickable and will take you to the full documentation of the function.

The amount of available functions is much larger. Use the table of contents on the left-hand side and/or Ctrl+F to navigate through this module.

Strings and characters

Proc	Usage
len(s)	Return the length of a string
chr(i)	Convert an `int` in the range `0..255` to a character
ord(c)	Return `int` value of a character
a & b	Concatenate two strings
s.add(c)	Add character to the string
$	Convert various types to string

See also:

strutils module for common string functions
strformat module for string interpolation and formatting
unicode module for Unicode UTF-8 handling
strscans for scanf and scanp macros, which offer easier substring extraction than regular expressions
strtabs module for efficient hash tables (dictionaries, in some programming languages) mapping from strings to strings

Seqs

Proc	Usage
newSeq	Create a new sequence of a given length
newSeqOfCap	Create a new sequence with zero length and a given capacity
setLen	Set the length of a sequence
len	Return the length of a sequence
@	Turn an array into a sequence
add	Add an item to the sequence
insert	Insert an item at a specific position
delete	Delete an item while preserving the order of elements (`O(n)` operation)
del	`O(1)` removal, doesn't preserve the order
pop	Remove and return last item of a sequence
x & y	Concatenate two sequences
x[a .. b]	Slice of a sequence (both ends included)
x[a .. ^b]	Slice of a sequence but `b` is a reversed index (both ends included)
x[a ..< b]	Slice of a sequence (excluded upper bound)

See also:

sequtils module for operations on container types (including strings)
json module for a structure which allows heterogeneous members
lists module for linked lists

Sets

Built-in bit sets.

Proc	Usage
incl	Include element `y` in the set `x`
excl	Exclude element `y` from the set `x`
card	Return the cardinality of the set, i.e. the number of elements
a * b	Intersection
a + b	Union
a - b	Difference
contains	Check if an element is in the set
a < b	Check if `a` is a subset of `b`

See also:

sets module for hash sets
intsets module for efficient int sets

Numbers

Proc	Usage	Also known as (in other languages)
div	Integer division	`//`
mod	Integer modulo (remainder)	`%`
shl	Shift left	`<<`
shr	Shift right	`>>`
ashr	Arithmetic shift right
and	Bitwise `and`	`&`
or	Bitwise `or`	`\|`
xor	Bitwise `xor`	`^`
not	Bitwise `not` (complement)	`~`
toInt	Convert floating-point number into an `int`
toFloat	Convert an integer into a `float`

See also:

math module for mathematical operations like trigonometric functions, logarithms, square and cubic roots, etc.
complex module for operations on complex numbers
rationals module for rational numbers

Ordinals

Ordinal type includes integer, bool, character, and enumeration types, as well as their subtypes.

Proc	Usage
succ	Successor of the value
pred	Predecessor of the value
inc	Increment the ordinal
dec	Decrement the ordinal
high	Return the highest possible value
low	Return the lowest possible value
ord	Return `int` value of an ordinal value

Misc

Proc	Usage
is	Check if two arguments are of the same type
isnot	Negated version of `is`
!=	Not equals
addr	Take the address of a memory location
T and F	Boolean `and`
T or F	Boolean `or`
T xor F	Boolean `xor` (exclusive or)
not T	Boolean `not`
a[^x]	Take the element at the reversed index `x`
a .. b	Binary slice that constructs an interval `[a, b]`
a ..^ b	Interval `[a, b]` but `b` as reversed index
a ..< b	Interval `[a, b)` (excluded upper bound)
runnableExamples	Create testable documentation

Imports

since, ansi_c, memory, assertions, iterators, dollars, miscdollars, stacktraces, formatfloat, widestrs, io

Types

float {...}{.magic: Float.}

Default floating point type. Source Edit

float32 {...}{.magic: Float32.}

32 bit floating point type. Source Edit

float64 {...}{.magic: Float.}

64 bit floating point type. Source Edit

char {...}{.magic: Char.}

Built-in 8 bit character type (unsigned). Source Edit

string {...}{.magic: String.}

Built-in string type. Source Edit

cstring {...}{.magic: Cstring.}

Built-in cstring (compatible string) type. Source Edit

pointer {...}{.magic: Pointer.}

Built-in pointer type, use the addr operator to get a pointer to a variable. Source Edit

typedesc {...}{.magic: TypeDesc.}

Meta type to denote a type description. Source Edit

ptr[T] {...}{.magic: Pointer.}

Built-in generic untraced pointer type. Source Edit

ref[T] {...}{.magic: Pointer.}

Built-in generic traced pointer type. Source Edit

void {...}{.magic: "VoidType".}

Meta type to denote the absence of any type. Source Edit

auto {...}{.magic: Expr.}

Meta type for automatic type determination. Source Edit

any = distinct auto

Meta type for any supported type. Source Edit

untyped {...}{.magic: Expr.}

Meta type to denote an expression that is not resolved (for templates). Source Edit

typed {...}{.magic: Stmt.}

Meta type to denote an expression that is resolved (for templates). Source Edit

int {...}{.magic: "Int".}

Default integer type; bitwidth depends on architecture, but is always the same as a pointer. Source Edit

int8 {...}{.magic: "Int8".}

Signed 8 bit integer type. Source Edit

int16 {...}{.magic: "Int16".}

Signed 16 bit integer type. Source Edit

int32 {...}{.magic: "Int32".}

Signed 32 bit integer type. Source Edit

int64 {...}{.magic: "Int64".}

Signed 64 bit integer type. Source Edit

uint {...}{.magic: "UInt".}

Unsigned default integer type. Source Edit

uint8 {...}{.magic: "UInt8".}

Unsigned 8 bit integer type. Source Edit

uint16 {...}{.magic: "UInt16".}

Unsigned 16 bit integer type. Source Edit

uint32 {...}{.magic: "UInt32".}

Unsigned 32 bit integer type. Source Edit

uint64 {...}{.magic: "UInt64".}

Unsigned 64 bit integer type. Source Edit

bool {...}{.magic: "Bool".} = enum false = 0, true = 1

Built-in boolean type. Source Edit

SomeSignedInt = int | int8 | int16 | int32 | int64

Type class matching all signed integer types. Source Edit

SomeUnsignedInt = uint | uint8 | uint16 | uint32 | uint64

Type class matching all unsigned integer types. Source Edit

SomeInteger = SomeSignedInt | SomeUnsignedInt

Type class matching all integer types. Source Edit

Type class matching all ordinal types; however this includes enums with holes. See also Ordinal Source Edit

BiggestInt = int64

is an alias for the biggest signed integer type the Nim compiler supports. Currently this is int64, but it is platform-dependent in general. Source Edit

SomeFloat = float | float32 | float64

Type class matching all floating point number types. Source Edit

SomeNumber = SomeInteger | SomeFloat

Type class matching all number types. Source Edit

Ordinal[T] {...}{.magic: Ordinal.}

Generic ordinal type. Includes integer, bool, character, and enumeration types as well as their subtypes. See also SomeOrdinal. Source Edit

static[T] {...}{.magic: "Static".}

Meta type representing all values that can be evaluated at compile-time.

The type coercion static(x) can be used to force the compile-time evaluation of the given expression x.