Quiz 11 - Introdução

1. **O que caracteriza uma Closures em Rust?**

É uma função que nunca termina

É uma função anônima que pode capturar variáveis do ambiente onde foi definida

É um tipo de dado para guardar arquivos

É um comando do terminal > **Explicação**: Closures são flexíveis porque "lembram" do contexto (escopo) em que foram criadas.

2. **Qual a sintaxe para definir parâmetros em uma Closure?**

`(a, b) { ... }`

`|a, b| { ... }`

`[a, b] { ... }`

` { ... }` > **Explicação**: Os tubos (pipes) `| |` são usados para os parâmetros das closures.

3. **Iteradores em Rust são "preguiçosos" (lazy). O que isso significa?**

Eles param de funcionar se o computador ficar lento

Eles não realizam nenhuma ação até que um método consumidor seja chamado

Eles só funcionam em computadores antigos

Eles demoram muito para compilar > **Explicação**: A computação só acontece quando você realmente pede o resultado final (ex: com `collect` ou `for`).

4. **Qual método transforma um item de um iterador em outro valor?**

`filter`

`find`

`map`

`take` > **Explicação**: O `map` aplica uma função a cada elemento e retorna o resultado transformado.

5. **O método `filter` serve para:**

Deletar todos os itens da coleção

Manter apenas os itens que satisfazem uma condição booleana

Mudar o tipo da coleção

Imprimir os itens na tela > **Explicação**: `filter` cria um novo iterador contendo apenas os elementos desejados.

6. **Para converter um iterador de volta em uma coleção (como um `Vec`), usamos:**

`build`

`finish`

`collect`

`gather` > **Explicação**: `collect` é o método mais versátil para consumir um iterador e gerar uma coleção.

7. **Qual a vantagem das "Abstrações de Custo Zero" no Rust?**

O código é grátis para baixar

O uso de ferramentas de alto nível (como iteradores) tem a mesma performance de um loop manual de baixo nível

Não precisamos pagar impostos sobre o software

O compilador não consome memória > **Explicação**: O compilador otimiza as abstrações para que elas não gerem sobrecarga de performance.

8. **Closures podem ser passadas como argumentos para outras funções?**

Sim, e isso é muito comum em APIs do Rust

Não, elas só funcionam dentro de `main`

Sim, mas apenas se não capturarem variáveis

Sim, mas o programa fica 10x mais lento > **Explicação**: Passar comportamento via closures é um padrão fundamental no Rust.

9. **O método `.iter()` em uma coleção cria um iterador de:**

Cópias dos dados

Referências imutáveis aos itens

Referências mutáveis aos itens

Donos (posse) dos itens > **Explicação**: `.iter()` permite ler os dados sem movê-los ou alterá-los.

10. **A diferença entre `.iter()` e `.into_iter()` é que o segundo:**

É 2x mais rápido

Consome a coleção, movendo a posse dos itens para o iterador

É apenas para números inteiros

Só funciona em arrays > **Explicação**: `into_iter` transforma a coleção em um iterador que possui os dados (move usage).