Iterator

// A colecao esconde a estrutura (aqui, uma arvore binaria)
class No {
  constructor(
    readonly valor: number,
    readonly esq?: No,
    readonly dir?: No,
  ) {}
}

class Arvore {
  constructor(private raiz?: No) {}

  // Iterador em ordem, sem materializar a arvore inteira
  *[Symbol.iterator](): Generator<number> {
    function* percorrer(n?: No): Generator<number> {
      if (!n) return;
      yield* percorrer(n.esq);
      yield n.valor;          // pausa aqui e devolve o controle
      yield* percorrer(n.dir);
    }
    yield* percorrer(this.raiz);
  }
}

const arvore = new Arvore(
  new No(5, new No(3, new No(1)), new No(8, new No(7))),
);

// O cliente nao sabe que ha uma arvore embaixo
for (const v of arvore) console.log(v); // 1 3 5 7 8

// E ganha de graca tudo que fala a linguagem de iteracao
console.log([...arvore].filter((v) => v > 4)); // [5, 7, 8]

class No:
    def __init__(self, valor, esq=None, dir=None):
        self.valor, self.esq, self.dir = valor, esq, dir

class Arvore:
    def __init__(self, raiz=None):
        self._raiz = raiz

    # Iterador em ordem, sem materializar a arvore inteira
    def __iter__(self):
        def percorrer(n):
            if n is None:
                return
            yield from percorrer(n.esq)
            yield n.valor        # pausa aqui e devolve o controle
            yield from percorrer(n.dir)
        yield from percorrer(self._raiz)

arvore = Arvore(No(5, No(3, No(1)), No(8, No(7))))

# O cliente nao sabe que ha uma arvore embaixo
for v in arvore:
    print(v)  # 1 3 5 7 8

# E ganha de graca tudo que fala a linguagem de iteracao
print([v for v in arvore if v > 4])  # [5, 7, 8]