Why does Rust not have a return value in the main function, and how to return a value anyway?

Question

In Rust the main function is defined like this:

fn main() {

}

This function does not allow for a return value though. Why would a language not allow for a return value and is there a way to return something anyway? Would I be able to safely use the C exit(int) function, or will this cause leaks and whatnot?

Answer 1

As of Rust 1.26, main can return a Result:

use std::fs::File;

fn main() -> Result<(), std::io::Error> {
    let f = File::open("bar.txt")?;

    Ok(())
}

The returned error code in this case is 1 in case of an error. With File::open("bar.txt").expect("file not found"); instead, an error value of 101 is returned (at least on my machine).

Also, if you want to return a more generic error, use:

use std::error::Error;
...

fn main() -> Result<(), Box<dyn Error>> {
   ...
}

Answer 2

This is no longer the recommended way to exit with a status, see other answers about returning from main and types that implement Termination

---

std::process::exit(code: i32) is the way to exit with a code.

---

Rust does it this way so that there is a consistent explicit interface for returning a value from a program, wherever it is set from. If main starts a series of tasks then any of these can set the return value, even if main has exited.

Rust does have a way to write a main function that returns a value, however it is normally abstracted within stdlib. See the documentation on writing an executable without stdlib for details.

As noted in the functions docs, this will exit immediately without running any destructors, so should be used with care:

Note that because this function never returns, and that it terminates the process, no destructors on the current stack or any other thread’s stack will be run. If a clean shutdown is needed it is recommended to only call this function at a known point where there are no more destructors left to run.

Answer 3

As was noted by others, std::process::exit(code: i32) is the way to go here

More information about why is given in RFC 1011: Process Exit. Discussion about the RFC is in the pull request of the RFC.

Answer 4

The reddit thread on this has a "why" explanation:

Rust certainly could be designed to do this. It used to, in fact.

But because of the task model Rust uses, the fn main task could start a bunch of other tasks and then exit! But one of those other tasks may want to set the OS exit code after main has gone away.

Calling set_exit_status is explicit, easy, and doesn't require you to always put a 0 at the bottom of main when you otherwise don't care.

Answer 5

Try:

use std::process::ExitCode;

fn main() -> ExitCode {
  ExitCode::from(2)
}

Take a look in doc

or:

use std::process::{ExitCode, Termination};

pub enum LinuxExitCode { E_OK, E_ERR(u8) }

impl Termination for LinuxExitCode {
   fn report(self) -> ExitCode {
     match self {
       LinuxExitCode::E_OK => ExitCode::SUCCESS,
       LinuxExitCode::E_ERR(v) => ExitCode::from(v)
     }
   }
}

fn main() -> LinuxExitCode {
    LinuxExitCode::E_ERR(3)
}

Answer 6

You can set the return value with std::os::set_exit_status.