Option: valores que pueden faltar
fn precio(objeto: String) Option[int] {
if objeto == "espada" {
return 50
}
return none1 · Un valor que puede faltarLa tienda no vende de todo. Option[int] quiere decir "un int, o nada". return 50 devuelve un valor, y return none, el vacío.}Este código todavía no imprime nada.
fn precio(objeto: String) Option[int] {
if objeto == "espada" {
return 50
}
return none
}
print(precio("espada") ?? 0)
print(precio("hacha") ?? 0)2 · Un valor de repuesto con ??a ?? b da el valor que hay dentro de a o, si a es none, el de la derecha.50 0
fn precio(objeto: String) Option[int] {
if objeto == "espada" {
return 50
}
return none
}
if p := precio("hacha") {
print($"Cuesta {p}")
} else {
print("No se vende")3 · Solo si hay valorif p := ... ejecuta el bloque solo si hay valor, y dentro p es ese valor. Si no hay, se ejecuta el else.}No se vende
fn precio(objeto: String) Option[int] {
if objeto == "espada" {
return 50
}
return none
}
match precio("espada") {
some(p): {
print($"Cuesta {p}")
}
none: {4 · Los dos casos con matchsome(p) es el caso con valor y none, el vacío. Grost te obliga a escribir los dos, así que no te puedes olvidar del caso sin valor. print("No se vende")
}
}Cuesta 50
Buscas la llave en la mochila. A veces está y a veces no. ¿Qué devuelve una función que busca algo que puede no estar?
Ya viste una respuesta: find da -1 cuando no lo encuentra. Pero -1 parece un número
normal, y si te olvidas de comprobarlo, mochila[-1] te da el último objeto sin quejarse. El
error pasa desapercibido. En Grost, un valor que puede faltar tiene su propio tipo, Option,
y Grost no te deja usarlo sin antes comprobar si está.
Un valor que puede faltar
module Tienda
fn precio(objeto: String) Option[int] { if objeto == "espada" { return 50 } return none}
fn _ready() void { print(precio("espada")) print(precio("hacha"))}| Parte | Qué hace |
|---|---|
Option[int] | El tipo: un int, o nada. Entre corchetes va el tipo del valor |
return 50 | Devuelve un valor |
none | El vacío: “no hay nada” |
print muestra el valor que hay dentro, o <null> si está vacío. Sirve para mirar qué pasa,
pero para usar el valor tienes que sacarlo, como verás ahora.
Un Option no es un int
Un Option[int] puede estar vacío, así que Grost no te deja usarlo como si fuera un int:
module NoEsInt
fn precio(objeto: String) Option[int] { if objeto == "espada" { return 50 } return none}
fn _ready() void { coste : int = precio("espada")}El mensaje lo dice: “puede ser none; compruébalo con if o match, o da un valor por
defecto con ??”. Lo mismo pasa si intentas sumarlo o pasarlo donde va un int. Son las tres
formas de sacar el valor, una por sección.
Un valor de repuesto con ??
a ?? b da el valor de a o, si a está vacío, b. El resultado ya es un int normal:
module Repuesto
fn precio(objeto: String) Option[int] { if objeto == "espada" { return 50 } return none}
fn _ready() void { mut monedas : int = 100 monedas -= precio("espada") ?? 0 print(monedas) monedas -= precio("hacha") ?? 0 print(monedas)}Úsalo cuando haya un valor que tenga sentido “si no hay nada”: 0 monedas, un nombre como
"nadie", la velocidad normal.
Solo si hay valor: if :=
Cuando quieres hacer algo solo si hay valor, usa if con :=:
module Comprar
fn precio(objeto: String) Option[int] { if objeto == "espada" { return 50 } return none}
fn comprar(objeto: String) void { if p := precio(objeto) { print($"{objeto}: pagas {p} monedas") } else { print($"{objeto}: no se vende") }}
fn _ready() void { comprar("espada") comprar("hacha")}- Si hay valor, el bloque se ejecuta y
pes ese valor, ya comoint. psolo existe dentro delif.- El
elsees opcional: se ejecuta cuando el Option está vacío.
He visto if x is some(p). ¿Es distinto?
Hace lo mismo: if precio(objeto) is some(p) { ... } ejecuta el bloque cuando hay valor, con
p dentro. Usa la forma que te resulte más clara.
Los dos casos con match
match trata los dos casos por separado: some(p) cuando hay valor y none cuando no.
module Casos
fn precio(objeto: String) Option[int] { if objeto == "espada" { return 50 } return none}
fn _ready() void { tienda : []String = ["espada", "hacha"] for objeto : String in tienda { match precio(objeto) { some(p): { print($"{objeto}: {p}") } none: { print($"{objeto}: agotado") } } }}Si quitas el caso none, Grost te avisa de que falta: un match sobre un Option tiene que
tratar los dos casos (o usar _).
Option en listas, diccionarios y variables
No solo tus funciones devuelven un Option. Te lo vas a encontrar en muchos sitios:
module Donde
mut objetivo : Option[String] = none
fn _ready() void { mut cartas : []String = ["as", "rey"] ultima : Option[String] = cartas.pop_back() print(ultima ?? "ninguna") precios : Dictionary[String, int] = { "espada": 50 } print(precios.get("arco") ?? 0) puntos : []int = [30, 10] print(puntos[5] ?? 0) print(objetivo ?? "nadie") objetivo = "orco" print(objetivo ?? "nadie")}pop_back()quita el último valor de una lista y lo devuelve. Es un Option porque la lista podría estar vacía.get(clave)de un diccionario, sin valor por defecto, da un Option.- Con
??detrás, una posición o una clave que no existe ya no es un error: da el valor de la derecha. - Una variable
Option[String]puede empezar vacía (none) y recibir un valor después, como el enemigo al que apunta una torreta.
Hora de practicar
¿Qué imprime este código?
fn doble_si_par(n: int) Option[int] {
if n % 2 == 0 {
return n * 2
}
return none
}
fn _ready() void {
print(doble_si_par(3) ?? 0)
}none y ?? da el 0.none, ?? usa lo de la derecha.Completa la función: devuelve la posición del nombre, o nada si no está.
-1
fn buscar(nombres: []String, quien: String) {
for i : int in range(nombres.size()) {
if nombres[i] == quien {
return i
}
}
return
}
fn _ready() void {
print(buscar(["Ana", "Leo"], "Zoe") ?? -1)
}int, o nada". El segundo, el valor vacío.fn buscar(nombres: []String, quien: String) Option[int] {
for i : int in range(nombres.size()) {
if nombres[i] == quien {
return i
}
}
return none
}
fn _ready() void {
print(buscar(["Ana", "Leo"], "Zoe") ?? -1)
}Con vida : Option[int], ¿qué expresión da un int que siempre puedes usar?
Option[int] no es un int hasta que lo compruebas: sumarlo, convertirlo con int() o pedirle .value son errores. vida ?? 0 da su valor, o 0 si no tiene.¿Qué imprime este código?
mut cartas : []String = ["as"]
primera : Option[String] = cartas.pop_back()
segunda : Option[String] = cartas.pop_back()
print(primera ?? "vacío")
print(segunda ?? "vacío")"as". La segunda, la lista ya está vacía y da none, así que ?? usa "vacío".pop_back() saca el último valor de la lista. ¿Qué queda después de sacar el primero?