.. default-role:: code
.. include:: ../doc/rstcommon.rst

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

* `iterators <iterators.html>`_
* `exceptions <exceptions.html>`_
* `assertions <assertions.html>`_
* `dollars <dollars.html>`_
* `ctypes <ctypes.html>`_


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.

There are many more functions available than the ones listed in this overview.
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)<#len,string>`_            Return the length of a string
`chr(i)<#chr,range[]>`_           Convert an `int` in the range `0..255`
                                  to a character
`ord(c)<#ord,T>`_                 Return `int` value of a character
`a & b<#&,string,string>`_        Concatenate two strings
`s.add(c)<#add,string,char>`_     Add character to the string
`$<dollars.html>`_                Convert various types to string
=============================     =======================================

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



Seqs
----

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

**See also:**
* `sequtils module <sequtils.html>`_ for operations on container
  types (including strings)
* `json module <json.html>`_ for a structure which allows heterogeneous members
* `lists module <lists.html>`_ for linked lists



Sets
----

Built-in bit sets.

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

**See also:**
* `setutils module <setutils.html>`_ for bit set convenience functions
* `sets module <sets.html>`_ for hash sets
* `intsets module <intsets.html>`_ for efficient int sets



Numbers
-------

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

**See also:**
* `math module <math.html>`_ for mathematical operations like trigonometric
  functions, logarithms, square and cubic roots, etc.
* `complex module <complex.html>`_ for operations on complex numbers
* `rationals module <rationals.html>`_ for rational numbers



Ordinals
--------

`Ordinal type <#Ordinal>`_ includes integer, bool, character, and enumeration
types, as well as their subtypes.

=====================     =======================================
Proc                      Usage
=====================     =======================================
`succ<#succ,T,int>`_      Successor of the value
`pred<#pred,T,int>`_      Predecessor of the value
`inc<#inc,T,int>`_        Increment the ordinal
`dec<#dec,T,int>`_        Decrement the ordinal
`high<#high,T>`_          Return the highest possible value
`low<#low,T>`_            Return the lowest possible value
`ord<#ord,T>`_            Return `int` value of an ordinal value
=====================     =======================================



Misc
----

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