Patrones Anidados

Combina patrones dentro de patrones para extraer datos de estructuras profundas en una sola rama de match.

Cualquier posición de subpatrón acepta otro patrón completo. Esto permite extraer datos de estructuras arbitrariamente profundas — enum dentro de array, struct que contiene enum, enum dentro de enum — sin necesidad de anidar múltiples match ni usar variables temporales.

Enum dentro de array; struct que contiene enum; enum dentro de enum.

12-nested-patterns.zolo

Playground

// Feature: Nested patterns — combining everything
// Syntax: subpatterns inside subpatterns
// When to use: extract data from deep structures in a single pass
// without nesting `match` or `if let`.

enum Maybe<T> {
  Just(T),
  Nothing,
}

// Enum INSIDE array.
let opts = [Maybe.Just(1), Maybe.Nothing, Maybe.Just(3)]

for o in opts {
  let label = match o {
    Maybe::Just(n) => "got {n}",
    Maybe::Nothing => "none",
  }
  print(label)
}

// Struct containing an enum.
struct Box {
  label: str,
  content: Maybe<int>,
}

let b1 = Box { label: "alpha", content: Maybe.Just(10) }
let b2 = Box { label: "beta", content: Maybe.Nothing }

fn describe_box(b: Box) -> str {
  return match b {
    Box { label, content: Maybe::Just(n) } => "{label} = {n}",
    Box { label, content: Maybe::Nothing } => "{label} = empty",
  }
}

print(describe_box(b1))  // alpha = 10
print(describe_box(b2))  // beta = empty

// Enum nested in enum.
enum Result2 {
  Ok(Maybe<int>),
  Err(str),
}

let r1 = Result2.Ok(Maybe.Just(42))
let r2 = Result2.Ok(Maybe.Nothing)
let r3 = Result2.Err("failed")

fn classify(r: Result2) -> str {
  return match r {
    Result2::Ok(Maybe::Just(n)) => "ok with {n}",
    Result2::Ok(Maybe::Nothing) => "ok but empty",
    Result2::Err(msg) => "error: {msg}",
  }
}

print(classify(r1))  // ok with 42
print(classify(r2))  // ok but empty
print(classify(r3))  // error: failed

El ejemplo anterior muestra tres formas de anidamiento:

Enum en iteración — el match dentro del for desestructura cada elemento del array directamente.
Struct con campo enum — el patrón Box { label, content: Maybe::Just(n) } hace coincidir el campo content con un subpatrón de enum, extrayendo label y n en una sola rama.
Enum en enum — Result2::Ok(Maybe::Just(n)) atraviesa dos niveles de variante en una línea.

La regla general es: dondequiera que un patrón espere un valor, puedes colocar otro patrón más específico.

Encuentra tu camino por Zolo

Empieza aquí