Salta ai contenuti
Ferris the Rust crabTutorial Rust

Errore Rust E0601: `main` function not found in crate (manca la funzione main)

E0601 significa: Rust voleva costruire un programma, ma non ha trovato da dove comincia. Ogni programma Rust parte da una funzione che si chiama esattamente main, scritta al livello più esterno di src/main.rs. Se manca, è scritta male o è nascosta dentro un modulo, ottieni questo errore. È molto comune quando copi un pezzo di codice da un tutorial o dalla documentazione di una libreria, e si corregge sempre in fretta. (Questa pagina fa parte di Errori del compilatore Rust spiegati.)

Il messaggio di errore

Sezione intitolata “Il messaggio di errore”
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`

Il compilatore dice: non ha trovato la funzione main nel crate, e ti consiglia di aggiungerne una a src/main.rs. Questo è il programma che produce l’errore:

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

Cosa significa

Sezione intitolata “Cosa significa”

Il ^ indica proprio la fine del file, subito dopo l’ultima }. Sembra strano, ma ha senso: rustc ha letto tutto il file cercando fn main, ed è arrivato in fondo senza trovarla. Non c’è una riga sbagliata da indicare; il problema è una riga che non c’è.

Il nome del crate nel messaggio dipende da come compili. Questo output viene da rustc src/main.rs, quindi il crate si chiama main, come il file. Con cargo run vedrai invece il nome del pacchetto preso da Cargo.toml, per esempio `main` function not found in crate `shop`. Stesso errore, stesse correzioni.

È come il copione di una commedia con scene bellissime ma senza «Atto primo, scena prima». Gli attori sono pronti, ma nessuno sa da dove inizia lo spettacolo.

Perché Rust si comporta così

Sezione intitolata “Perché Rust si comporta così”

Un binario Rust (un programma che esegui) ha bisogno di un unico punto d’ingresso fisso. Quando avvii il programma, il sistema operativo chiama main, e tutto il resto succede perché main lo chiama. Rust non tira a indovinare: non la prima funzione del file, non una funzione chiamata start, non Main. Il nome dev’essere esattamente main, tutto minuscolo, al livello più esterno del crate.

Il codice che non è un programma a sé, come un insieme di helper usati da altro codice, è una libreria. Una libreria non ha main e si scrive invece in src/lib.rs. Spesso E0601 significa che il codice va bene, ma sta nel tipo di crate sbagliato. Vedi Cargo e crate in Rust e Primi passi con Rust.

Come risolverlo

Sezione intitolata “Come risolverlo”

Soluzione 1: aggiungi una funzione main (o correggine il nome)

Sezione intitolata “Soluzione 1: aggiungi una funzione main (o correggine il nome)”

Scegli questa nella maggior parte dei casi: hai copiato delle funzioni da qualche parte, o hai iniziato a scrivere helper e non hai ancora scritto main. Aggiungi fn main() e chiama il tuo codice da lì:

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


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


fn main() { // ✅ il programma parte da qui
    let prices = [250, 199, 1200];
    println!("totale: {} centesimi", total(&prices));
    println!("media: {} centesimi", average(&prices));
}

Output:

totale: 1649 centesimi
media: 549 centesimi
▶ Provalo tu

Hai già una main? Allora controlla come l’hai scritta. fn Main(), fn mian() o fn main_() danno tutte esattamente lo stesso E0601, perché per Rust sono solo altre funzioni. Il nome distingue maiuscole e minuscole, e dev’essere una funzione: fn main(), con le tonde.

Soluzione 2: sposta main fuori dal modulo

Sezione intitolata “Soluzione 2: sposta main fuori dal modulo”

Scegli questa quando il messaggio dice the main function must be defined at the crate level (la funzione main va definita al livello del crate). Hai una main, ma sta dentro un mod, quindi in realtà è app::main, non il punto d’ingresso del programma:

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

Il programma che lo produce:

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

Metti la vera main al livello più esterno. Il codice nel modulo può restare lì; dagli un nome più chiaro come run e chiamalo da main:

mod app {
    pub fn run() {
        println!("Avvio del negozio...");
    }
}


fn main() { // ✅ al livello più esterno di src/main.rs
    app::run();
}

Output:

Avvio del negozio...
▶ Provalo tu

Lo stesso vale per i moduli in altri file: una pub fn main() in src/app.rs è app::main, mai il punto d’ingresso. Vedi Moduli in Rust.

Soluzione 3: rendilo una libreria, se non deve girare da solo

Sezione intitolata “Soluzione 3: rendilo una libreria, se non deve girare da solo”

Scegli questa quando il codice è un insieme di helper usati da altro codice, senza niente da «eseguire». Le librerie non hanno main. Crea il progetto con --lib:

Terminal window
cargo new --lib cart     # crea src/lib.rs: una libreria, main non serve
cargo new shop           # crea src/main.rs con fn main(): un programma

Metti gli helper in src/lib.rs, segna con pub ciò che altro codice può usare, e controllali con i test invece che con 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);
    }
}

Su una libreria esegui cargo build o cargo test. cargo run lì non funziona; dice error: a bin target must be available for `cargo run`, che è il modo di Cargo per dire «in questo pacchetto non c’è nessun programma». Se li vuoi entrambi, aggiungi un src/main.rs accanto a src/lib.rs. Usa la libreria tramite il nome del pacchetto:

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

Ora cargo run stampa total: 1649 cents. Vedi Cargo e crate in Rust e Test in Rust.

Dove lo incontri di solito

Sezione intitolata “Dove lo incontri di solito”

Incollare un pezzo di codice dalla documentazione o da un tutorial. Molti esempi mostrano solo una funzione o una struct, non un programma intero. Incollati in src/main.rs, danno E0601. Correzione: racchiudi le righe che fanno qualcosa in fn main() { ... }, e lascia fuori funzioni e struct. (Il Rust Playground si accorge che manca main e ti propone di compilare il codice invece di eseguirlo, quindi lì di solito non vedi questo errore.)

Il tuo editor segna in rosso l’ultima riga di main.rs. rust-analyzer esegue cargo check in background, quindi vedi E0601 sull’ultima riga mentre stai ancora scrivendo gli helper. Va bene così: il segno sparisce appena aggiungi fn main().

Programmi in più in src/bin/. Ogni file in src/bin/, come src/bin/import.rs, è un programma separato, e ognuno ha bisogno della sua fn main(). Correzione: aggiungi main a quel file, oppure sposta il codice condiviso in src/lib.rs. Vedi il link sui target di Cargo qui sotto.

Errori correlati

Sezione intitolata “Errori correlati”

Verifica veloce

Sezione intitolata “Verifica veloce”

Verifica veloce

1. Il tuo src/main.rs contiene fn Main() { ... }. Che cosa dice cargo run?

2. Stai scrivendo helper da usare in altro codice, senza niente da eseguire. Qual è la configurazione giusta?

3. rustc dice "the main function must be defined at the crate level". Che cosa non va?

Punteggio: 0 / 3

Per approfondire

Sezione intitolata “Per approfondire”