Control de Flujo

El control de flujo es lo que hace que un programa tome decisiones, repita cosas, y sepa cuándo parar. Piola tiene lo necesario y nada más.

---

cachai — condicional

La forma de tomar decisiones. Si la condición es verdad, ejecuta el bloque. Si no, sigue de largo o ejecuta el si no.

wea temperatura_horno = 180

cachai (temperatura_horno >= 200) {
  altiro("Listo para las empanadas")
} si no {
  altiro("Espera un poco más, weon")
}
// → Espera un poco más, weon

Condiciones encadenadas

No hay sino cachai como en otros lenguajes — se anidan bloques:

wea ingredientes = 3

cachai (ingredientes == 0) {
  altiro("No hay nada, pide delivery")
} si no {
  cachai (ingredientes < 3) {
    altiro("Alcanza para un completo no más")
  } si no {
    altiro("Suficiente para una cazuela")
  }
}
// → Suficiente para una cazuela

Operadores lógicos

Usa y, o, y no para combinar condiciones:

wea tiene_palta  = verdad
wea tiene_tomate = verdad
wea tiene_mayo   = falso

cachai (tiene_palta y tiene_tomate) {
  altiro("Completo italiano asegurado")
}

cachai (tiene_mayo o tiene_palta) {
  altiro("Algo rico sale igual")
}

cachai (no tiene_mayo) {
  altiro("Sin mayo, más sano pero menos rico")
}

---

mientras — bucle condicional

Repite un bloque mientras una condición sea verdad. Clásico para cuando no sabes cuántas veces vas a repetir algo.

// Freír sopaipillas hasta que se acabe la masa
wea masa_restante = 500  // gramos

mientras (masa_restante > 0) {
  altiro("Friendo sopaipilla... quedan " + masa_restante + "g de masa")
  masa_restante = masa_restante - 50
}

altiro("¡Se acabó la masa!")
// → Friendo sopaipilla... quedan 500g de masa
// → Friendo sopaipilla... quedan 450g de masa
// → ... (10 veces)
// → ¡Se acabó la masa!

Caution

Si la condición nunca se vuelve falsa, el bucle no termina nunca. Asegúrate de que algo dentro del bloque eventualmente la haga falsa — como restar de masa_restante arriba.

---

para — bucle sobre colecciones

Itera sobre cada elemento de una lista o los caracteres de un texto. Úsalo cuando sabes exactamente sobre qué vas a iterar.

// Ingredientes de una cazuela
wea ingredientes = ["vacuno", "papas", "choclo", "zanahoria", "zapallo"]

para (ingrediente en ingredientes) {
  altiro("Agregar " + ingrediente + " a la olla")
}
// → Agregar vacuno a la olla
// → Agregar papas a la olla
// → Agregar choclo a la olla
// → Agregar zanahoria a la olla
// → Agregar zapallo a la olla

También funciona con texto:

para (letra en "pebre") {
  altiro(letra)
}
// → p
// → e
// → b
// → r
// → e

---

cortala — salir del bucle

Interrumpe el bucle inmediatamente. Útil cuando ya encontraste lo que buscabas o ya tuviste suficiente.

wea completos_comidos = 0

mientras (verdad) {  // bucle infinito a propósito
  completos_comidos = completos_comidos + 1
  altiro("Completo número " + completos_comidos)

  cachai (completos_comidos >= 3) {
    altiro("Ya, basta. Me voy a morir.")
    cortala
  }
}
// → Completo número 1
// → Completo número 2
// → Completo número 3
// → Ya, basta. Me voy a morir.

En un para:

wea postres = ["manjar", "calzones rotos", "mote con huesillos", "leche asada"]

para (postre en postres) {
  cachai (postre == "mote con huesillos") {
    altiro("¡Este es! Me quedo con el " + postre)
    cortala
  }
  altiro("Pasando el " + postre + "...")
}
// → Pasando el manjar...
// → Pasando el calzones rotos...
// → ¡Este es! Me quedo con el mote con huesillos

Note

cortala afecta al bucle más cercano. Si tienes bucles anidados, solo sale del interior.

---

sigue — saltar a la siguiente iteración

Salta el resto del bloque actual y pasa directo a la siguiente vuelta del bucle. Útil para ignorar casos específicos.

// Preparando chorrillana — saltamos las cebollas porque alguien es resentido
wea toppings = ["papas fritas", "cebolla", "carne mechada", "huevo", "cebolla"]

para (topping en toppings) {
  cachai (topping == "cebolla") {
    altiro("Ugh, cebolla no gracias")
    sigue  // ← no agrega la cebolla, sigue con el siguiente
  }
  altiro("Agregando " + topping)
}
// → Agregando papas fritas
// → Ugh, cebolla no gracias
// → Agregando carne mechada
// → Agregando huevo
// → Ugh, cebolla no gracias

---

Combinando todo

Un ejemplo más completo: calcular el precio de un pedido de empanadas con descuento por cantidad.

wea pedido    = ["pino", "queso", "pino", "camarón", "pino"]
wea total     = 0
wea cant_pino = 0

para (sabor en pedido) {
  cachai (sabor == "camarón") {
    altiro("Sin camarones, se nos acabaron")
    sigue
  }

  wea precio = 0

  cachai (sabor == "pino") {
    precio    = 2500
    cant_pino = cant_pino + 1
  } si no {
    precio = 2000
  }

  total = total + precio
  altiro("+ Empanada de " + sabor + ": $" + precio)
}

altiro("---")
altiro("Empanadas de pino: " + cant_pino)
altiro("Total: $" + total)

+ Empanada de pino: $2500
+ Empanada de queso: $2000
+ Empanada de pino: $2500
Sin camarones, se nos acabaron
+ Empanada de pino: $2500
---
Empanadas de pino: 3
Total: $9500

---

Referencia rápida

// condicional
cachai (condicion) {
  // si es verdad
} si no {
  // si es falso
}

// mientras haya condición
mientras (condicion) {
  cortala  // salir
  sigue    // siguiente iteración
}

// para cada elemento
para (item en coleccion) {
  cortala  // salir
  sigue    // siguiente iteración
}