    # Nim Sample file
    # Obtained form: https://nim-by-example.github.io/

    # Comment ALERT NOTE FIXME
    #[ Multi-line
    comment ]#

    ## Documentation comment
    ##[ Multi-line
        documentation comment ]##

    import strformat

    type
        Person = object
            name: string
            age: Natural # Ensures the age is positive

    let people = [
        Person(name: "John", age: 45),
        Person(name: "Kate", age: 30)
    ]

    for person in people:
        # Type-safe string interpolation,
        # evaluated at compile time.
        echo(fmt"{person.name} is {person.age} years old")

    # Thanks to Nim's 'iterator' and 'yield' constructs,
    # iterators are as easy to write as ordinary
    # functions. They are compiled to inline loops.
    iterator oddNumbers[Idx, T](a: array[Idx, T]): T =
        for x in a:
            if x mod 2 == 1:
                yield x

    for odd in oddNumbers([3, 6, 9, 12, 15, 18]):
        echo odd

    # Use Nim's macro system to transform a dense
    # data-centric description of x86 instructions
    # into lookup tables that are used by
    # assemblers and JITs.
    import macros, strutils

    macro toLookupTable(data: static[string]): untyped =
        result = newTree(nnkBracket)
        for w in data.split(';'):
            result.add newLit(w)

    const
        data = "mov;btc;cli;xor"
        opcodes = toLookupTable(data)

    for o in opcodes:
        echo o

    # Variables
    proc getAlphabet(): string =
        var accm = ""
        for letter in 'a'..'z':  # see iterators
            accm.add(letter)
        return accm

    # Computed at compilation time
    const alphabet = getAlphabet()

    # Mutable variables
    var
        a = "foo"
        b = 0
        # Works fine, initialized to 0
        c: int

    # Immutable variables
    let
        d = "foo"
        e = 5
        # Compile-time error, must be initialized at creation
        f: float

    # Works fine, `a` is mutable
    a.add("bar")
    b += 1
    c = 3

    # Compile-time error, const cannot be modified at run-time
    alphabet = "abc"

    # Compile-time error, `d` and `e` are immutable
    d.add("bar")
    e += 1

    # Const
    STRING_LITERAL(TMP129, "abcdefghijklmnopqrstuvwxyz", 26);

    # Loops
    import strutils, random

    randomize()
    let answer = random(10) + 1
    while true:
        echo "I have a number from 1 to 10, what is it? "
        let guess = parseInt(stdin.readLine)

        if guess < answer:
            echo "Too low, try again"
        elif guess > answer:
            echo "Too high, try again"
        else:
            echo "Correct!"
            break

    block busyloops:
        while true:
            while true:
            break busyloops

    # Case Statements
    case "charlie":
        of "alfa":
            echo "A"
        of "bravo":
            echo "B"
        of "charlie":
            echo "C"
        else:
            echo "Unrecognized letter"

    case 'h':
        of 'a', 'e', 'i', 'o', 'u':
            echo "Vowel"
        of '\127'..'\255':
            echo "Unknown"
        else:
            echo "Consonant"

    proc positiveOrNegative(num: int): string =
        result = case num:
            of low(int).. -1:
                "negative"
            of 0:
                "zero"
            of 1..high(int):
                "positive"
            else:
                "impossible"

    echo positiveOrNegative(-1)

    # items and pairs
    type
        CustomRange = object
            low: int
            high: int

    iterator items(range: CustomRange): int =
        var i = range.low
        while i <= range.high:
            yield i
            inc i

    iterator pairs(range: CustomRange): tuple[a: int, b: char] =
        for i in range:  # uses CustomRange.items
            yield (i, char(i + ord('a')))

    for i, c in CustomRange(low: 1, high: 3):
        echo c

    # Operators
    iterator `...`*[T](a: T, b: T): T =
        var res: T = T(a)
        while res <= b:
            yield res
            inc res

    for i in 0...5:
        echo i

    # Inline Iterators
    iterator countTo(n: int): int =
        var i = 0
        while i <= n:
            yield i
            inc i

    for i in countTo(5):
        echo i

    # Closure Iterators
    proc countTo(n: int): iterator(): int =
        return iterator(): int =
            var i = 0
            while i <= n:
                yield i
                inc i

    let countTo20 = countTo(20)

    echo countTo20()

    var output = ""
    # Raw iterator usage:
    while true:
        # 1. grab an element
        let next = countTo20()
        # 2. Is the element bogus? It's the end of the loop, discard it
        if finished(countTo20):
            break
        # 3. Loop body goes here:
        output.add($next & " ")

    echo output

    output = ""
    let countTo9 = countTo(9)
    for i in countTo9():
        output.add($i)
    echo output

    # Procs
    proc fibonacci(n: int): int =
        if n < 2:
            result = n
        else:
            result = fibonacci(n - 1) + (n - 2).fibonacci

    # Operators
    proc `$`(a: array[2, array[2, int]]): string =
        result = ""
        for v in a:
            for vx in v:
                result.add($vx & ", ")
            result.add("\n")

    echo([[1, 2], [3, 4]])  # See varargs for
                            # how echo works

    proc `^&*^@%`(a, b: string): string =
        ## A confusingly named useless operator
        result = a[0] & b[high(b)]

    assert("foo" ^&*^@% "bar" == "fr")

    # Generic Functions
    # Not really good idea for obvious reasons
    let zero = ""
    proc `+`(a, b: string): string =
        a & b

    proc `*`[T](a: T, b: int): T =
        result = zero
        for i in 0..b-1:
            result = result + a  # calls `+` from line 3

    assert("a" * 10 == "aaaaaaaaaa")

    # Blocks
    block outer:
        for i in 0..2000:
            for j in 0..2000:
                if i+j == 3145:
                    echo i, ", ", j
                    break outer

    let b = 3
    block:
        let b = "3"  # shadowing is probably a dumb idea

    # Primitive types
    let
        a: int8 = 0x7F # Works
        b: uint8 = 0b1111_1111 # Works
        d = 0xFF # type is int
        c: uint8 = 256 # Compile time error
    let
        a: int = 2
        b: int = 4
    echo 4/2

    # Types Aliases
    type
        MyInteger* = int

    let a: int = 2
    discard a + MyInteger(4)

    # Objects
    type
        Animal* = object
            name*, species*: string
            age: int

    proc sleep*(a: var Animal) =
        a.age += 1

    proc dead*(a: Animal): bool =
        result = a.age > 20

    var carl: Animal
    carl = Animal(name : "Carl",
                  species : "L. glama",
                  age : 12)

    let joe = Animal(name : "Joe",
                     species : "H. sapiens",
                     age : 23)

    assert(not carl.dead)
    for i in 0..10:
        carl.sleep()
    assert carl.dead

    # Enums
    type
        CompassDirections = enum
            cdNorth, cdEast, cdSouth, cdWest

        Colors {.pure.} = enum
            Red = "FF0000", Green = (1, "00FF00"), Blue = "0000FF"

        Signals = enum
            sigQuit = 3, sigAbort = 6, sigKill = 9

    # Distinct Types
    type
        Dollars* = distinct float

    var a = 20.Dollars
    a = 25  # Doesn't compile
    a = 25.Dollars  # Works fine

    # Strings
    echo "words words words ⚑"
    echo """
    <html>
      <head>
      </head>\n\n

      <body>
      </body>
    </html> """

    proc re(s: string): string = s

    echo r"."".\s\"      # Raw string
    echo re"\b[a-z]++\b" # Regular expression
    echo function"text"  # Tagged string

    # Arrays
    type
        ThreeStringAddress = array[3, string]
    let names: ThreeStringAddress = ["Jasmine", "Ktisztina", "Kristof"]
    let addresses: ThreeStringAddress = ["101 Betburweg", "66 Bellion Drive", "194 Laarderweg"]

    type
        Matrix[W, H: static[int]] =
            array[1..W, array[1..H, int]]

    let mat1: Matrix[2, 2] = [[1, 0],
                              [0, 1]]
    let mat2: Matrix[2, 2] = [[0, 1],
                              [1, 0]]

    proc `+`[W, H](a, b: Matrix[W, H]):
        Matrix[W, H] =
            for i in 1..high(a):
                for j in 1..high(a[0]):
                    result[i][j] = a[i][j] + b[i][j]

    # Seqs
    var
        a = @[1, 2, 3]
        b = newSeq[int](3)

    for i, v in a:
        b[i] = v*v

    for i in 4..100:
        b.add(i * i)

    b.delete(0)  # takes O(n) time
    b = a[0] & b  # Same as original b

    # JSON
    import json

    let element = "Hydrogen"
    let atomicNumber = 1

    let jsonObject = %* {"element": element, "atomicNumber": atomicNumber}
    # This will print {"element":"Hydrogen", "atomicNumber": 1}
    echo $jsonObject

    # We start with a string representation of a JSON object
    let jsonObject = """{"name": "Sky", "age": 32}"""
    let jsonArray = """[7, 8, 9]"""

    let parsedObject = parseJson(jsonObject)
    let name = parsedObject["name"].getStr()
    # This will print Sky
    echo name

    let parsedArray = parseJson(jsonArray)
    let eight = parsedArray[1].getInt()
    # This will print 8
    echo eight

    # First we'll define our types
    type
        Element = object
            name: string
            atomicNumber: int

    # Let's say this is the JSON we want to convert
    let jsonObject = parseJson("""{"name": "Carbon", "atomicNumber": 6}""")

    let element = to(jsonObject, Element)
    # This will print Carbon
    echo element.name
    # This will print 6
    echo element.atomicNumber

    # Object Oriented Programming
    type Animal = ref object of RootObj
        name: string
        age: int
    method vocalize(this: Animal): string {.base.} = "..."
    method ageHumanYrs(this: Animal): int {.base.} = this.age

    type Dog = ref object of Animal
    method vocalize(this: Dog): string = "woof"
    method ageHumanYrs(this: Dog): int = this.age * 7

    type Cat = ref object of Animal
    method vocalize(this: Cat): string = "meow"

    var animals: seq[Animal] = @[]
    animals.add(Dog(name: "Sparky", age: 10))
    animals.add(Cat(name: "Mitten", age: 10))

    for a in animals:
        echo a.vocalize()
        echo a.ageHumanYrs()