--- title: "E0107: Argumentos Genéricos Incorretos no Rust" url: "https://rustlang.com.br/erros/e0107-argumentos-genericos-errados/" markdown_url: "https://rustlang.com.br/erros/e0107-argumentos-genericos-errados.MD" description: "Como resolver o erro E0107 do Rust: número incorreto de argumentos genéricos. Aprenda a usar parâmetros de tipo, lifetime e const generics corretamente." date: "2026-02-23" author: "Equipe Rust Brasil" --- # E0107: Argumentos Genéricos Incorretos no Rust Como resolver o erro E0107 do Rust: número incorreto de argumentos genéricos. Aprenda a usar parâmetros de tipo, lifetime e const generics corretamente. # E0107: Argumentos Genéricos Incorretos O erro **E0107** ocorre quando você fornece o número **errado de argumentos genéricos** (tipo, lifetime ou const) ao usar um tipo ou função genérica. É como chamar uma função com o número errado de argumentos, mas para parâmetros de tipo. ## A Mensagem de Erro ``` error[E0107]: this struct takes 2 generic arguments but 1 generic argument was supplied --> src/main.rs:3:16 | 3 | let mapa: HashMap = HashMap::new(); | ^^^^^^^ ------- supplied 1 generic argument | | | expected 2 generic arguments | note: struct defined here, with 2 generic parameters: `K`, `V` ``` Outra variação — argumentos demais: ``` error[E0107]: this struct takes 1 generic argument but 2 generic arguments were supplied --> src/main.rs:3:16 | 3 | let lista: Vec = Vec::new(); | ^^^ ------ help: remove this generic argument | | | expected 1 generic argument ``` ## O Que Significa Tipos genéricos no Rust são definidos com um número específico de parâmetros de tipo. Quando você usa o tipo, precisa fornecer exatamente o número correto: - `Vec` — 1 parâmetro de tipo - `HashMap` — 2 parâmetros de tipo - `Result` — 2 parâmetros de tipo - `Option` — 1 parâmetro de tipo Se você fornece menos ou mais parâmetros que o esperado, o compilador rejeita o código. Em alguns casos, o compilador pode inferir os tipos automaticamente (e você não precisa especificá-los), mas quando você começa a anotar, precisa fornecer todos. ## Código com Erro ```rust use std::collections::HashMap; fn main() { // ERRO: HashMap precisa de 2 argumentos (chave e valor) let mapa: HashMap = HashMap::new(); // ERRO: Vec precisa de apenas 1 argumento let lista: Vec = Vec::new(); // ERRO: Option precisa de 1 argumento let valor: Option = Some(42); } ``` Com funções genéricas: ```rust fn converter(valor: T) -> U { todo!() } fn main() { // ERRO: a função precisa de 2 argumentos genéricos let resultado = converter::(42); } ``` Com lifetimes: ```rust struct Referencia<'a, 'b> { primeiro: &'a str, segundo: &'b str, } fn criar(a: &str, b: &str) -> Referencia { // ERRO: Referencia precisa de 2 lifetimes Referencia { primeiro: a, segundo: b } } ``` ## Como Resolver ### Solução 1: Fornecer o Número Correto de Argumentos ```rust use std::collections::HashMap; fn main() { // HashMap — 2 argumentos let mapa: HashMap = HashMap::new(); // Vec — 1 argumento let lista: Vec = Vec::new(); // Result — 2 argumentos let resultado: Result = Ok("sucesso".to_string()); // Option — 1 argumento let valor: Option = Some(42); } ``` ### Solução 2: Deixar o Compilador Inferir os Tipos Em muitos casos, você não precisa especificar os tipos — o compilador infere: ```rust use std::collections::HashMap; fn main() { // O compilador infere HashMap<&str, i32> pelo uso let mut mapa = HashMap::new(); mapa.insert("chave", 42); // O compilador infere Vec pelos elementos let lista = vec![1, 2, 3]; // Inferência parcial com _ (turbofish parcial) let numeros: Vec<_> = (1..10).collect(); } ``` ### Solução 3: Usar Turbofish para Funções Genéricas A sintaxe `::<>` (turbofish) especifica argumentos genéricos em chamadas de função: ```rust fn main() { // Todos os argumentos genéricos let resultado = "42".parse::().unwrap(); // Collect com tipo especificado let numeros: Vec = (1..5).collect(); // Ou com turbofish: let numeros = (1..5).collect::>(); } ``` ### Solução 4: Corrigir Lifetimes ```rust struct Referencia<'a, 'b> { primeiro: &'a str, segundo: &'b str, } // Especifique todos os lifetimes necessários fn criar<'a, 'b>(a: &'a str, b: &'b str) -> Referencia<'a, 'b> { Referencia { primeiro: a, segundo: b } } ``` Ou simplifique usando um único lifetime quando possível: ```rust struct Referencia<'a> { primeiro: &'a str, segundo: &'a str, } fn criar<'a>(a: &'a str, b: &'a str) -> Referencia<'a> { Referencia { primeiro: a, segundo: b } } ``` ### Solução 5: Tipos com Default Genéricos Alguns tipos têm parâmetros genéricos com valores padrão. `HashMap`, por exemplo, tem um terceiro parâmetro opcional para o hasher: ```rust use std::collections::HashMap; // HashMap // Normalmente usamos apenas K e V: let mapa: HashMap = HashMap::new(); // Mas podemos especificar um hasher customizado: use std::hash::BuildHasherDefault; use std::collections::hash_map::DefaultHasher; let mapa: HashMap> = HashMap::default(); ``` ## Referência Rápida de Tipos Genéricos Comuns | Tipo | Parâmetros | Exemplo | |---|---|---| | `Vec` | 1 tipo | `Vec` | | `Option` | 1 tipo | `Option` | | `Result` | 2 tipos | `Result` | | `HashMap` | 2 tipos | `HashMap>` | | `BTreeMap` | 2 tipos | `BTreeMap` | | `Box` | 1 tipo | `Box` | | `Rc` | 1 tipo | `Rc` | | `Arc` | 1 tipo | `Arc>>` | | `Cow<'a, B>` | 1 lifetime + 1 tipo | `Cow<'a, str>` | ## Veja Também - [E0046: Items Faltando na Implementação](/erros/e0046-items-faltando-impl/) - [E0277: Trait Não Implementado](/erros/e0277-trait-nao-implementado/) - [E0308: Tipos Incompatíveis](/erros/e0308-tipos-incompativeis/) - [Glossário Rust](/glossario/) - [Documentação oficial: E0107](https://doc.rust-lang.org/error_codes/E0107.html)