Nim cheatsheet

# 'let' declares immutable variables.
let
  salute: string = "Hello!"
  x: int = 10
  y = x + 5

let z = 20
z = 500   # Error: 'z' is immutable

# This is a comment

#[
  This is a multiline comment.
  In Nim, multiline comments can be nested, beginning with #[
  ... and ending with ]#
]#

for item in (1 ..< 6):
  if item == 3: break
  echo item

echo "All done!"

See: Loops

import std/strutils
let number = parseInt(readLine(stdin))

if number <= 5:
  echo "Small sized number."
elif number > 5 and number <= 25:
  echo "Medium sized number."
else:
  echo "Big number."

See: Flow Control

proc myFunction() =
  echo "Hello, this is my function"

myFunction()

# prints "Hello, this is my function"

See: Procedures

import std/strformat

let
  a = "Hello there."
  b = "How's it going?"
  c = "These are variables."

echo fmt"{a} {b} {c}" # "Hello there. How's it going? These are variables."

See: Imports

let
  a = 11
  b = 4

echo "a + b = ", a + b # 15
echo "a - b = ", a - b # 7
echo "a * b = ", a * b # 44
echo "a / b = ", a / b # 2.75
echo "a div b = ", a div b # 2
echo "a mod b = ", a mod b # 3

let
  c = 6.75
  d = 2.25

echo "c + d = ", c + d # 9.0
echo "c - d = ", c - d # 4.5
echo "c * d = ", c * d # 15.1875
echo "c / d = ", c / d # 3.0

let
  h = 'z'
  i = '+'
  j = '2'
  k = '35'   # error: too many characters
  l = 'xy'   # error: too many characters

let x = true
let y = false

# Boolean literals are lowercase.

type IntArray = array[0..3, int]

let a: IntArray = [10, 20, 30, 40]

echo a[0]      # 10
echo a.len     # 4

var s: seq[int] = @[1, 2, 3]
s.add(4)

echo s         # @[1, 2, 3, 4]
echo s.len     # 4

type Person = object
  name: string
  age: int

let p = Person(name: "Ana", age: 20)
echo p.name

var person = (name: "Sophie", age: 18)

echo person.name # Sophie
echo person.age  # 18

# swapping values:
var (x, y) = (1, 2)
(x, y) = (y, x)
echo x, " ", y     # 2 1

type CharSet = set[char]

let letters: CharSet = {'a'..'z'}

echo 'a' in letters    # true
echo 'Z' in letters    # false

type Node = ref object
  value: int
  next: Node     # linked list style

var n = Node(value: 10)
echo n.value

Needed for Object Oriented Programming within Nim.

import std/tables

var ages = initTable[string, int]()
ages["Ana"] = 20
ages["Sophie"] = 18

echo ages["Ana"]                 # 20
echo ages.getOrDefault("X", -1)  # -1

for name, age in ages:
  echo name, ": ", age

These only work on mutable (var) variables, not on let or const.

var value = 1990
echo value # 1990

value = 2
echo value # 2

#Update operations

Other variants like /= or mod= are not available,
so just write them out explicitly, e.g. x = x / y.

var counter = 0

while counter <= 10:
  counter = counter + 1
  echo counter # prints 1..10

while true:
  echo "ay! "

while 1 > 0:
  echo "echo... "

var query = ""
while true:
  echo "Do you want out?"
  query = readLine(stdin)
  if query == "yes":
    echo "Well then."
    break
  else:
    echo "I'll ask again."

for i in 1..5:
  if i mod 2 == 0: continue
  echo i
# prints only odd numbers: 1 3 5

proc salute() =
  echo "Hello!"

salute() # prints "Hello!"

proc addition(a: int, b: int): int =
  a + b

echo addition(20, 30) # returns 50

proc divmod(a, b: int): (int, int) =
  (a div b, a mod b)

let (q, r) = divmod(10, 3)
echo q, " ", r   # 3 1

let square = proc(x: int): int = x * x
echo square(5) # 25

proc show(x: int) = echo "int: ", x
proc show(x: string) = echo "string: ", x

show(10)
show("hi")

proc doSomething(): int {.discardable.} =
  123

doSomething()      # allowed now

type
  Counter = ref object
    value: int

proc inc(c: var Counter) =
  inc c.value

var c = Counter(value: 0)
inc(c)
echo c.value  # 1

type
  Dog = ref object
    name: string
    age: int

proc newDog(name: string; age: int): Dog =
  Dog(name: name, age: age)

let d = newDog("Fido", 3)
echo d.name, " is ", d.age, " years old"

import std/math

echo sqrt(9.0) # 3.0

See also: Standard Library

import std/[strutils, sequtils]

echo "hi".toUpperAscii()    # "HI"
echo @[1,2,3].mapIt(it * 2) # @[2, 4, 6]

from std/strutils import toLowerAscii

echo toLowerAscii("ABC")  # "abc"

import std/random as rng

rng.randomize()

echo rng.rand(1..10) # anywhere from 1 to 10

Don't forget to use randomize() if you're using the std/random library, or else you won't have randomness.

proc run() =
  echo "Running..."

when isMainModule:
  run()  # Only runs when this file is the program entry point

Code inside when isMainModule: is skipped when the file is imported.

type
  MyError* = object of Exception

proc loadData(name: string) =
  if name == "":
    raise newException(MyError, "No name provided")
  # ... else proceed

loadData("")  # raises MyError

proc processFile(path: string) =
  var f = open(path, fmRead)
  defer:
    close(f)
  # work with f …

import std/strutils

let result = try: parseInt("bad")
             except ValueError: -1

echo result  # prints -1

proc riskyOperation() {.raises: [IOError].} =
  # this proc may raise IOError
  raise newException(IOError, "fail")

# A proc with {.raises: []} must not raise any catchable exception.

type
  Direction = enum
    north, east, south, west

var d = north

if d == north:
  echo "Going up!"

# with the same Direction enum:

var d = north

case d:
  of north: echo "N"
  of south: echo "S"
  of east:  echo "E"
  of west:  echo "W"

# with the same Direction enum:
echo ord(north)   # 0
echo succ(north)  # east
echo pred(south)  # east

for i in countup(1, 3):
  echo i               # 1 2 3

for i in countdown(3, 1):
  echo i               # 3 2 1

for line in lines("data.txt"):
  echo line

# Template = macro-like, expanded at compile time
template times2(x: untyped): untyped = (x) * 2
echo times2(21)  # 42