Nim (programming language)

The syntax of Nim is readable, as it highly resembles that of Python.[20] Code blocks and nesting statements are identified through use of white-space according to the offside-rule, and many keywords are identical to their Python equivalents, which are mostly English keywords, where other programming languages use punctuation. Even though Nim supports indentation based syntax like Python, it introduced flexibility whereby one could break statements with a comma or binary operator to the next line. Nim also supports user-defined operators.

Nim is almost fully style-insensitive; two identifiers are considered equal if they only differ by capitalization and underscores, as long as the first characters are identical.[21]

In details, it is influenced by:

• Modula-3: traced vs untraced pointers
• Object Pascal: type safe bit sets (set of char), case statement syntax, various type names and filenames in the standard library
• Ada: subrange types, distinct type, safe variants – case objects
• C++: operator overloading, generic programming
• Python: Off-side rule
• Lisp: Macro system, embrace the AST, homoiconicity
• Oberon: export marker
• C#: async – await, lambda macros
• Go: defer

Also, Nim supports a Uniform Function Call Syntax (UFCS)[22] and identifier equality.[23]

Nimble is the standard package manager used by Nim to package Nim modules,[26] it was initially developed by Dominik Picheta who is also a core Nim developer. Newer releases of Nim come with Nimble included.

Nimble packages are defined by .nimble files, which contain information about the package version, author, license, description, dependencies and more.[27] These files support a limited subset of the Nim syntax called NimScript, with the main limitation being the access to the FFI. These scripts allow changing of test procedure, or for custom tasks to be written.

The list of packages is stored in a JSON file which is freely accessible in the nim-lang/packages repository on GitHub. This JSON file provides Nimble with a mapping between the names of packages and their Git or Mercurial repository URLs.

Because Nimble comes with the Nim compiler, it is possible to test the Nimble environment by running: nimble -v This command will reveal the version number, the compilation date and time and git hash of nimble. Nimble utilizes git, which must be available for Nimble to function well. The Nimble command-line is used as interface for installing, removing (uninstalling), and upgrading/patching module packages.[28]

c2nim is a transcompiler/transpiler that helps to generate new bindings by translating ANSI C code to Nim code.[29] The output is human-readable Nim code that is meant to be tweaked by hand after the translation process.

Choosenim was developed by Dominik Picheta, the author of the book Nim in Action, as a tool that enables a developer to have multiple versions of Nim compilers in his/her machine. Choosenim installs Nim from official downloads and sources, enabling easy switching between stable and development compilers.[30]

A maintenance script that is used to build Nim and also provide HTML documentation.

Is a generic tool for manipulating text. It is used to search for regex or peg patterns or search the whole directory at once and also replace tasks.

Nimfix is a tool that helps to convert old-style Nimrod code to Nim code.[31] Nimfix is currently beta-quality.[32]

pas2nim is a tool to translate Object Pascal wrappers to Nim code.[33] It was used to translate the original Pascal sources of the Nim compiler. Only what maps easily to Nim is supported. Free Pascal, Delphi-style classes, and some other features are unsupported. At this time, development and maintenance is mostly stalled.

py2nim is a tool used for transpiling Python code into idiomatic Nim code.[34] Development is active, with plans to extend the amount of Python code that can be fully translated into Nim.

The Nim standard library can be classified in to two groups known as the pure libraries and impure libraries.

Are a collection of modules written only in Nim programming language, without wrappers to access libraries written in other programming languages. The pure modules can be further classified into subgroups based on their tasks, which includes the following:

• The Core
• Collections and Algorithm
• String Handling
• Generic Operating System Services
• Math Libraries
• Internet Protocols
• Parsers

The impure modules of Nim code which depend on external libraries that are written in other programming languages such as C.

The "Hello, World!" program in Nim:

echo("Hello, world!")
# Procedures can be called with no parentheses
echo "Hello, World!"

Another version of coding "Hello World" is...

stdout.write("Hello, world!\n")
## This is documentation single line comment

Program to calculate the factorial of a positive integer using the iterative approach:

import strutils

var n = 0
try:
  stdout.write "Input positive integer number: "
  n = stdin.readline.parseInt
except ValueError:
  raise newException(ValueError, "You must enter a positive number")

var fact = 1
for i in 2..n:
  fact = fact * i

echo fact

Using the module math from Nim's standard library:

import math

let i: int = fac(x)
echo i

A simple demonstration showing many of Nim's features.

proc reverse(s: string): string =
  for i in countdown(s.high, 0):
    result.add s[i]

let str1 = "Reverse This!"
echo "Reversed: ", reverse(str1)

One of the more exotic features is the implicit result variable. Every procedure in Nim with a non-void return type has an implicit result variable that represents the value that will be returned. In the for loop we see an invocation of countdown which is an iterator. If an iterator is omitted, the compiler will attempt to use an items iterator, if one is defined for the type specified.

Using GTK3 with gobject introspection through the gintro module:

import gintro/[gtk, glib, gobject, gio]

proc appActivate(app: Application) =
  let window = newApplicationWindow(app)
  window.title = "GTK3 application with gobject introspection"
  window.defaultSize = (400, 400)
  showAll(window)

proc main =
  let app = newApplication("org.gtk.example")
  connect(app, "activate", appActivate)
  discard run(app)

main()

This code requires the gintro module to work, which is not part of the standard library. To install the module gintro and many others you can use the tool nimble, which comes as part of nim. To install the gintro module with nimble you do the following:

nimble install gintro

This is an example of metaprogramming in Nim using its template facilities.

template genType(name, fieldname: untyped, fieldtype: typedesc) =
  type
    name = object
      fieldname: fieldtype

genType(Test, foo, int)

var x = Test(foo: 4566)
echo(x.foo) # 4566

The genType is invoked at compile-time and a Test type is created.

Generics may be used in procs, templates and macros. They are defined after the proc's name in square brackets, as seen below.

proc addThese[T](a, b: T): T =
  a + b

echo addThese(1, 2) # 3 (of int type)
echo addThese(uint8 1, uint8 2) # 3 (of uint8 type)

In addThese, T is the generic type, the compiler will accept any values for this function as long as both parameters and the return value are of the same type.

Macros can literally rewrite parts of the code before it's compiled. Nim macros are powerful and can do many operations on the abstract syntax tree.

Here's a simple example, that creates a macro called twice:

import macros

macro twice(arg: untyped): untyped =
  result = quote do:
    `arg`
    `arg`

twice echo "Hello world!"

The twice macro in this example takes the echo statement in the form of an abstract syntax tree as input. In this example we decided to return this syntax tree without any manipulations applied to it. But we do it twice, hence the name of the macro. The end result is that the code gets rewritten by the macro to look like the following code at compile time:

echo "Hello world!"
echo "Hello world!"

Nim's FFI is used to call functions written in the other programming languages that it can compile to. This means that libraries written in C, C++, Objective-C and JavaScript can be used in Nim source code. One should be aware that both JavaScript and C, C++, or Objective-C libraries cannot be combined in the same program, as they are not as compatible with JavaScript as they are with each other. Both C++ and Objective-C are based on and compatible with C, but JavaScript is incompatible, as a dynamic, client-side web-based language.[39]

The following program demonstrates the ease with which external C code can be used directly in Nim.

proc printf(formatstr: cstring) {.header: "<stdio.h>", varargs.}

printf("%s %d\n", "foo", 5)

In this code the printf function is imported into Nim and then used.

To activate threading support in Nim, a program should be compiled with --threads:on command line argument. Each thread has a separate garbage collected heap and sharing of memory is restricted, which help with efficiency and stops race conditions by the threads.

import locks

var
  thr: array[0..4, Thread[tuple[a,b: int]]]
  L: Lock

proc threadFunc(interval: tuple[a,b: int]) {.thread.} =
  for i in interval.a..interval.b:
    acquire(L) # lock stdout
    echo i
    release(L)

initLock(L)

for i in 0..high(thr):
  createThread(thr[i], threadFunc, (i*10, i*10+5))
joinThreads(thr)

Nim has channels module, that simplifies passing data between threads.

import os

type
  CalculationTask = object
    id*: int
    data*: int

  CalculationResult = object
    id*: int
    result*: int

var task_queue: Channel[CalculationTask]
var result_queue: Channel[CalculationResult]

proc workerFunc() {.thread.} =
  result_queue.open()

  while true:
    var task = task_queue.recv()
    result_queue.send(CalculationResult(id: task.id, result: task.data * 2))

var workerThread: Thread[void]
createThread(workerThread, workerFunc)

task_queue.open()
task_queue.send(CalculationTask(id: 1, data: 13))
task_queue.send(CalculationTask(id: 2, data: 37))

while true:
  echo "got result: ", repr(result_queue.recv())

Nim supports asynchronous IO via asyncdispatch module, which adds async/await syntax via macro system. An example of asynchronous http server:

import asynchttpserver, asyncdispatch

var server = newAsyncHttpServer()
proc cb(req: Request) {.async.} =
  await req.respond(Http200, "Hello World")

waitFor server.serve(Port(8080), cb)