Ir al contenido
Descargar
Curso de Grost

Option: valores que pueden faltar

Módulo 2 · Datos y coleccionesLección 10 de 209 min de lectura4 retos
main.groPaso 1 de 4
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.}
Output

Este código todavía no imprime nada.

main.groPaso 2 de 4
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.
Output
50
0
main.groPaso 3 de 4
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.}
Output
No se vende
main.groPaso 4 de 4
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")
  }
}
Output
Cuesta 50
También con las flechas ← →

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

main.gro
module Tienda
fn precio(objeto: String) Option[int] {
if objeto == "espada" {
return 50
}
return none
}
fn _ready() void {
print(precio("espada"))
print(precio("hacha"))
}
Output50 <null>
ParteQué hace
Option[int]El tipo: un int, o nada. Entre corchetes va el tipo del valor
return 50Devuelve un valor
noneEl 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:

main.gro
module NoEsInt
fn precio(objeto: String) Option[int] {
if objeto == "espada" {
return 50
}
return none
}
fn _ready() void {
coste : int = precio("espada")
}
OutputParse Error: Cannot assign a value of type Option[int] to variable "coste" with specified type int. It may be none: check it with "if x is some(v)" or "match", or give a default with "?? value".

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:

main.gro
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)
}
Output50 50

Ú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 :=:

main.gro
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")
}
Outputespada: pagas 50 monedas hacha: no se vende
  • Si hay valor, el bloque se ejecuta y p es ese valor, ya como int.
  • p solo existe dentro del if.
  • El else es 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.

main.gro
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")
}
}
}
}
Outputespada: 50 hacha: 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:

main.gro
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")
}
Outputrey 0 0 nadie orco
  • 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

Retos: 0/4 resueltosSe guardan en este navegador
Reto 1 de 4sin resolver

¿Qué imprime este código?

main.gro
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)
}
3 es impar, así que la función devuelve none y ?? da el 0.
¿Es 3 un número par? Si la función da none, ?? usa lo de la derecha.
Reto 2 de 4sin resolver

Completa la función: devuelve la posición del nombre, o nada si no está.

Salida esperada
-1
main.gro
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)
}
El primer hueco es el tipo de "un int, o nada". El segundo, el valor vacío.
Solución:
main.gro
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)
}
Reto 3 de 4sin resolver

Con vida : Option[int], ¿qué expresión da un int que siempre puedes usar?

Un 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.
Solo una de ellas dice qué hacer cuando no hay valor.
Reto 4 de 4sin resolver

¿Qué imprime este código?

main.gro
mut cartas : []String = ["as"]
primera : Option[String] = cartas.pop_back()
segunda : Option[String] = cartas.pop_back()
print(primera ?? "vacío")
print(segunda ?? "vacío")
La primera vez saca "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?