Hello everyone. I can't understand why the early return of an error in the expression match is needed. How does it differ from the usual return error, and in what cases should it be used?
I'm reading chapter 9 which talks about panic!, one of the paragraphs talks about early return of the error, but I didn't find an explanation for why this is needed...
Can you copy-paste the relevant code snippet here?
Sure. The line Err (e) => return Err (e)
and the line Err (e) => Err (e)
. What is the difference?
#![allow(unused)]
fn main() {
use std::fs::File;
use std::io;
use std::io::Read;
fn read_username_from_file() -> Result<String, io::Error> {
let f = File::open("hello.txt");
let mut f = match f {
Ok(file) => file,
Err(e) => return Err(e),
};
let mut s = String::new();
match f.read_to_string(&mut s) {
Ok(_) => Ok(s),
Err(e) => Err(e),
}
}
}
Please use 3 backticks on each the top and the bottom of the code snippet. It's not really all that readable as it is now.
Sorry my bad. Corrected it
The return
keyword causes a function to return early. Otherwise, the function will continue executing until the end of its body.
When you write return Err(e)
, the function returns early and the rest of its body does not execute.
If you change this to Err(e)
, then the match
expression would have the value Err(e)
. The value of the match
expression gets assigned to the variable f
. Then the function continues executing on its next line.
In other words, without the return
, this would be equivalent to:
let temp;
match f {
Ok(file) => temp = file,
Err(e) => temp = Err(e),
}
let mut f = temp;
And this causes a type error because Err(e)
and file
have two different types, so you can't assign them to the same variable.
An explicit return
does what it says on the tin: it returns, immediately and unconditionally, from the enclosing function. An explicit return is needed whenever you want to return early from a function, without executing the rest of the function body.
In contrast, the last match
doesn't contain explicit return
s, because that match
expression is the very last expression in the function body, and the last expression of the function body is automatically returned, even without an explicit return
statement.
This is true in general as well: Rust is an expression language, and most language constructs, such as match
and if
, are expressions. Block-like language elements (including the aforementioned two kinds of expressions, as well as bare blocks and function bodies) are also expressions and yield the value of their last contained expression automatically.
Thanks a lot! Now I understand how it works!
Thanks a lot!
This topic was automatically closed 90 days after the last reply. We invite you to open a new topic if you have further questions or comments.