Padrões Aninhados

Combine padrões dentro de padrões para extrair dados de estruturas profundas em um único braço de match.

Qualquer posição de subpadrão aceita outro padrão completo. Isso permite extrair dados de estruturas arbitrariamente profundas — enum dentro de array, struct contendo enum, enum dentro de enum — sem precisar aninhar múltiplos match ou usar variáveis temporárias.

Enum dentro de array; struct contendo 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

No exemplo acima há três formas de aninhamento:

Enum em iteração — o match dentro do for desestrutura cada elemento do array diretamente.
Struct com campo de enum — o padrão Box { label, content: Maybe::Just(n) } casa o campo content com um subpadrão de enum, extraindo label e n em um único braço.
Enum em enum — Result2::Ok(Maybe::Just(n)) atravessa dois níveis de variante em uma linha.

A regra geral é: onde quer que um padrão espere um valor, você pode colocar outro padrão mais específico.

Encontre seu caminho pela Zolo

Comece por aqui