Manejo de Errores

En Piola hay dos categorías de cosas que pueden salir mal: los errores de runtime que el lenguaje lanza automáticamente, y los errores que tú capturas con ojo/cago. Ambos hablan chileno.

ojo / cago — try / catch

Envuelve en ojo el código que puede fallar. Si algo explota, cago lo captura.

ojo {
  wea resultado = 10 / 0
} cago(error) {
  altiro("La cagó: " + error)
}
// → La cagó: Weon, no se puede dividir por cero.

error dentro del cago es un texto con el mensaje del error. Puedes llamarlo como quieras:

ojo {
  altiro(lista_inexistente)
} cago(e) {
  altiro("Oe: " + e)
}
// → Oe: La wea 'lista_inexistente' no existe papito.

Errores que se pueden capturar

Cualquier error de runtime puede ser atrapado con ojo/cago. Estos son todos los que Piola puede lanzar:

Error de tipo

ojo {
  wea x = "fósforos" + 42
} cago(error) {
  altiro(error)
}
// → No podi usar '+' entre un 'texto' y un 'numero' pedazo de saco wea.

Tip

Sumar texto con número funciona si el número va al lado del texto, es coerción intencional:

altiro("Precio: " + 1500)  // → Precio: 1500  ✓
altiro(1500 + " pesos")    // → 1500 pesos     ✓
altiro("precio" + 1500 + "CLP")   // → precio1500CLP  ✓

Lo que no funciona es intentar operar aritméticamente:

altiro("precio" * 2)  // Error ✗

Variable no definida

ojo {
  altiro(boleta_electronica)
} cago(error) {
  altiro(error)
}
// → La wea 'boleta_electronica' no existe papito.

División por cero

ojo {
  wea promedio = 100 / 0
} cago(error) {
  altiro(error)
}
// → Weon, no se puede dividir por cero.

Índice inválido

wea fila_banco = ["señora Rosa", "don Lucho", "el cabro chico"]

ojo {
  altiro(fila_banco[99])
} cago(error) {
  altiro(error)
}
// → Te fuiste al chancho, el índice 99 no existe en la lista (largo: 3).

Clave inexistente en mapa

wea tramite = {"nombre": "certificado de residencia", "costo": 0}

ojo {
  altiro(tramite["tiempo_estimado"])
} cago(error) {
  altiro(error)
}
// → La clave 'tiempo_estimado' no existe papito.

Constante inmutable

duro PRECIO_MICRO = 800

ojo {
  PRECIO_MICRO = 750
} cago(error) {
  altiro(error)
}
// → Oe, 'PRECIO_MICRO' es duro, no lo podí cambiar.

Argumentos incorrectos

pega recargar_bip(monto) {
  "Recargando $" + monto
}

ojo {
  recargar_bip(500, "efectivo", "por favor")
} cago(error) {
  altiro(error)
}
// → La pega espera 1 args, le pasaste 3.

Llamar algo que no es una función

wea direccion = "Avenida Libertador Bernardo O'Higgins 1234"

ojo {
  direccion()
} cago(error) {
  altiro(error)
}
// → 'texto' no es una pega papito.

---

ojo/cago anidados

Puedes anidar bloques para manejar errores en distintos niveles:

// Simulando un trámite en el Registro Civil
pega buscar_documento(rut) {
  cachai (rut == nada) {
    wea lista = []
    devolver lista[-1]  // Error a propósito
  }
  "Documento de " + rut
}

ojo {
  ojo {
    wea doc = buscar_documento(nada)
    altiro(doc)
  } cago(error_interno) {
    altiro("Error buscando documento: " + error_interno)
    // podríamos relanzar o manejar acá
  }

  altiro("Trámite completado")

} cago(error_externo) {
  altiro("Error general del sistema: " + error_externo)
}

---

Lo que ojo/cago NO captura

Las señales de control de flujo no son errores — pasan a través del ojo sin ser capturadas:

para (i en [1, 2, 3, 4, 5]) {
  ojo {
    cachai (i == 3) {
      cortala  // ← esto NO lo atrapa el cago
    }
    altiro(i)
  } cago(e) {
    altiro("error: " + e)
  }
}
// → 1
// → 2
// (se corta en 3, el cortala sale del bucle correctamente)

Lo mismo con sigue y devolver — son control de flujo, no errores.

---

Errores de sintaxis y léxicos

Estos ocurren antes de que el programa corra, no durante. No se pueden capturar con ojo/cago porque Piola ni llega a ejecutar el código.

// Este archivo no corre en absoluto:
wea x = @#$

Error léxico
  × Carácter inesperado '@'.
   ╭─[programa.cl:1:9]
 1 │ wea x = @#$
   ·         ┬
   ·         ╰── Carácter inesperado '@'.
   ╰────

---

Catálogo de errores

Error de tipo

Operación entre tipos incompatibles.

"No podi usar '+' entre un 'numero' y un 'texto'..."

Variable no definida

Usar una variable que no fue declarada.

"La wea 'x' no existe papito."

División por cero

Dividir o hacer módulo con cero.

"Weon, no se puede dividir por cero."

Índice inválido

Acceder fuera del rango de una lista.

"Te fuiste al chancho, el índice N no existe..."

Clave inexistente

Acceder a una clave que no existe en un mapa.

"La clave 'x' no existe papito."

Constante inmutable

Intentar modificar una variable duro.

"Oe, 'X' es duro, no lo podí cambiar."

Argumentos incorrectos

Llamar una función con el número equivocado de argumentos.

"La pega espera N args, le pasaste M."

No es una función

Intentar llamar algo que no es una pega.

"'texto' no es una pega papito."

---

Patrón recomendado

En vez de envolver todo en un ojo gigante, captura cerca del origen del problema:

// ✗ Demasiado amplio — no sabes qué falló
ojo {
  wea datos     = obtener_datos()
  wea procesado = procesar(datos)
  wea resultado = guardar(procesado)
  altiro(resultado)
} cago(e) {
  altiro("algo falló: " + e)
}

// ✓ Captura específica — sabes exactamente qué y dónde
wea datos = nada

ojo {
  datos = obtener_datos()
} cago(e) {
  altiro("No se pudieron obtener los datos: " + e)
}

cachai (datos != nada) {
  wea procesado = procesar(datos)
  altiro(procesado)
}