Descripción general del lenguaje Nim

Nim 2.2 — lenguaje de sistemas | Sintaxis similar a Python | Motores C/JS/LLVM | GC opcional | metaprogramación a través de macros

paradigma

Multiparadigma: imperativo, funcional, orientado a objetos (mediante sintaxis de llamada a método), metaprogramación. Tipificación estática con inferencia completa (tipo Hindley-Milner), equivalencia de tipo estructural. Compilación mediante C, C++, JavaScript o LLVM. Las macros basadas en AST se ejecutan en tiempo de compilación.

Tipos

Declaraciones

Controlar el flujo

Características del estuche (partido)

• Condiciones de rama: of val:, of val1, val2:, of 0..10:
• Patrones de rango, membresía de conjuntos, coincidencia de tipos
• of T(someField): — coincidencia de patrones con encuadernación
• Exhaustividad comprobada para enumeraciones.

Operadores

Sobrecarga del operador

Cualquier operador puede sobrecargarse: `+`, `*`, `in`, etc. Los operadores personalizados se pueden definir con notación de acento grave.

Sintaxis de llamada al método

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

Genéricos

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

Memoria y GC

ARC/ORC (desde Nim 2.0)

• --gc:arc: recuento de referencia determinista (sin colector de ciclo)
• --gc:orc: ARC + colector de ciclo opcional
• {.acyclic.} pragma para tipos sin ciclos
• sink parámetros para la semántica de movimiento
• cursor anotación para semántica tipo préstamo

Memoria manual

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

Macros y metaprogramación

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

Funciones en tiempo de compilación

• static[T] — forzar la evaluación en tiempo de compilación
• when - condicional en tiempo de compilación (como #if en C)
• const — constante de tiempo de compilación con semántica completa de Nim
• macro — Transformación de código de nivel AST
• template — sustitución a nivel de sintaxis
• {.pragma.} — pragmas definibles por el usuario
• compileTime - ejecutar código en tiempo de compilación
• import macros — AST construction/manipulation

Biblioteca estándar (seleccionada)

Manejo de errores

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

Compilación

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

Banderas de compilación

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

Administrador de paquetes ágil

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 configura los metadatos del paquete, las dependencias y las reglas de compilación.

Interoperabilidad 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

Características de la interfaz de funciones externas

• {.importc.} {.exportc.} {.header.} {.link.} {.nodecl.}
• {.importcpp.} para interoperabilidad de C++
• {.importobjc.} para Objective-C
• {.importjs.} para interoperabilidad de JavaScript
• {.packed.} para diseño de estructura compatible con ABI
• {.union.} para uniones C
• {.bitsize.} para campos de bits