Pular para o conteúdo
Ferris the Rust crabTutorial de Rust

Erro E0601 do Rust: `main` function not found in crate (sem fn main)

O E0601 quer dizer: o Rust queria compilar um programa, mas não encontrou onde ele começa. Todo programa em Rust começa numa função chamada exatamente main, escrita no nível de cima do src/main.rs. Se ela não existe, está com o nome errado ou está escondida dentro de um módulo, você recebe esse erro. Ele é muito comum quando você copia um trecho de um tutorial ou da documentação de uma biblioteca, e a correção é sempre rápida. Esta página faz parte do guia de erros do compilador.

A mensagem de erro

Seção intitulada “A mensagem de erro”
error[E0601]: `main` function not found in crate `main`
 --> src/main.rs:7:2
  |
7 | } // ❌ end of the file, and no `fn main` anywhere
  |  ^ consider adding a `main` function to `src/main.rs`

Em português: “a função main não foi encontrada no crate main”. A seta sugere acrescentar uma função main ao src/main.rs.

Este é o programa que gera o erro:

fn total(prices: &[u32]) -> u32 {
    prices.iter().sum()
}


fn average(prices: &[u32]) -> u32 {
    total(prices) / prices.len() as u32
} // ❌ end of the file, and no `fn main` anywhere

(O comentário quer dizer “fim do arquivo, e nenhum fn main em lugar nenhum”. Ele fica em inglês porque aparece na saída do compilador.)

O que significa

Seção intitulada “O que significa”

O ^ aponta para o fim do arquivo, logo depois do último }. Parece estranho, mas faz sentido: o rustc leu o arquivo inteiro procurando fn main e chegou ao fim sem encontrar. Não há uma linha errada para apontar; o problema é uma linha que não está lá.

O nome do crate na mensagem depende de como você compila. Esta saída vem de rustc src/main.rs, então o crate se chama main, por causa do arquivo. Com cargo run, você vê o nome do seu pacote no Cargo.toml, por exemplo `main` function not found in crate `shop`. É o mesmo erro, com as mesmas correções.

É como o roteiro de uma peça com ótimas cenas, mas sem “Ato 1, Cena 1”. Os atores estão prontos, mas ninguém sabe onde o espetáculo começa.

Por que o Rust faz isso

Seção intitulada “Por que o Rust faz isso”

Um binário em Rust (um programa que você roda) precisa de um ponto de entrada fixo. Quando você inicia o programa, o sistema operacional chama main, e todo o resto acontece porque main chama. O Rust não tenta adivinhar: não é a primeira função do arquivo, nem uma função chamada start, nem Main. O nome tem que ser exatamente main, tudo em minúsculas, no nível de cima do crate.

Um código que não é um programa por si só, como um conjunto de funções auxiliares que outro código usa, é uma biblioteca. Uma biblioteca não tem main e fica no src/lib.rs. Muitas vezes o E0601 quer dizer que o código está certo, mas está no tipo errado de crate. Veja Crates binário e biblioteca juntos e Primeiros passos.

Como corrigir

Seção intitulada “Como corrigir”

Correção 1: Acrescente uma função main (ou corrija o nome dela)

Seção intitulada “Correção 1: Acrescente uma função main (ou corrija o nome dela)”

Escolha esta na maioria das vezes: você copiou funções de algum lugar, ou começou a escrever funções auxiliares e ainda não escreveu a main. Acrescente fn main() e chame o seu código a partir dela:

fn total(prices: &[u32]) -> u32 {
    prices.iter().sum()
}


fn average(prices: &[u32]) -> u32 {
    total(prices) / prices.len() as u32
}


fn main() { // ✅ o programa começa aqui
    let prices = [250, 199, 1200];
    println!("total: {} centavos", total(&prices));
    println!("média: {} centavos", average(&prices));
}

Saída:

total: 1649 centavos
média: 549 centavos
▶ Experimente você mesmo

Já tem uma main? Então confira como ela está escrita. fn Main(), fn mian() ou fn main_() dão exatamente o mesmo E0601, porque para o Rust elas são só outras funções. O nome diferencia maiúsculas de minúsculas, e precisa ser uma função: fn main(), com os parênteses.

Correção 2: Tire a main de dentro do módulo

Seção intitulada “Correção 2: Tire a main de dentro do módulo”

Escolha esta quando a mensagem diz the main function must be defined at the crate level (a função main precisa ser definida no nível do crate). Você tem uma main, mas ela está dentro de um mod, então na verdade ela é app::main, e não o ponto de entrada do programa:

error[E0601]: `main` function not found in crate `main`
 --> src/main.rs:5:2
  |
5 | }
  |  ^ the main function must be defined at the crate level (in `src/main.rs`)
  |
note: here is a function named `main`
 --> src/main.rs:2:5
  |
2 |     pub fn main() { // ❌ inside a module, not at the top level
  |     ^^^^^^^^^^^^^
  = note: you have one or more functions named `main` not defined at the crate level
  = help: consider moving the `main` function definitions

A primeira nota mostra onde está a função chamada main; a segunda diz que ela não foi definida no nível do crate, e a ajuda sugere movê-la. O programa por trás disso:

mod app {
    pub fn main() { // ❌ inside a module, not at the top level
        println!("Starting the shop...");
    }
}

(O comentário em inglês diz “dentro de um módulo, não no nível de cima”.) Coloque a main de verdade no nível de cima. O código do módulo pode continuar lá; dê a ele um nome mais claro, como run, e chame-o a partir da main:

mod app {
    pub fn run() {
        println!("Abrindo a loja...");
    }
}


fn main() { // ✅ no nível de cima do src/main.rs
    app::run();
}

Saída:

Abrindo a loja...
▶ Experimente você mesmo

O mesmo vale para módulos em outros arquivos: uma pub fn main() em src/app.rs é app::main, nunca o ponto de entrada. Veja Módulos.

Correção 3: Transforme em biblioteca, se o código não foi feito para rodar sozinho

Seção intitulada “Correção 3: Transforme em biblioteca, se o código não foi feito para rodar sozinho”

Escolha esta quando o código é um conjunto de funções auxiliares que outro código usa, sem nada para “rodar”. Bibliotecas não têm main. Crie o projeto com --lib:

Terminal window
cargo new --lib cart     # cria src/lib.rs: uma biblioteca, sem main
cargo new shop           # cria src/main.rs com fn main(): um programa

Coloque as funções auxiliares no src/lib.rs, marque com pub o que outro código pode usar e confira tudo com testes, no lugar de cargo run:

src/lib.rs
pub fn total(prices: &[u32]) -> u32 {
    prices.iter().sum()
}


#[cfg(test)]
mod tests {
    use super::*;


    #[test]
    fn adds_prices() {
        assert_eq!(total(&[3, 4]), 7);
    }
}

Numa biblioteca, rode cargo build ou cargo test. O cargo run não funciona ali; ele diz error: a bin target must be available for `cargo run`, que é o jeito do Cargo de dizer “não há nenhum programa neste pacote”. Se você quer os dois, acrescente um src/main.rs ao lado do src/lib.rs. Ele usa a biblioteca pelo nome do pacote:

src/main.rs
fn main() {
    let sum = cart::total(&[250, 199, 1200]);
    println!("total: {} cents", sum);
}

Agora o cargo run imprime total: 1649 cents. Veja Crates binário e biblioteca juntos e Testes.

Onde você costuma ver esse erro

Seção intitulada “Onde você costuma ver esse erro”

Colando um trecho da documentação ou de um tutorial. Muitos exemplos mostram só uma função ou uma struct, e não um programa inteiro. Colados no src/main.rs, eles dão E0601. Correção: coloque as linhas que fazem alguma coisa dentro de fn main() { ... }, e deixe funções e structs do lado de fora. (O Rust Playground percebe quando falta a main e oferece compilar o código em vez de rodar, então lá você quase nunca vê esse erro.)

O editor marca a última linha do main.rs em vermelho. O rust-analyzer roda cargo check em segundo plano, então você vê o E0601 na última linha enquanto ainda está escrevendo as funções auxiliares. Tudo bem: a marca some assim que você acrescenta fn main().

Programas extras em src/bin/. Cada arquivo em src/bin/, como src/bin/import.rs, é um programa separado, e cada um precisa da sua própria fn main(). Correção: acrescente a main nesse arquivo, ou mova o código compartilhado para o src/lib.rs. Veja o link sobre os targets do Cargo mais abaixo.

Erros relacionados

Seção intitulada “Erros relacionados”

Teste o que aprendeu

Seção intitulada “Teste o que aprendeu”

Teste o que aprendeu

1. O seu src/main.rs tem fn Main() { ... }. O que o cargo run diz?

2. Você está escrevendo funções auxiliares para outro código usar, sem nada para rodar. Qual é a estrutura certa?

3. O rustc diz "the main function must be defined at the crate level". O que está errado?

Pontuação: 0 / 3

Para saber mais

Seção intitulada “Para saber mais”