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