What’s the difference between using the return statement and omitting the semicolon in Rust?

by

A return statement, otherwise known as an early return, will return an object from the last/innermost function-like scope. (Function-like because it applies to both closures and functions)

let x = || {
    return 0;
    println!("This will never happen!");
};
fn foo() {
    return 0;
    println!("This won't happen either");
}

An absent semicolon will instead evaluate the expression, like a return, but only return to the last/innermost scope, or in other words, it returns from within any set of {}.

let x = {           // Scope start
    0
};                  // Scope end

fn foo() -> usize { // Scope start
    0
}                   // Scope end

return statement will break out of any amount of nested scopes until it hits a function-like scope:

fn foo() -> usize {// <------------------------------------------\
    {                                                      //    |
        {                                                  //    |
            {                                              //    |
                {                                          //    |
                    {                                      //    |
                        {                                  //    |
                            {                              //    |
                                {                          //    |
                                    {                      //    |
                                        {                  //    |
                                            {              //    |
                                                 return 0; // ---/
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

The return statement also has a type of its own, that is to say that let x = return; will actually compile.

A return statement will evaluate to !, AKA the never type. You can’t name it in stable rust right now, but it will eventually become stable and usable.

More Related Contents:

  1. Lifetime error when creating a function that returns a value implementing serde::Deserialize
  2. How to fix lifetime error when function returns a serde Deserialize type?
  3. What are non-lexical lifetimes?
  4. What are Rust’s exact auto-dereferencing rules?
  5. Deriving a trait results in unexpected compiler error, but the manual implementation works
  6. Mutably borrow one struct field while borrowing another in a closure
  7. How do I convert a Vector of bytes (u8) to a string?
  8. Is it possible to use `impl Trait` as a function’s return type in a trait definition?
  9. Cannot borrow as immutable because it is also borrowed as mutable in function arguments
  10. What is the relation between auto-dereferencing and deref coercion?
  11. What is the return type of the indexing operation?
  12. I implemented a trait for another trait but cannot call methods from both traits
  13. How to update-or-insert on a Vec?
  14. Lifetime troubles sharing references between threads
  15. Moved variable still borrowing after calling `drop`?
  16. How do I include the end value in a range?
  17. How do I invoke a system command and capture its output?
  18. How to return a string (or similar) from Rust in WebAssembly?
  19. Can I destructure a tuple without binding the result to a new variable in a let/match/for statement?
  20. How to format output to a byte array with no_std and no allocator?
  21. Efficiently insert or replace multiple elements in the middle or at the beginning of a Vec?
  22. Calling a generic async function with a (mutably) borrowed argument
  23. What makes `impl Trait` as an argument “universal” and as a return value “existential”?
  24. Do all primitive types implement the Copy trait?
  25. Why does a mutable borrow of a closure through DerefMut not work?
  26. Why can Serde not derive Deserialize for a struct containing only a &Path?
  27. Creating a vector of zeros for a specific size
  28. What is the difference between immutable and const variables in Rust?
  29. How to print structs and arrays?
  30. Can Rust optimise away the bit-wise copy during move of an object someday?

Leave a Comment