Opcionales

En esta página

Cuando un valor puede simplemente no existir — y eso no es un fallo — usa el tipo opcional T?. El tipo acepta el valor nil (ausente) o un valor del tipo T (presente). No existe Option.Some / Option.None en Zolo: la presencia se representa directamente con el valor.

T?, nil, ?? (coalescing), ?. (encadenamiento seguro), if let como instrucción y como expresión.

05-optionals.zolo

Playground

// Feature: Optionals — `T?`, `nil`, `??`, `?.`, `if let`

// Syntax: type `T?`, value `nil` or `T`, operators `??` and `?.`

// When to use: missing value that is NOT an error (e.g., lookup miss).


// -- Optional type ---------------------------------------------

let name: str? = nil
let age: int? = 42
print(name)  // nil

print(age)  // 42


// -- ?? — null coalescing (default) ---------------------------

let display_name = name ?? "Anonymous"
let display_age = age ?? 0
print("{display_name}, {display_age}")

// expected: Anonymous, 42


// -- ?. — optional chaining (safe access) ---------------------

struct Address {
  city: str,
  zip: str,
}

struct User {
  name: str,
  address: Address,
}

let u = User { name: "Alice", address: Address { city: "Porto", zip: "01000" } }
let city = u?.address?.city ?? "Unknown"
print(city)

// expected: Porto


// -- if let — unwraps if non-nil ------------------------------

let v: int? = 42
if let x = v {
  print("got {x}")
} else {
  print("empty")
}

// expected: got 42


let none: int? = nil
if let x = none {
  print("got {x}")
} else {
  print("empty")
}

// expected: empty


// -- if let as expression -------------------------------------

let doubled = if let x = v { x * 2 } else { 0 }
print(doubled)  // 84


// -- Function returning an optional ---------------------------

fn find(id: int) -> str? {
  if id == 1 { return "Alice" }
  if id == 2 { return "Bob" }
  return nil
}

print(find(1) ?? "not found")  // Alice

print(find(3) ?? "not found")  // not found


// -- Chaining ?? with multiple defaults -----------------------

let a: str? = nil
let b: str? = nil
let c: str? = "value C"
print(a ?? b ?? c ?? "fallback")  // value C

Los tres operadores principales:

?? devuelve el lado derecho cuando el lado izquierdo es nil — encadenable (a ?? b ?? c).
?. accede a un campo o llama a un método; si el receptor es nil, el resultado completo se convierte en nil en lugar de entrar en pánico.
if let x = opcional { ... } desempaqueta el valor; el bloque else cubre el caso nil.

Usa T? + ?? para ausencias esperadas (una búsqueda que puede no encontrar nada). Usa Result<T, E> cuando la ausencia lleva información de error.

Desafío

Agrega una cuarta llamada find(4) ?? "not found" al ejemplo. Luego crea una función find_upper(id: int) -> str? que use ?. para llamar a .to_upper() sobre el resultado de find — ¿qué ocurre para id == 99?

Consulta también

Editar en GitHub