let neto = (SUELDO ?? 0) * 0.8;
emit { neto: neto };

use std.math.{ round };

header {
    name: "liquidacion";
    version: "1.0.0";
    const TASA_AFP = 0.1157;
}

main {
    let bruto      = SUELDO_BASE ?? 0;
    let desc_afp   = round(bruto * TASA_AFP, 0);
    let desc_salud = round(bruto * FONASA_TASA, 0);

    emit {
        sueldo_bruto:   bruto,
        desc_afp:       desc_afp,
        desc_salud:     desc_salud,
        sueldo_liquido: bruto - desc_afp - desc_salud
    };
}

caper run [script.caper] [--context '{"CLAVE": val}']   Ejecutar un script
caper run [script.caper] [--context-file ctx.json]      Ejecutar con contexto desde archivo
caper run                                               Modo proyecto (lee .capercfg)
caper validate <script.caper>                           Solo verificar sintaxis
caper lint     <script.caper> [...]                     Análisis estático (apto para CI)
caper fmt      <script.caper> [--write]                 Formatear código fuente
caper install                                           Instalar dependencias
caper new <nombre>                                      Nuevo proyecto
caper new --pkg <@author/nombre>                        Nuevo paquete publicable
caper repl                                              REPL interactivo
caper -m                                                Listar módulos de la stdlib
caper --cfg                                             Mostrar archivos de configuración cargados
caper version

header {
    name: "mi-script";
    version: "1.0.0";
    const TASA_IVA = 0.19;   // inmutable, no puede ser sobreescrita por el contexto
}

main {
    let total = MONTO * (1 + TASA_IVA);
    emit { total: total };
}

let x = 42;          // inmutable — no se puede reasignar
var contador = 0;    // mutable — puede reasignarse
contador = contador + 1;

let a = 0.1 + 0.2;   // 0.3 — no 0.30000000000000004

// Aritméticos
a + b    a - b    a * b    a / b    a % b    a ** b

// Comparación
a == b   a != b   a > b   a < b   a >= b   a <= b

// Lógicos
a and b   a or b   not a

// Null coalescing
valor ?? valor_por_defecto    // retorna valor_por_defecto cuando valor es null

// Concatenación de strings
"Hola " + nombre

// Rango (produce un array)
1..10    // [1, 2, ..., 10]

// if / else if / else — como sentencia o como expresión
if puntaje >= 90 {
    nota = "A";
} else if puntaje >= 70 {
    nota = "B";
} else {
    nota = "C";
}

let etiqueta = if activo { "activo" } else { "inactivo" };

// while
while (i < 10) {
    i = i + 1;
}

// foreach
foreach item in items {
    total = total + item.precio;
}

foreach clave, valor in mapa {
    // clave y valor disponibles
}

// break y continue funcionan dentro de loops

// Match exacto
let descripcion = match tipo_contrato {
    "indefinido" => "Contrato a Plazo Indefinido",
    "plazo_fijo" => "Contrato a Plazo Fijo",
    "honorarios" => "Boleta de Honorarios",
    _            => "Tipo no reconocido"
};

// Con guards
let tramo = match sueldo {
    n if n < 500_000   => "exento",
    n if n < 1_500_000 => "medio",
    _                  => "alto"
};

fn factorial(n) {
    if n <= 1 { emit 1; }
    emit n * factorial(n - 1);
}

// Closures
let doble  = |x| => x * 2;
let sumar  = |a, b| => a + b;

// Closure con cuerpo
let clamp = |val, min, max| => {
    if val < min { emit min; }
    if val > max { emit max; }
    emit val;
};

let items = [10, 20, 30];
let primero = items[0];    // 10
let ultimo  = items[-1];   // 30

let persona = { nombre: "Ana", edad: 30 };
let nombre  = persona.nombre;
let edad    = persona["edad"];

// Spread
let a = [1, 2];
let b = [...a, 3, 4];            // [1, 2, 3, 4]

let base    = { x: 1 };
let merged  = { ...base, y: 2 }; // { x: 1, y: 2 }

try {
    let resultado = funcion_riesgosa(entrada);
    emit { ok: resultado };
} catch e {
    emit { error: e.message };
}

// throw un valor estructurado
throw { code: "ENTRADA_INVALIDA", message: "El monto debe ser positivo" };

fn clasificar(n) {
    if n > 0 { emit "positivo"; }
    if n < 0 { emit "negativo"; }
    emit "cero";
}

// Importar funciones específicas de la stdlib
use std.math.{ round, min, max };
use std.arrays.{ sum, filter, map };

// Importar un script de usuario (ruta relativa)
use formulas.gratificacion;

// Importar con alias de ruta (configurado en .capercfg)
use @formulas.liquidacion;

// Importar desde un paquete de vendor (instalado con caper install)
use @author/mi-paquete.lib.{ mi_funcion };
use autor/otro-pkg.modulo.{ helper };

use std.arrays.{ map, filter, sum };

let sueldos = [850000, 1200000, 450000, 2100000];

let altos  = filter(sueldos, |s| => s > 1_000_000);
let dobles = map(sueldos, |s| => s * 2);
let total  = sum(sueldos);

mi-proyecto/
  .capercfg     ← manifiesto del proyecto
  main.caper    ← script principal
  .gitignore

@mi-usuario/
  formulas-cl/
    pkg.capercfg    ← manifiesto del paquete
    lib.caper       ← módulo principal
    .gitignore

mi-proyecto/
  .capercfg
  caper.lock       ← versiones exactas bloqueadas (commitear)
  vendors/
    @autor/
      formulas-cl/
        pkg.capercfg
        lib.caper
    mi-lib-interna/
      pkg.capercfg
      ...

use @autor/formulas-cl.lib.{ calcular_afp, calcular_salud };
use mi-lib-interna.helpers.{ formatear_rut };

main {
    let afp = calcular_afp(SUELDO_BASE);
    emit { afp: afp };
}

// En un script:
let msg = saludar("Ana");   // → "Hola, Ana!"

>>> 1 + 2
3
>>> let x = 10; let y = 20; x + y
30
>>> fn doble(n) { emit n * 2; }; doble(21)
42
>>> .help
>>> .exit