Présentation du langage Nim

Nim 2.2 — langage système | Syntaxe de type Python | Moteurs C/JS/LLVM | CG en option | métaprogrammation via des macros

Paradigme

Multi-paradigme : impératif, fonctionnel, orienté objet (via la syntaxe d'appel de méthode), métaprogrammation. Typage statique avec inférence complète (de type Hindley-Milner), équivalence de type structurel. Compilation via C, C++, JavaScript ou LLVM. Les macros basées sur AST s'exécutent au moment de la compilation.

Espèces

Déclarations

Flux de contrôle

Caractéristiques du boîtier (correspondance)

• Conditions de branche : of val:, of val1, val2:, of 0..10:
• Modèles de plage, appartenance à un ensemble, correspondance de type
• of T(someField): — correspondance de motifs avec reliure
• exhaustivité vérifiée pour les énumérations

Opérateurs

Surcharge de l'opérateur

N'importe quel opérateur peut être surchargé : `+`, `*`, `in`, etc. Les opérateurs personnalisés peuvent être définis avec une notation backtick.

Syntaxe des appels de méthode

# 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"

Génériques

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

Mémoire et CPG

ARC/ORC (depuis Nim 2.0)

• --gc:arc: comptage de références déterministe (pas de collecteur de cycles)
• --gc:orc: ARC + collecteur de cycle en option
• {.acyclic.} pragma pour les types sans cycle
• sink paramètres pour la sémantique de déplacement
• cursor annotation pour une sémantique de type emprunt

Mémoire manuelle

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

Macros et métaprogrammation

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")

Fonctionnalités au moment de la compilation

• static[T] — forcer l'évaluation au moment de la compilation
• when — conditionnel à la compilation (comme #if en C)
• const — constante de compilation avec sémantique Nim complète
• macro — Transformation de code au niveau AST
• template — substitution au niveau de la syntaxe
• {.pragma.} — pragmas définissables par l'utilisateur
• compileTime - exécuter le code au moment de la compilation
• import macros — AST construction/manipulation

Bibliothèque standard (sélectionnée)

Gestion des erreurs

# 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

Drapeaux de compilation

--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

Gestionnaire de paquets agile

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 configure les métadonnées, les dépendances et les règles de build du package.

Interopérabilité C

# 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

Fonctionnalités de l'interface de fonction étrangère

• {.importc.} {.exportc.} {.header.} {.link.} {.nodecl.}
• {.importcpp.} pour l'interopérabilité C++
• {.importobjc.} pour Objective-C
• {.importjs.} pour l'interopérabilité JavaScript
• {.packed.} pour la disposition de structure compatible ABI
• {.union.} pour raccords C
• {.bitsize.} pour les champs de bits