What are the different ways to return a value from a function in Rust?

Question

I came across following two ways:

#[derive(Debug)]
struct InputList(i32, i32, i32, i32);
#[derive(Debug)]
struct OutputList(i32, i32, i32, i32);

// Option 1
fn foo(input_list: InputList) -> OutputList {
    return OutputList(input_list.0, input_list.1, input_list.2, input_list.3);
}

// Option 2
fn bar(input_list: InputList) -> OutputList {
    OutputList(input_list.0, input_list.1, input_list.2, input_list.3)
}

fn main() {
    let input_list1 = InputList(1, 2, 3, 4);
    let input_list2 = InputList(6, 7, 8, 9);

    println!("foo() invocation output: {:?}", foo(input_list1));
    println!("bar() invocation output: {:?}", bar(input_list2));
}

Are these the only two options?

Answer 1

1. Have an expression without a semicolon in the tail position of the function.

    fn implicit() -> i32 { 1 }

   See also:

   • Are semicolons optional in Rust?

2. Use a return statement.

    fn explicit() -> i32 { return 1; }

   See also:

   • Why is using return as the last statement in a function considered bad style?
   • What's the difference between using the return statement and omitting the semicolon in Rust?

   ---

   Macros can contain return statements inside of them, so you might not always see the return .

    macro_rules: thing { ($val;expr) => {{ if $val { return 42; } }}; } fn macro() -> i32 { thing!(true); 99 }

   See also:

   • How do you unwrap a Result on Ok or return from the function on Err?
   • Is there a shortcut to unwrap or continue in a loop?

3. Use ? in a function that returns a type implementing Try .

    fn error() -> Option<i32> { None?; Some(42) }

   See also:

   • What is this question mark operator about?

Other cases

Depending on exactly how you categorize "returning from a function", these might also apply:

1. Use .await in an asynchronous function.

    async fn sometime() -> i32 { async { 42 }.await; 99 }

   This one is tricky and non-obvious because the compiler rewrites the function to contain a state machine and implement the Future trait. Every .await can return a Poll::Pending , but the caller of the function never has to think about this.

   See also:

   • What is the purpose of async/await in Rust?

2. Panicking.

    fn bail_out() -> Option<i32> { panic!() }

   Here, the function "returns", but you generally don't get a value.

   See also:

   • Suppress panic output in Rust when using panic::catch_unwind