Médio Rust

Transformando e encadeando

Enunciado

Complete a função processar que recebe um Option<i32>, multiplica por 2 usando map e, se o resultado for maior que 10, soma 1 usando and_then. Retorne None se a condição não for satisfeita.

Requisitos

  • Use map para dobrar o valor.
  • Use and_then para verificar se é maior que 10 e somar 1.
  • Imprima o resultado para Some(6) e Some(3).

Código inicial

fn processar(op: Option<i32>) -> Option<i32> {
    // complete aqui
}

fn main() {
    println!("{:?}", processar(Some(6)));
    println!("{:?}", processar(Some(3)));
}

Saída esperada

Some(13)
None
Ver dica

map transforma o valor dentro de Some. and_then é usado quando a função de transformação também retorna Option.

Mostrar solução 
fn processar(op: Option<i32>) -> Option<i32> {
    op.map(|x| x * 2) // dobra o valor
      .and_then(|x| if x > 10 { Some(x + 1) } else { None }) // soma 1 se > 10
}

fn main() {
    println!("{:?}", processar(Some(6))); // Some(13)
    println!("{:?}", processar(Some(3))); // None
}

Passo a passo

  1. op.map(|x| x * 2) transforma Some(6) em Some(12) e Some(3) em Some(6). Se op fosse None, continuaria None.
  2. .and_then(|x| ...) recebe o Option resultante e aplica uma função que retorna Option.
  3. Dentro do and_then, verificamos se x > 10. Se sim, retornamos Some(x + 1); senão, None.
  4. Para Some(12), retorna Some(13). Para Some(6), retorna None.
  5. O main imprime os resultados com {:?} para mostrar Option.

Por que funciona

map aplica uma função ao valor dentro de Some e propaga None automaticamente. and_then é usado quando a função também retorna Option, evitando aninhamento Option<Option<T>>. A combinação permite encadear transformações e validações de forma fluida.

Erros comuns

  • Usar map em vez de and_then dentro da segunda etapa: op.map(|x| x * 2).map(|x| if x > 10 { Some(x + 1) } else { None }) resultaria em Option<Option<i32>>, não Option<i32>.
  • Esquecer de retornar None no else: if x > 10 { Some(x + 1) } sem else não compila, pois o tipo esperado é Option<i32>.

Outra forma de resolver

Usar filter e map:

op.map(|x| x * 2).filter(|&x| x > 10).map(|x| x + 1)

Prefira and_then quando a lógica de validação for mais complexa.

Saída esperada

Some(13)
None