===================== Nim Tutorial (Part I) ===================== :Author: Andreas Rumpf :Version: |nimversion| .. contents:: Introduction ============ .. raw:: html

"Der Mensch ist doch ein Augentier -- schöne Dinge wünsch ich mir."

This document is a tutorial for the programming language *Nim*. This tutorial assumes that you are familiar with basic programming concepts like variables, types or statements but is kept very basic. The `manual `_ contains many more examples of the advanced language features. All code examples in this tutorial, as well as the ones found in the rest of Nim's documentation, follow the `Nim style guide `_. The first program ================= We start the tour with a modified "hello world" program: .. code-block:: Nim :test: "nim c $1" # This is a comment echo "What's your name? " var name: string = readLine(stdin) echo "Hi, ", name, "!" Save this code to the file "greetings.nim". Now compile and run it:: nim compile --run greetings.nim With the ``--run`` `switch `_ Nim executes the file automatically after compilation. You can give your program command line arguments by appending them after the filename:: nim compile --run greetings.nim arg1 arg2 Commonly used commands and switches have abbreviations, so you can also use:: nim c -r greetings.nim To compile a release version use:: nim c -d:release greetings.nim By default the Nim compiler generates a large amount of runtime checks aiming for your debugging pleasure. With ``-d:release`` these checks are `turned off and optimizations are turned on `_. Though it should be pretty obvious what the program does, I will explain the syntax: statements which are not indented are executed when the program starts. Indentation is Nim's way of grouping statements. Indentation is done with spaces only, tabulators are not allowed. String literals are enclosed in double quotes. The ``var`` statement declares a new variable named ``name`` of type ``string`` with the value that is returned by the `readLine `_ procedure. Since the compiler knows that `readLine `_ returns a string, you can leave out the type in the declaration (this is called `local type inference`:idx:). So this will work too: .. code-block:: Nim :test: "nim c $1" var name = readLine(stdin) Note that this is basically the only form of type inference that exists in Nim: it is a good compromise between brevity and readability. The "hello world" program contains several identifiers that are already known to the compiler: ``echo``, `readLine `_, etc. These built-ins are declared in the system_ module which is implicitly imported by any other module. Lexical elements ================ Let us look at Nim's lexical elements in more detail: like other programming languages Nim consists of (string) literals, identifiers, keywords, comments, operators, and other punctuation marks. String and character literals ----------------------------- String literals are enclosed in double quotes; character literals in single quotes. Special characters are escaped with ``\``: ``\n`` means newline, ``\t`` means tabulator, etc. There are also *raw* string literals: .. code-block:: Nim r"C:\program files\nim" In raw literals the backslash is not an escape character. The third and last way to write string literals are *long string literals*. They are written with three quotes: ``""" ... """``; they can span over multiple lines and the ``\`` is not an escape character either. They are very useful for embedding HTML code templates for example. Comments -------- Comments start anywhere outside a string or character literal with the hash character ``#``. Documentation comments start with ``##``: .. code-block:: nim :test: "nim c $1" # A comment. var myVariable: int ## a documentation comment Documentation comments are tokens; they are only allowed at certain places in the input file as they belong to the syntax tree! This feature enables simpler documentation generators. Multiline comments are started with ``#[`` and terminated with ``]#``. Multiline comments can also be nested. .. code-block:: nim :test: "nim c $1" #[ You can have any Nim code text commented out inside this with no indentation restrictions. yes("May I ask a pointless question?") #[ Note: these can be nested!! ]#

import os

proc findNodeJs*(): string =
  result = findExe("nodejs")
  if result == "":
    result = findExe("node")
  if result == "":
    result = findExe("iojs")

es 1, 2, .., 10. Each value is ``echo``-ed. This code does the same: .. code-block:: nim echo "Counting to 10: " var i = 1 while i <= 10: echo i inc(i) # increment i by 1 # --> Outputs 1 2 3 4 5 6 7 8 9 10 on different lines Counting down can be achieved as easily (but is less often needed): .. code-block:: nim echo "Counting down from 10 to 1: " for i in countdown(10, 1): echo i # --> Outputs 10 9 8 7 6 5 4 3 2 1 on different lines Since counting up occurs so often in programs, Nim also has a `.. `_ iterator that does the same: .. code-block:: nim for i in 1..10: ... Zero-indexed counting have two shortcuts ``..<`` and ``..^`` to simplify counting to one less than the higher index: .. code-block:: nim for i in 0..<10: ... # 0..9 or .. code-block:: nim var s = "some string" for i in 0.. a at index 0 # => b at index 1 Scopes and the block statement ------------------------------ Control flow statements have a feature not covered yet: they open a new scope. This means that in the following example, ``x`` is not accessible outside the loop: .. code-block:: nim :test: "nim c $1" :status: 1 while false: var x = "hi" echo x # does not work A while (for) statement introduces an implicit block. Identifiers are only visible within the block they have been declared. The ``block`` statement can be used to open a new block explicitly: .. code-block:: nim :test: "nim c $1" :status: 1 block myblock: var x = "hi" echo x # does not work either The block's *label* (``myblock`` in the example) is optional. Break statement --------------- A block can be left prematurely with a ``break`` statement. The break statement can leave a ``while``, ``for``, or a ``block`` statement. It leaves the innermost construct, unless a label of a block is given: .. code-block:: nim :test: "nim c $1" block myblock: echo "entering block" while true: echo "looping" break # leaves the loop, but not the block echo "still in block" block myblock2: echo "entering block" while true: echo "looping" break myblock2 # leaves the block (and the loop) echo "still in block" Continue statement ------------------ Like in many other programming languages, a ``continue`` statement starts the next iteration immediately: .. code-block:: nim :test: "nim c $1" while true: let x = readLine(stdin) if x == "": continue echo x When statement -------------- Example: .. code-block:: nim :test: "nim c $1" when system.hostOS == "windows": echo "running on Windows!" elif system.hostOS == "linux": echo "running on Linux!" elif system.hostOS == "macosx": echo "running on Mac OS X!" else: echo "unknown operating system" The ``when`` statement is almost identical to the ``if`` statement, but with these differences: * Each condition must be a constant expression since it is evaluated by the compiler. * The statements within a branch do not open a new scope. * The compiler checks the semantics and produces code *only* for the statements that belong to the first condition that evaluates to ``true``. The ``when`` statement is useful for writing platform specific code, similar to the ``#ifdef`` construct in the C programming language. Statements and indentation ========================== Now that we covered the basic control flow statements, let's return to Nim indentation rules. In Nim there is a distinction between *simple statements* and *complex statements*. *Simple statements* cannot contain other statements: Assignment, procedure calls or the ``return`` statement belong to the simple statements. *Complex statements* like ``if``, ``when``, ``for``, ``while`` can contain other statements. To avoid ambiguities, complex statements must always be indented, but single simple statements do not: .. code-block:: nim # no indentation needed for single assignment statement: if x: x = false # indentation needed for nested if statement: if x: if y: y = false else: y = true # indentation needed, because two statements follow the condition: if x: x = false y = false *Expressions* are parts of a statement which usually result in a value. The condition in an if statement is an example for an expression. Expressions can contain indentation at certain places for better readability: .. code-block:: nim if thisIsaLongCondition() and thisIsAnotherLongCondition(1, 2, 3, 4): x = true As a rule of thumb, indentation within expressions is allowed after operators, an open parenthesis and after commas. With parenthesis and semicolons ``(;)`` you can use statements where only an expression is allowed: .. code-block:: nim # computes fac(4) at compile time: :test: "nim c $1" const fac4 = (var x = 1; for i in 1..4: x *= i; x) Procedures ========== To define new commands like `echo `_ and `readLine `_ in the examples, the concept of a `procedure` is needed. (Some languages call them *methods* or *functions*.) In Nim new procedures are defined with the ``proc`` keyword: .. code-block:: nim :test: "nim c $1" proc yes(question: string): bool = echo question, " (y/n)" while true: case readLine(stdin) of "y", "Y", "yes", "Yes": return true of "n", "N", "no", "No": return false else: echo "Please be clear: yes or no" if yes("Should I delete all your important files?"): echo "I'm sorry Dave, I'm afraid I can't do that." else: echo "I think you know what the problem is just as well as I do." This example shows a procedure named ``yes`` that asks the user a ``question`` and returns true if they answered "yes" (or something similar) and returns false if they answered "no" (or something similar). A ``return`` statement leaves the procedure (and therefore the while loop) immediately. The ``(question: string): bool`` syntax describes that the procedure expects a parameter named ``question`` of type ``string`` and returns a value of type ``bool``. The ``bool`` type is built-in: the only valid values for ``bool`` are ``true`` and ``false``. The conditions in if or while statements must be of type ``bool``. Some terminology: in the example ``question`` is called a (formal) *parameter*, ``"Should I..."`` is called an *argument* that is passed to this parameter. Result variable --------------- A procedure that returns a value has an implicit ``result`` variable declared that represents the return value. A ``return`` statement with no expression is a shorthand for ``return result``. The ``result`` value is always returned automatically at the end of a procedure if there is no ``return`` statement at the exit. .. code-block:: nim :test: "nim c $1" proc sumTillNegative(x: varargs[int]): int = for i in x: if i < 0: return result = result + i echo sumTillNegative() # echos 0 echo sumTillNegative(3, 4, 5) # echos 12 echo sumTillNegative(3, 4 , -1 , 6) # echos 7 The ``result`` variable is already implicitly declared at the start of the function, so declaring it again with 'var result', for example, would shadow it with a normal variable of the same name. The result variable is also already initialised with the type's default value. Note that referential data types will be ``nil`` at the start of the procedure, and thus may require manual initialisation. Parameters ---------- Parameters are constant in the procedure body. By default, their value cannot be changed because this allows the compiler to implement parameter passing in the most efficient way. If a mutable variable is needed inside the procedure, it has to be declared with ``var`` in the procedure body. Shadowing the parameter name is possible, and actually an idiom: .. code-block:: nim :test: "nim c $1" proc printSeq(s: seq, nprinted: int = -1) = var nprinted = if nprinted == -1: s.len else: min(nprinted, s.len) for i in 0 .. `_ operator in Nim.) The compiler chooses the most appropriate proc for the ``toString`` calls. How this overloading resolution algorithm works exactly is not discussed here (it will be specified in the manual soon). However, it does not lead to nasty surprises and is based on a quite simple unification algorithm. Ambiguous calls are reported as errors. Operators --------- The Nim library makes heavy use of overloading - one reason for this is that each operator like ``+`` is just an overloaded proc. The parser lets you use operators in `infix notation` (``a + b``) or `prefix notation` (``+ a``). An infix operator always receives two arguments, a prefix operator always one. (Postfix operators are not possible, because this would be ambiguous: does ``a @ @ b`` mean ``(a) @ (@b)`` or ``(a@) @ (b)``? It always means ``(a) @ (@b)``, because there are no postfix operators in Nim.) Apart from a few built-in keyword operators such as ``and``, ``or``, ``not``, operators always consist of these characters: ``+ - * \ / < > = @ $ ~ & % ! ? ^ . |`` User defined operators are allowed. Nothing stops you from defining your own ``@!?+~`` operator, but doing so may reduce readability. The operator's precedence is determined by its first character. The details can be found in the manual. To define a new operator enclose the operator in backticks "``": .. code-block:: nim proc `$` (x: myDataType): string = ... # now the $ operator also works with myDataType, overloading resolution # ensures that $ works for built-in types just like before The "``" notation can also be used to call an operator just like any other procedure: .. code-block:: nim :test: "nim c $1" if `==`( `+`(3, 4), 7): echo "True" Forward declarations -------------------- Every variable, procedure, etc. needs to be declared before it can be used. (The reason for this is that it is non-trivial to avoid this need in a language that supports meta programming as extensively as Nim does.) However, this cannot be done for mutually recursive procedures: .. code-block:: nim # forward declaration: proc even(n: int): bool .. code-block:: nim proc odd(n: int): bool = assert(n >= 0) # makes sure we don't run into negative recursion if n == 0: false else: n == 1 or even(n-1) proc even(n: int): bool = assert(n >= 0) # makes sure we don't run into negative recursion if n == 1: false else: n == 0 or odd(n-1) Here ``odd`` depends on ``even`` and vice versa. Thus ``even`` needs to be introduced to the compiler before it is completely defined. The syntax for such a forward declaration is simple: just omit the ``=`` and the procedure's body. The ``assert`` just adds border conditions, and will be covered later in `Modules`_ section. Later versions of the language will weaken the requirements for forward declarations. The example also shows that a proc's body can consist of a single expression whose value is then returned implicitly. Iterators ========= Let's return to the simple counting example: .. code-block:: nim :test: "nim c $1" echo "Counting to ten: " for i in countup(1, 10): echo i Can a `countup `_ proc be written that supports this loop? Lets try: .. code-block:: nim proc countup(a, b: int): int = var res = a while res <= b: return res inc(res) However, this does not work. The problem is that the procedure should not only ``return``, but return and **continue** after an iteration has finished. This *return and continue* is called a `yield` statement. Now the only thing left to do is to replace the ``proc`` keyword by ``iterator`` and here it is - our first iterator: .. code-block:: nim :test: "nim c $1" iterator countup(a, b: int): int = var res = a while res <= b: yield res inc(res) Iterators look very similar to procedures, but there are several important differences: * Iterators can only be called from for loops. * Iterators cannot contain a ``return`` statement (and procs cannot contain a ``yield`` statement). * Iterators have no implicit ``result`` variable. * Iterators do not support recursion. * Iterators cannot be forward declared, because the compiler must be able to inline an iterator. (This restriction will be gone in a future version of the compiler.) However, you can also use a ``closure`` iterator to get a different set of restrictions. See `first class iterators `_ for details. Iterators can have the same name and parameters as a proc, since essentially they have their own namespaces. Therefore it is common practice to wrap iterators in procs of the same name which accumulate the result of the iterator and return it as a sequence, like ``split`` from the `strutils module `_. Basic types =========== This section deals with the basic built-in types and the operations that are available for them in detail. Booleans -------- Nim's boolean type is called ``bool`` and consists of the two pre-defined values ``true`` and ``false``. Conditions in while, if, elif, and when statements must be of type bool. The operators ``not, and, or, xor, <, <=, >, >=, !=, ==`` are defined for the bool type. The ``and`` and ``or`` operators perform short-circuit evaluation. For example: .. code-block:: nim while p != nil and p.name != "xyz": # p.name is not evaluated if p == nil p = p.next Characters ---------- The `character type` is called ``char``. Its size is always one byte, so it cannot represent most UTF-8 characters; but it *can* represent one of the bytes that makes up a multi-byte UTF-8 character. The reason for this is efficiency: for the overwhelming majority of use-cases, the resulting programs will still handle UTF-8 properly as UTF-8 was specially designed for this. Character literals are enclosed in single quotes. Chars can be compared with the ``==``, ``<``, ``<=``, ``>``, ``>=`` operators. The ``$`` operator converts a ``char`` to a ``string``. Chars cannot be mixed with integers; to get the ordinal value of a ``char`` use the ``ord`` proc. Converting from an integer to a ``char`` is done with the ``chr`` proc. Strings ------- String variables are **mutable**, so appending to a string is possible, and quite efficient. Strings in Nim are both zero-terminated and have a length field. A string's length can be retrieved with the builtin ``len`` procedure; the length never counts the terminating zero. Accessing the terminating zero is not an error and often leads to simpler code: .. code-block:: nim if s[i] == 'a' and s[i+1] == 'b': # no need to check whether ``i < len(s)``! ... The assignment operator for strings copies the string. You can use the ``&`` operator to concatenate strings and ``add`` to append to a string. Strings are compared using their lexicographical order. All the comparison operators are supported. By convention, all strings are UTF-8 encoded, but this is not enforced. For example, when reading strings from binary files, they are merely a sequence of bytes. The index operation ``s[i]`` means the i-th *char* of ``s``, not the i-th *unichar*. String variables are initialized with a special value, called ``nil``. However, most string operations cannot deal with ``nil`` (leading to an exception being raised) for performance reasons. It is best to use empty strings ``""`` rather than ``nil`` as the *empty* value. But ``""`` often creates a string object on the heap, so there is a trade-off to be made here. Integers -------- Nim has these integer types built-in: ``int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64``. The default integer type is ``int``. Integer literals can have a *type suffix* to specify a non-default integer type: .. code-block:: nim :test: "nim c $1" let x = 0 # x is of type ``int`` y = 0'i8 # y is of type ``int8`` z = 0'i64 # z is of type ``int64`` u = 0'u # u is of type ``uint`` Most often integers are used for counting objects that reside in memory, so ``int`` has the same size as a pointer. The common operators ``+ - * div mod < <= == != > >=`` are defined for integers. The ``and or xor not`` operators are also defined for integers, and provide *bitwise* operations. Left bit shifting is done with the ``shl``, right shifting with the ``shr`` operator. Bit shifting operators always treat their arguments as *unsigned*. For `arithmetic bit shifts`:idx: ordinary multiplication or division can be used. Unsigned operations all wrap around; they cannot lead to over- or under-flow errors. Lossless `Automatic type conversion`:idx: is performed in expressions where different kinds of integer types are used. However, if the type conversion would cause loss of information, the `EOutOfRange`:idx: exception is raised (if the error cannot be detected at compile time). Floats ------ Nim has these floating point types built-in: ``float float32 float64``. The default float type is ``float``. In the current implementation, ``float`` is always 64-bits. Float literals can have a *type suffix* to specify a non-default float type: .. code-block:: nim :test: "nim c $1" var x = 0.0 # x is of type ``float`` y = 0.0'f32 # y is of type ``float32`` z = 0.0'f64 # z is of type ``float64`` The common operators ``+ - * / < <= == != > >=`` are defined for floats and follow the IEEE-754 standard. Automatic type conversion in expressions with different kinds of floating point types is performed: the smaller type is converted to the larger. Integer types are **not** converted to floating point types automatically, nor vice versa. Use the `toInt `_ and `toFloat `_ procs for these conversions. Type Conversion --------------- Conversion between basic types is performed by using the type as a function: .. code-block:: nim :test: "nim c $1" var x: int32 = 1.int32 # same as calling int32(1) y: int8 = int8('a') # 'a' == 97'i8 z: float = 2.5 # int(2.5) rounds down to 2 sum: int = int(x) + int(y) + int(z) # sum == 100 Internal type representation ============================ As mentioned earlier, the built-in `$ `_ (stringify) operator turns any basic type into a string, which you can then print to the console using the ``echo`` proc. However, advanced types, and your own custom types, won't work with the ``$`` operator until you define it for them. Sometimes you just want to debug the current value of a complex type without having to write its ``$`` operator. You can use then the `repr `_ proc which works with any type and even complex data graphs with cycles. The following example shows that even for basic types there is a difference between the ``$`` and ``repr`` outputs: .. code-block:: nim :test: "nim c $1" var myBool = true myCharacter = 'n' myString = "nim" myInteger = 42 myFloat = 3.14 echo myBool, ":", repr(myBool) # --> true:true echo myCharacter, ":", repr(myCharacter) # --> n:'n' echo myString, ":", repr(myString) # --> nim:0x10fa8c050"nim" echo myInteger, ":", repr(myInteger) # --> 42:42 echo myFloat, ":", repr(myFloat) # --> 3.1400000000000001e+00:3.1400000000000001e+00 Advanced types ============== In Nim new types can be defined within a ``type`` statement: .. code-block:: nim :test: "nim c $1" type biggestInt = int64 # biggest integer type that is available biggestFloat = float64 # biggest float type that is available Enumeration and object types may only be defined within a ``type`` statement. Enumerations ------------ A variable of an enumeration type can only be assigned one of the enumeration's specified values. These values are a set of ordered symbols. Each symbol is mapped to an integer value internally. The first symbol is represented at runtime by 0, the second by 1 and so on. For example: .. code-block:: nim :test: "nim c $1" type Direction = enum north, east, south, west var x = south # `x` is of type `Direction`; its value is `south` echo x # writes "south" to `stdout` All the comparison operators can be used with enumeration types. An enumeration's symbol can be qualified to avoid ambiguities: ``Direction.south``. The ``$`` operator can convert any enumeration value to its name, and the ``ord`` proc can convert it to its underlying integer value. For better interfacing to other programming languages, the symbols of enum types can be assigned an explicit ordinal value. However, the ordinal values must be in ascending order. A symbol whose ordinal value is not explicitly given is assigned the value of the previous symbol + 1. An explicit ordered enum can have *holes*: .. code-block:: nim :test: "nim c $1" type MyEnum = enum a = 2, b = 4, c = 89 Ordinal types ------------- Enumerations without holes, integer types, ``char`` and ``bool`` (and subranges) are called ordinal types. Ordinal types have quite a few special operations: ----------------- -------------------------------------------------------- Operation Comment ----------------- -------------------------------------------------------- ``ord(x)`` returns the integer value that is used to represent `x`'s value ``inc(x)`` increments `x` by one ``inc(x, n)`` increments `x` by `n`; `n` is an integer ``dec(x)`` decrements `x` by one ``dec(x, n)`` decrements `x` by `n`; `n` is an integer ``succ(x)`` returns the successor of `x` ``succ(x, n)`` returns the `n`'th successor of `x` ``pred(x)`` returns the predecessor of `x` ``pred(x, n)`` returns the `n`'th predecessor of `x` ----------------- -------------------------------------------------------- The `inc `_, `dec `_, `succ `_ and `pred `_ operations can fail by raising an `EOutOfRange` or `EOverflow` exception. (If the code has been compiled with the proper runtime checks turned on.) Subranges --------- A subrange type is a range of values from an integer or enumeration type (the base type). Example: .. code-block:: nim :test: "nim c $1" type MySubrange = range[0..5] ``MySubrange`` is a subrange of ``int`` which can only hold the values 0 to 5. Assigning any other value to a variable of type ``MySubrange`` is a compile-time or runtime error. Assignments from the base type to one of its subrange types (and vice versa) are allowed. The ``system`` module defines the important `Natural `_ type as ``range[0..high(int)]`` (`high `_ returns the maximal value). Other programming languages may suggest the use of unsigned integers for natural numbers. This is often **unwise**: you don't want unsigned arithmetic (which wraps around) just because the numbers cannot be negative. Nim's ``Natural`` type helps to avoid this common programming error. Sets ---- .. include:: sets_fragment.txt Arrays ------ An array is a simple fixed length container. Each element in an array has the same type. The array's index type can be any ordinal type. Arrays can be constructed using ``[]``: .. code-block:: nim :test: "nim c $1" type IntArray = array[0..5, int] # an array that is indexed with 0..5 var x: IntArray x = [1, 2, 3, 4, 5, 6] for i in low(x)..high(x): echo x[i] The notation ``x[i]`` is used to access the i-th element of ``x``. Array access is always bounds checked (at compile-time or at runtime). These checks can be disabled via pragmas or invoking the compiler with the ``--bound_checks:off`` command line switch. Arrays are value types, like any other Nim type. The assignment operator copies the whole array contents. The built-in `len `_ proc returns the array's length. `low(a) `_ returns the lowest valid index for the array `a` and `high(a) `_ the highest valid index. .. code-block:: nim :test: "nim c $1" type Direction = enum north, east, south, west BlinkLights = enum off, on, slowBlink, mediumBlink, fastBlink LevelSetting = array[north..west, BlinkLights] var level: LevelSetting level[north] = on level[south] = slowBlink level[east] = fastBlink echo repr(level) # --> [on, fastBlink, slowBlink, off] echo low(level) # --> north echo len(level) # --> 4 echo high(level) # --> west The syntax for nested arrays (multidimensional) in other languages is a matter of appending more brackets because usually each dimension is restricted to the same index type as the others. In Nim you can have different dimensions with different index types, so the nesting syntax is slightly different. Building on the previous example where a level is defined as an array of enums indexed by yet another enum, we can add the following lines to add a light tower type subdivided in height levels accessed through their integer index: .. code-block:: nim type LightTower = array[1..10, LevelSetting] var tower: LightTower tower[1][north] = slowBlink tower[1][east] = mediumBlink echo len(tower) # --> 10 echo len(tower[1]) # --> 4 echo repr(tower) # --> [[slowBlink, mediumBlink, ...more output.. # The following lines don't compile due to type mismatch errors #tower[north][east] = on #tower[0][1] = on Note how the built-in ``len`` proc returns only the array's first dimension length. Another way of defining the ``LightTower`` to better illustrate its nested nature would be to omit the previous definition of the ``LevelSetting`` type and instead write it embedded directly as the type of the first dimension: .. code-block:: nim type LightTower = array[1..10, array[north..west, BlinkLights]] It is quite common to have arrays start at zero, so there's a shortcut syntax to specify a range from zero to the specified index minus one: .. code-block:: nim :test: "nim c $1" type IntArray = array[0..5, int] # an array that is indexed with 0..5 QuickArray = array[6, int] # an array that is indexed with 0..5 var x: IntArray y: QuickArray x = [1, 2, 3, 4, 5, 6] y = x for i in low(x)..high(x): echo x[i], y[i] Sequences --------- Sequences are similar to arrays but of dynamic length which may change during runtime (like strings). Since sequences are resizable they are always allocated on the heap and garbage collected. Sequences are always indexed with an ``int`` starting at position 0. The `len `_, `low `_ and `high `_ operations are available for sequences too. The notation ``x[i]`` can be used to access the i-th element of ``x``. Sequences can be constructed by the array constructor ``[]`` in conjunction with the array to sequence operator ``@``. Another way to allocate space for a sequence is to call the built-in `newSeq `_ procedure. A sequence may be passed to an openarray parameter. Example: .. code-block:: nim :test: "nim c $1" var x: seq[int] # a reference to a sequence of integers x = @[1, 2, 3, 4, 5, 6] # the @ turns the array into a sequence allocated on the heap Sequence variables are initialized with ``nil``. However, most sequence operations cannot deal with ``nil`` (leading to an exception being raised) for performance reasons. Thus one should use empty sequences ``@[]`` rather than ``nil`` as the *empty* value. But ``@[]`` creates a sequence object on the heap, so there is a trade-off to be made here. The ``for`` statement can be used with one or two variables when used with a sequence. When you use the one variable form, the variable will hold the value provided by the sequence. The ``for`` statement is looping over the results from the `items() `_ iterator from the `system `_ module. But if you use the two variable form, the first variable will hold the index position and the second variable will hold the value. Here the ``for`` statement is looping over the results from the `pairs() `_ iterator from the `system `_ module. Examples: .. code-block:: nim :test: "nim c $1" for value in @[3, 4, 5]: echo value # --> 3 # --> 4 # --> 5 for i, value in @[3, 4, 5]: echo "index: ", $i, ", value:", $value # --> index: 0, value:3 # --> index: 1, value:4 # --> index: 2, value:5 Open arrays ----------- **Note**: Openarrays can only be used for parameters. Often fixed size arrays turn out to be too inflexible; procedures should be able to deal with arrays of different sizes. The `openarray`:idx: type allows this. Openarrays are always indexed with an ``int`` starting at position 0. The `len `_, `low `_ and `high `_ operations are available for open arrays too. Any array with a compatible base type can be passed to an openarray parameter, the index type does not matter. .. code-block:: nim :test: "nim c $1" var fruits: seq[string] # reference to a sequence of strings that is initialized with 'nil' capitals: array[3, string] # array of strings with a fixed size fruits = @[] # creates an empty sequence on the heap that will be referenced by 'fruits' capitals = ["New York", "London", "Berlin"] # array 'capitals' allows assignment of only three elements fruits.add("Banana") # sequence 'fruits' is dynamically expandable during runtime fruits.add("Mango") proc openArraySize(oa: openArray[string]): int = oa.len assert openArraySize(fruits) == 2 # procedure accepts a sequence as parameter assert openArraySize(capitals) == 3 # but also an array type The openarray type cannot be nested: multidimensional openarrays are not supported because this is seldom needed and cannot be done efficiently. Varargs ------- A ``varargs`` parameter is like an openarray parameter. However, it is also a means to implement passing a variable number of arguments to a procedure. The compiler converts the list of arguments to an array automatically: .. code-block:: nim :test: "nim c $1" proc myWriteln(f: File, a: varargs[string]) = for s in items(a): write(f, s) write(f, "\n") myWriteln(stdout, "abc", "def", "xyz") # is transformed by the compiler to: myWriteln(stdout, ["abc", "def", "xyz"]) This transformation is only done if the varargs parameter is the last parameter in the procedure header. It is also possible to perform type conversions in this context: .. code-block:: nim :test: "nim c $1" proc myWriteln(f: File, a: varargs[string, `$`]) = for s in items(a): write(f, s) write(f, "\n") myWriteln(stdout, 123, "abc", 4.0) # is transformed by the compiler to: myWriteln(stdout, [$123, $"abc", $4.0]) In this example `$ `_ is applied to any argument that is passed to the parameter ``a``. Note that `$ `_ applied to strings is a nop. Slices ------ Slices look similar to subranges types in syntax but are used in a different context. A slice is just an object of type Slice which contains two bounds, `a` and `b`. By itself a slice is not very useful, but other collection types define operators which accept Slice objects to define ranges. .. code-block:: nim :test: "nim c $1" var a = "Nim is a progamming language" b = "Slices are useless." echo a[7..12] # --> 'a prog' b[11..^2] = "useful" echo b # --> 'Slices are useful.' In the previous example slices are used to modify a part of a string. The slice's bounds can hold any value supported by their type, but it is the proc using the slice object which defines what values are accepted. To understand some of the different ways of specifying the indices of strings, arrays, sequences, etc., it must be remembered that Nim uses zero-based indices. So the string ``b`` is of length 19, and two different ways of specifying the indices are .. code-block:: nim "Slices are useless." | | | 0 11 17 using indices ^19 ^8 ^2 using ^ syntax where ``b[0..^1]`` is equivalent to ``b[0..b.len-1]`` and ``b[0.. Error: type mismatch: got (tuple[street: string, number: int]) # but expected 'Person' # The following works because the field names and types are the same. var teacher: tuple[name: string, age: int] = ("Mark", 42) person = teacher Even though you don't need to declare a type for a tuple to use it, tuples created with different field names will be considered different objects despite having the same field types. Tuples can be *unpacked* during variable assignment (and only then!). This can be handy to assign directly the fields of the tuples to individually named variables. An example of this is the `splitFile `_ proc from the `os module `_ which returns the directory, name and extension of a path at the same time. For tuple unpacking to work you must use parentheses around the values you want to assign the unpacking to, otherwise you will be assigning the same value to all the individual variables! For example: .. code-block:: nim :test: "nim c $1" import os let path = "usr/local/nimc.html" (dir, name, ext) = splitFile(path) baddir, badname, badext = splitFile(path) echo dir # outputs `usr/local` echo name # outputs `nimc` echo ext # outputs `.html` # All the following output the same line: # `(dir: usr/local, name: nimc, ext: .html)` echo baddir echo badname echo badext Reference and pointer types --------------------------- References (similar to pointers in other programming languages) are a way to introduce many-to-one relationships. This means different references can point to and modify the same location in memory. Nim distinguishes between `traced`:idx: and `untraced`:idx: references. Untraced references are also called *pointers*. Traced references point to objects in a garbage collected heap, untraced references point to manually allocated objects or to objects elsewhere in memory. Thus untraced references are *unsafe*. However for certain low-level operations (e.g., accessing the hardware), untraced references are necessary. Traced references are declared with the **ref** keyword; untraced references are declared with the **ptr** keyword. The empty ``[]`` subscript notation can be used to *derefer* a reference, meaning to retrieve the item the reference points to. The ``.`` (access a tuple/object field operator) and ``[]`` (array/string/sequence index operator) operators perform implicit dereferencing operations for reference types: .. code-block:: nim :test: "nim c $1" type Node = ref object le, ri: Node data: int var n: Node new(n) n.data = 9 # no need to write n[].data; in fact n[].data is highly discouraged! To allocate a new traced object, the built-in procedure ``new`` must be used. To deal with untraced memory, the procedures ``alloc``, ``dealloc`` and ``realloc`` can be used. The `system `_ module's documentation contains further details. If a reference points to *nothing*, it has the value ``nil``. Procedural type --------------- A procedural type is a (somewhat abstract) pointer to a procedure. ``nil`` is an allowed value for a variable of a procedural type. Nim uses procedural types to achieve `functional`:idx: programming techniques. Example: .. code-block:: nim :test: "nim c $1" proc echoItem(x: int) = echo x proc forEach(action: proc (x: int)) = const data = [2, 3, 5, 7, 11] for d in items(data): action(d) forEach(echoItem) A subtle issue with procedural types is that the calling convention of the procedure influences the type compatibility: procedural types are only compatible if they have the same calling convention. The different calling conventions are listed in the `manual `_. Distinct type ------------- A Distinct type allows for the creation of new type that "does not imply a subtype relationship between it and its base type". You must **explicitly** define all behaviour for the distinct type. To help with this, both the distinct type and its base type can cast from one type to the other. Examples are provided in the `manual `_. Modules ======= Nim supports splitting a program into pieces with a module concept. Each module is in its own file. Modules enable `information hiding`:idx: and `separate compilation`:idx:. A module may gain access to the symbols of another module by using the `import`:idx: statement. Only top-level symbols that are marked with an asterisk (``*``) are exported: .. code-block:: nim # Module A var x*, y: int proc `*` *(a, b: seq[int]): seq[int] = # allocate a new sequence: newSeq(result, len(a)) # multiply two int sequences: for i in 0..len(a)-1: result[i] = a[i] * b[i] when isMainModule: # test the new ``*`` operator for sequences: assert(@[1, 2, 3] * @[1, 2, 3] == @[1, 4, 9]) The above module exports ``x`` and ``*``, but not ``y``. A module's top-level statements are executed at the start of the program. This can be used to initialize complex data structures for example. Each module has a special magic constant ``isMainModule`` that is true if the module is compiled as the main file. This is very useful to embed tests within the module as shown by the above example. A symbol of a module *can* be *qualified* with the ``module.symbol`` syntax. And if a symbol is ambiguous, it *must* be qualified. A symbol is ambiguous if it is defined in two (or more) different modules and both modules are imported by a third one: .. code-block:: nim # Module A var x*: string .. code-block:: nim # Module B var x*: int .. code-block:: nim # Module C import A, B write(stdout, x) # error: x is ambiguous write(stdout, A.x) # okay: qualifier used var x = 4 write(stdout, x) # not ambiguous: uses the module C's x But this rule does not apply to procedures or iterators. Here the overloading rules apply: .. code-block:: nim # Module A proc x*(a: int): string = $a .. code-block:: nim # Module B proc x*(a: string): string = $a .. code-block:: nim # Module C import A, B write(stdout, x(3)) # no error: A.x is called write(stdout, x("")) # no error: B.x is called proc x*(a: int): string = nil write(stdout, x(3)) # ambiguous: which `x` is to call? Excluding symbols ----------------- The normal ``import`` statement will bring in all exported symbols. These can be limited by naming symbols which should be excluded with the ``except`` qualifier. .. code-block:: nim import mymodule except y From statement -------------- We have already seen the simple ``import`` statement that just imports all exported symbols. An alternative that only imports listed symbols is the ``from import`` statement: .. code-block:: nim from mymodule import x, y, z The ``from`` statement can also force namespace qualification on symbols, thereby making symbols available, but needing to be qualified to be used. .. code-block:: nim from mymodule import x, y, z x() # use x without any qualification .. code-block:: nim from mymodule import nil mymodule.x() # must qualify x with the module name as prefix x() # using x here without qualification is a compile error Since module names are generally long to be descriptive, you can also define a shorter alias to use when qualifying symbols. .. code-block:: nim from mymodule as m import nil m.x() # m is aliasing mymodule Include statement ----------------- The ``include`` statement does something fundamentally different than importing a module: it merely includes the contents of a file. The ``include`` statement is useful to split up a large module into several files: .. code-block:: nim include fileA, fileB, fileC Part 2 ====== So, now that we are done with the basics, let's see what Nim offers apart from a nice syntax for procedural programming: `Part II `_ .. _strutils: strutils.html .. _system: system.html