Matching on the result of File::create - error-handling

Question

I am trying to write a library which must open files and I want to handle the Result type used by std::fs::File::create. I cannot figure out how to match on the return result given this wrapper function:
use std::fs::File;
use std::path::Path;
use std::fs::File;
use std::path::Path;
pub fn allocate(path:& str) -> File{
let mut file = File::create(Path::new(path));
}
which is then invoked:
mod whisper;
use std::io::Write;
fn main(){
let mut handle = whisper::allocate("./a_file.wsp");
match handle {
Ok(_) => println!("success!"),
Err(e) => println!("sorry, got {}",e),
}
return;
}
but the code doesn't compile due to a type mismatch:
Xaviers-MacBook-Pro:graphite-rust xavierlange$ cargo build
Compiling graphite-rust v0.0.1 (file:///Users/xavierlange/code/viasat/graphite-rust)
src/main.rs:8:5: 8:10 error: mismatched types:
expected `std::fs::File`,
found `core::result::Result<_, _>`
(expected struct `std::fs::File`,
found enum `core::result::Result`) [E0308]
src/main.rs:8 Ok(_) => println!("hi!"),
^~~~~
src/main.rs:9:5: 9:11 error: mismatched types:
expected `std::fs::File`,
found `core::result::Result<_, _>`
(expected struct `std::fs::File`,
found enum `core::result::Result`) [E0308]
src/main.rs:9 Err(e) => println!("sorry, got {}",e),
^~~~~~
error: aborting due to 2 previous errors
Could not compile `graphite-rust`.
The signature for std::fs::File::create is fn create<P: AsRef<Path>>(path: P) -> Result<File> so shouldn't I be expecting to "unwrap" the value using match? Why is it expecting a File value?

Answer 1

Let's look at a simplified version of your code, an MCVE. It's very useful to create small examples when programming, as it helps you concentrate on a single problem at a time:
use std::fs::File;
use std::path::Path;
fn allocate(path: &str) -> File {
File::create(Path::new(path))
}
fn main() {}
(I also took the liberty of aligning your code with the prevailing Rust style; I highly encourage you to learn it and love it for better community interaction!)
This gives the same error when run on the Playpen:
<anon>:5:5: 5:34 error: mismatched types:
expected `std::fs::File`,
found `core::result::Result<std::fs::File, std::io::error::Error>`
(expected struct `std::fs::File`,
found enum `core::result::Result`) [E0308]
<anon>:5 File::create(Path::new(path))
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The problem is because you have defined the return type of your function as a File, but the body of your function is returning a Result!
fn allocate(path: &str) -> File
You need to ensure that the type on your function and what the function does align. The simplest is to unwrap the result, which causes a thread panic on failure cases.
fn allocate(path: &str) -> File {
File::create(Path::new(path)).unwrap()
}
You could also return a Result of your own, and then force the caller to deal with failure (my preferred choice):
use std::io;
fn allocate(path: &str) -> io::Result<File> {
File::create(Path::new(path))
}
The other way of looking at your error is this half:
use std::fs::File;
fn allocate() -> File { unimplemented!() }
fn main() {
match allocate() {
Ok(..) => println!("OK!"),
Err(..) => println!("Bad!"),
}
}
Here, we are trying to match on a File, but File is not an enumeration with the variants Ok and Err - that would be Result! Thus, you get an error indicating such:
<anon>:7:9: 7:15 error: mismatched types:
expected `std::fs::File`,
found `core::result::Result<_, _>`
(expected struct `std::fs::File`,
found enum `core::result::Result`) [E0308]
<anon>:7 Ok(..) => println!("OK!"),
^~~~~~