# 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()