Learn Rust Coding · Aula

Adaptadores e consumidores

Encadeamento de operações

Adaptadores e consumidores é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.

Dois tipos de métodos

Os métodos de iteradores se dividem em dois grupos:

Adaptadores retornam um novo iterador e são preguiçosos (map, filter, take)
Consumidores executam o iterador e produzem um valor final (sum, collect, for_each)

Todo pipeline consiste em zero ou mais adaptadores seguidos exatamente por um consumidor.

take: limite a quantidade

take(n) produz no máximo n itens e então para. Ele é um adaptador, portanto continua preguiçoso.

Ele funciona até mesmo com iteradores infinitos, obtendo apenas a quantidade solicitada.

fn main() {
    let first_three: Vec<i32> = (1..).take(3).collect();
    println!("{:?}", first_three);
}

skip: ignore os primeiros itens

skip(n) descarta os primeiros n itens e produz o restante. Combine-o com take para obter uma janela a partir do meio.

fn main() {
    let window: Vec<i32> = (1..=10).skip(3).take(4).collect();
    println!("{:?}", window);
}

enumerate: associe um índice

enumerate produz tuplas (index, value), começando a contagem em zero. Essa é a forma idiomática de obter posições sem um contador manual.

fn main() {
    let letters = vec!['a', 'b', 'c'];
    for (i, c) in letters.iter().enumerate() {
        println!("{} -> {}", i, c);
    }
}

zip: percorra dois iteradores juntos

zip associa itens de dois iteradores. Ele para quando o iterador mais curto fica sem itens.

Isso é útil para combinar dados paralelos, como nomes e pontuações.

fn main() {
    let names = vec!["Ana", "Ben"];
    let ages = vec![30, 25];
    for (name, age) in names.iter().zip(ages.iter()) {
        println!("{} is {}", name, age);
    }
}

rev: inverta a ordem

rev produz os itens do fim para o início. Ele exige um iterador de duas extremidades, fornecido por intervalos e fatias.

fn main() {
    let backwards: Vec<i32> = (1..=5).rev().collect();
    println!("{:?}", backwards);
}

chain: una dois iteradores

chain executa o primeiro iterador até o fim e depois continua com o segundo, como se fossem uma única sequência.

fn main() {
    let joined: Vec<i32> = (1..=3).chain(10..=12).collect();
    println!("{:?}", joined);
}

fold: crie um único valor

fold é o consumidor genérico. Ele começa com um acumulador e incorpora cada item a ele usando um fechamento.

Muitos consumidores, como sum, são casos especiais de fold.

fn main() {
    let product = (1..=5).fold(1, |acc, x| acc * x);
    println!("5! = {}", product);
}

any e all: consumidores booleanos

any retorna true se pelo menos um item satisfizer o predicado; all retorna true somente se todos os itens o satisfizerem.

Ambos fazem curto-circuito: param assim que a resposta é conhecida.

fn main() {
    let nums = vec![2, 4, 6, 7];
    println!("{}", nums.iter().all(|x| x % 2 == 0));
    println!("{}", nums.iter().any(|x| x % 2 != 0));
}

find e position

find retorna o primeiro item que corresponde a um predicado como um Option. Já position retorna o índice da primeira correspondência.

Ambos fazem curto-circuito ao encontrar a primeira correspondência.

fn main() {
    let nums = vec![1, 3, 5, 8, 9];
    println!("{:?}", nums.iter().find(|&&x| x % 2 == 0));
    println!("{:?}", nums.iter().position(|&x| x % 2 == 0));
}

Projetando pipelines

Crie pipelines empilhando adaptadores e terminando com um consumidor. Mantenha-os legíveis: uma operação por linha.

Como os adaptadores são preguiçosos, até mesmo cadeias longas fazem apenas uma passagem pelos dados.

Verificação rápida

Adaptadores versus consumidores.

Recapitulação

Você explorou o encadeamento de operações:

Os adaptadores (take, skip, enumerate, zip, rev, chain) permanecem preguiçosos
Os consumidores (fold, any, all, find, position) concluem o trabalho
Os consumidores booleanos e de busca fazem curto-circuito
Todo pipeline consiste em adaptadores seguidos por um consumidor

Perguntas Frequentes

A aula “Adaptadores e consumidores” é grátis?

Sim — o texto completo de “Adaptadores e consumidores” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.

O que vou aprender em “Adaptadores e consumidores”?

Encadeamento de operações Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Adaptadores e consumidores”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Learn Rust Coding