Índice

Apéndice A: Referencia rápida de sintaxis

Palabras clave

Palabra clave Uso Ejemplo
fn Declaración de función fn add(a: int, b: int) -> int
let Binding inmutable let x: int = 42
var Binding mutable var count: int = 0
if / else Condicional if x > 0 { } else { }
while Bucle while i < 10 { i += 1 }
for Bucle con iterador for item in items { }
match Pattern matching match shape { Circle(r) => ... }
return Retornar de función return 42 o return vacío
defer Ejecutar al salir del scope defer { cleanup() }
struct Definición de estructura struct Point { x: int, y: int }
enum Enumeración / ADT enum Color { Red, Green, Blue }
trait Definición de trait trait Display { fn show(self) -> String }
impl Bloque de implementación impl Display for Point { }
import Importar módulo import "std/json"
export Exportar símbolo export fn create() -> Point
spawn Lanzar goroutine spawn { do_work() }
select Esperar en channels select { case ch => { } }
async Función async async fn fetch() -> String
await Esperar resultado async let r: String = await fetch()
unsafe Bloque unsafe unsafe { free(ptr) }
extern Función foránea extern "C" fn puts(s: String) -> int
true / false Literales booleanos let ok: bool = true
and / or / not Operadores lógicos if a > 0 and b > 0
as Conversión de tipo let p: int = addr as int
self Instancia actual fn length(self) -> int
derive Macro derive #[derive(Clone, Debug)]
where Restricción de trait fn f() where T: Display
type Alias de tipo type Callback = Fn(int) -> int
macro Macro declarativa macro log!(msg) { print(msg) }

Operadores

Aritméticos

Operador Significado Ejemplo
+ Suma / concatenación a + b, "hi" + name
- Resta a - b
* Multiplicación a * b
/ División a / b
% Módulo a % 2
** Potencia 2 ** 10

Comparación

Operador Significado Ejemplo
== Igual a == b
!= No igual a != b
< Menor que a < b
> Mayor que a > b
<= Menor o igual a <= b
>= Mayor o igual a >= b

Asignación

Operador Significado Ejemplo
= Asignar x = 42
+= Sumar y asignar x += 1
-= Restar y asignar x -= 1
*= Multiplicar y asignar x *= 2
/= Dividir y asignar x /= 2

Bit a bit

Operador Significado Ejemplo
& AND bit a bit flags & mask
`\ ` OR bit a bit `flags \ bit`
^ XOR bit a bit a ^ b
~ NOT bit a bit ~mask
<< Desplazamiento izquierda 1 << 8
>> Desplazamiento derecha value >> 4

Otros

Operador Significado Ejemplo
.. Rango 0..10
`\ >` Pipe `data \ > transform \ > print`
=> Brazo de match Some(x) => x
-> Tipo de retorno fn f() -> int

Declaraciones

Variables

let name: String = "Alice"       // inmutable
var count: int = 0               // mutable
let inferred = 42                // tipo inferido como int

Funciones

fn add(a: int, b: int) -> int {
    return a + b
}

fn greet(name: String, greeting: String = "Hola") -> String {
    return greeting + ", " + name
}

fn apply<T>(value: T, f: Fn(T) -> T) -> T {
    return f(value)
}

Structs

struct Point {
    x: int,
    y: int
}

struct Pair<T> {
    first: T,
    second: T
}

// Tuple struct
struct Meters(int)

Enums

enum Color { Red, Green, Blue }

enum Option<T> {
    Some(T),
    None
}

enum Shape {
    Circle(int),
    Rect(int, int),
    Triangle(int, int, int)
}

Traits e impl

trait Display {
    fn to_string(self) -> String
}

impl Display for Point {
    fn to_string(self) -> String {
        return "(" + int_to_string(self.x) + ", " + int_to_string(self.y) + ")"
    }
}

impl Point {
    fn new(x: int, y: int) -> Point {
        return Point { x: x, y: y }
    }
}

Imports

import "std/json"
import "std/http"
import { parse, stringify } from "std/json"

Tipos

Tipos primitivos

Tipo Descripción Ejemplo
int Entero 64 bits 42, -7, 0xFF
float Flotante 64 bits 3.14, -0.5
bool Booleano true, false
char Carácter (ASCII) 'A', 'z'
String String UTF-8 "hola"

Tipos compuestos

Tipo Descripción Ejemplo
Array Array dinámico [1, 2, 3]
Map Hash map Map.new()
Fn(A) -> B Tipo función Fn(int) -> int

Tipos con tamaño (programación de sistemas)

Tipo Tamaño Rango
i8 1 byte -128 a 127
i16 2 bytes -32768 a 32767
i32 4 bytes -2^31 a 2^31-1
i64 8 bytes -2^63 a 2^63-1
u8 1 byte 0 a 255
u16 2 bytes 0 a 65535
u32 4 bytes 0 a 2^32-1
u64 8 bytes 0 a 2^64-1
f32 4 bytes IEEE 754 simple
usize 8 bytes Tamaño de puntero

Tipos de puntero

Tipo Descripción
*T Puntero raw a T
*int Puntero raw a int

Flujo de control

If / else

if condicion {
    // ...
} else if otra {
    // ...
} else {
    // ...
}

While

while condicion {
    // ...
}

For

for item in coleccion {
    // ...
}

for i in 0..10 {
    // ...
}

Match

match valor {
    0 => print("cero"),
    1 | 2 => print("uno o dos"),
    n if n > 100 => print("grande"),
    _ => print("otro")
}

match opcion {
    Some(x) => usar(x),
    None => defecto()
}

If-let / While-let

if let Some(x) = maybe_value {
    print(int_to_string(x))
}

while let Some(item) = iterator.next() {
    process(item)
}

Atributos de función

#[naked]                          // Sin prólogo/epílogo
#[interrupt]                      // Manejador de interrupción
#[link_section(".text.boot")]     // Colocar en sección específica
#[export_name("_start")]          // Controlar nombre de símbolo
#[derive(Clone, Debug, Display)]  // Derivar implementaciones de traits
#[repr(C)]                        // Layout de memoria compatible con C

Métodos de String

Método Retorna Descripción
.length() int Longitud del string
.charAt(i) int Valor ASCII en índice
.substring(start, len) String Extraer subcadena
.indexOf(sub) int Buscar subcadena (-1 si no se encuentra)
.contains(sub) bool Verificar si contiene subcadena
.split(delim) Array Dividir en array
.trim() String Eliminar espacios
.toUpper() String Mayúsculas
.toLower() String Minúsculas
.startsWith(prefix) bool Verificar prefijo
.endsWith(suffix) bool Verificar sufijo
.replace(old, new) String Reemplazar ocurrencias

Métodos de Array

Método Retorna Descripción
.length() int Longitud del array
.push(item) void Agregar al final
.pop() any Quitar del final
.get(index) any Obtener por índice
.set(index, val) void Establecer por índice
.slice(start, end) Array Extraer sub-array
.contains(item) bool Verificar membresía
.indexOf(item) int Buscar índice
.join(sep) String Unir en string
.reverse() Array Invertir array
.sort() Array Ordenar array
.insert(índice, val) void Insertar en posición
.remove(índice) any Quitar en posición

Métodos de Map

Método Retorna Descripción
Map.new() Map Crear map vacío
.get(key) any Obtener valor por clave
.set(key, val) void Establecer par clave-valor
.contains(key) bool Verificar si existe clave
.remove(key) void Eliminar clave
.keys() Array Obtener todas las claves
.values() Array Obtener todos los valores
.size() int Número de entradas
.clear() void Eliminar todas las entradas

Funciones built-in

Función Descripción
print(value) Imprimir a stdout
println(value) Imprimir con salto de línea
int_to_string(n) Convertir int a string
float_to_string(f) Convertir float a string
string_to_int(s) Parsear string a int
string_to_float(s) Parsear string a float
typeof(value) Obtener nombre de tipo como string
time_us() Tiempo actual en microsegundos
sleep(ms) Dormir por milisegundos
exit(code) Salir del programa
chr(code) Convertir código ASCII a string de un carácter
read_byte() Leer un byte de stdin (devuelve int, -1 en EOF)
raw_mode_enter() Poner terminal en modo raw (sin eco, sin buffering)
raw_mode_exit() Restaurar terminal a modo normal
term_cols() Ancho del terminal en columnas
term_rows() Alto del terminal en filas

Builtins de control de procesos (v0.12.0)

Función Descripción
fork() Bifurcar proceso. Devuelve 0 en hijo, PID en padre, -1 en error
execvp(programa, args) Reemplazar proceso con programa. args es un Array de strings
waitpid(pid, opts) Esperar proceso hijo. opts: 0=bloquear, 1=WNOHANG. Devuelve estado de salida
dup2(old_fd, new_fd) Duplicar descriptor de archivo (para redirecciones)
pipe_new() Crear pipe. Devuelve [read_fd, write_fd]
close_fd(fd) Cerrar un descriptor de archivo raw
open_fd(path, mode) Abrir archivo como fd. mode: 0=lectura, 1=escritura(truncar), 2=append
getcwd() Obtener directorio de trabajo actual como String
chdir(path) Cambiar directorio de trabajo. Devuelve 0 en éxito
stat(path) Info de archivo: devuelve [size, mode, mtime, is_dir, is_file]
isatty(fd) Devuelve 1 si fd es un terminal, 0 si no
getpid() Obtener ID del proceso actual
kill_process(pid, signal) Enviar señal a un proceso

Configuración de build (nyx.toml)

Todo proyecto Nyx puede tener un archivo nyx.toml en su raíz. Este archivo describe los metadatos del proyecto, el punto de entrada y las dependencias.

[package]
name = "myapp"
version = "0.1.0"
main = "src/main.nx"
description = "Mi primer proyecto Nyx"
no_gc = false

[dependencies]
somelib = "*"
otherlib = "https://github.com/org/otherlib"
Campo Sección Descripción
name [package] Nombre del proyecto (usado para el binario de salida)
version [package] Versión semántica (MAJOR.MINOR.PATCH)
main [package] Archivo de punto de entrada (default: src/main.nx)
description [package] Descripción del proyecto en una línea
no_gc [package] Deshabilitar recolector de basura (default: false)
<name> = "<version>" [dependencies] Dependencia con restricción semver ("*" para cualquiera)
<name> = "<url>" [dependencies] Dependencia git (clonada a packages/)

Ejecuta nyx init para crear un nuevo proyecto con nyx.toml y src/main.nx. Ejecuta nyx build para compilar, lo cual también genera un archivo nyx.lock que fija las versiones de dependencias.

← Volver al Índice

← Anterior: Construyendo una base de datos — nyx-db Siguiente: Apéndice B: Módulos de la biblioteca estándar →