Nim Language Overview

Nim 2.2 — systems language | Python-like syntax | C/JS/LLVM backends | GC optional | metaprogramming via macros

Paradigm

Multi-paradigm: imperative, functional, object-oriented (via method call syntax), metaprogramming. Static typing with full inference (Hindley-Milner-like), structural type equivalence. Compilation via C, C++, JavaScript, or LLVM. AST-based macros run at compile time.

Types

Declarations

Control Flow

Case (Match) Features

• Branch conditions: of val:, of val1, val2:, of 0..10:
• Range patterns, set membership, type matching
• of T(someField): — pattern matching with binding
• Exhaustiveness checked for enums

Operators

Operator Overloading

Any operator can be overloaded: `+`, `*`, `in`, etc. Custom operators can be defined with backtick notation.

Method Call Syntax

# Object-oriented style
echo "hello".len()
x.addr().repr()

# Uniform Function Call Syntax (UFCS)
# Any proc can be called as method:
proc greet(s: string): string = "Hello " & s
"world".greet()  # "Hello world"

Generics

proc id[T](x: T): T = x

type
  Pair[T, U] = object
    first: T
    second: U

# Concepts (type constraints)
proc sort[T: SomeOrdinal](arr: var seq[T]) = ...

proc hash[T: Hashable](x: T): int =
  # T must implement Hashable concept

Memory & GC

ARC/ORC (since Nim 2.0)

• --gc:arc: deterministic reference counting (no cycle collector)
• --gc:orc: ARC + optional cycle collector
• {.acyclic.} pragma for cycle-free types
• sink parameters for move semantics
• cursor annotation for borrow-like semantics

Manual memory

var p = alloc(sizeof(int))
p[] = 42
dealloc(p)

Macros & Metaprogramming

import macros

macro assert(cond: untyped): untyped =
  # AST manipulation at compile time
  result = quote do:
    if not `cond`:
      echo "assertion failed: ", astToStr(`cond`)
      quit(1)

# Usage
assert(1 + 1 == 3)

# Template (simpler than macro)
template repeat(n: int, body: untyped): untyped =
  for i in 0..<n:
    body

repeat(3, echo "hello")

Compile-time features

• static[T] — force compile-time evaluation
• when — compile-time conditional (like #if in C)
• const — compile-time constant with full Nim semantics
• macro — AST-level code transformation
• template — syntax-level substitution
• {.pragma.} — user-definable pragmas
• compileTime — run code at compile time
• import macros — AST construction/manipulation

Standard Library (selected)

Error Handling

# Exceptions (runtime)
try:
  let f = open("file.txt")
  defer: f.close()
  echo f.readAll()
except IOError as e:
  echo "IO error: ", e.msg
finally:
  echo "done"

# Result type (no exception, Nim 2.0+)
from std/result import Result, Ok, Err

func div(a, b: int): Result[int, string] =
  if b == 0:
    return Err("division by zero")
  return Ok(a div b)

# Raise exceptions
raise newException(ValueError, "invalid input")

# Option type
import std/options
let x: Option[int] = some(42)
let y: Option[int] = none(int)

Compilation

nim c file.nim             # compile with C backend
nim cpp file.nim           # compile with C++ backend
nim js file.nim            # compile to JavaScript
nim r file.nim             # compile + run
nim build                  # compile project (newer)
nimble build               # compile with Nimble package
nim check file.nim         # type-check only
nim doc file.nim           # generate documentation
nim pretty file.nim        # format code

Compilation flags

--opt:speed --opt:size --opt:none -d:release --gc:orc --gc:arc --gc:markandsweep --cc:clang --cc:gcc --mm:arc --threads:on --stackTrace:on --lineTrace:on --checks:on

Nimble Package Manager

nimble init                 # create package
nimble install <pkg>       # install dependency
nimble build                # build project
nimble test                 # run tests
nimble publish              # publish to nimble registry

nimble.cfg configures package metadata, dependencies, and build rules.

C Interop

# Declare C function
proc printf(fmt: cstring): cint {.importc, varargs.}

# Import C library
proc sqrt(x: float64): float64 {.importc: "sqrt", header: "math.h".}

# Export to C
proc myFunc(a: cint): cint {.exportc.} = a * 2

# Inline C code
{.emit: """
static int add(int a, int b) { return a + b; }
""".}

proc add(a, b: cint): cint {.importc: "add".}

# C type mappings
# int → cint, char → cchar, void → pointer
# char* → cstring, struct → object {.pure, inheritable.}
# size_t → csize, size_t → csize_t

Foreign function interface features

• {.importc.} {.exportc.} {.header.} {.link.} {.nodecl.}
• {.importcpp.} for C++ interop
• {.importobjc.} for Objective-C
• {.importjs.} for JavaScript interop
• {.packed.} for ABI-compatible struct layout
• {.union.} for C unions
• {.bitsize.} for bitfields