mirror of
https://github.com/google/comprehensive-rust.git
synced 2025-04-04 09:49:46 +02:00
6d19292f16
I've taken some work by @fw-immunant and others on the new organization of the course and condensed it into a form amenable to a text editor and some computational analysis. You can see the inputs in `course.py` but the interesting bits are the output: `outline.md` and `slides.md`. The idea is to break the course into more, smaller segments with exercises at the ends and breaks in between. So `outline.md` lists the segments, their duration, and sums those durations up per-day. It shows we're about an hour too long right now! There are more details of the segments in `slides.md`, or you can see mostly the same stuff in `course.py`. This now contains all of the content from the v1 course, ensuring both that we've covered everything and that we'll have somewhere to redirect every page. Fixes #1082. Fixes #1465. --------- Co-authored-by: Nicole LeGare <dlegare.1001@gmail.com> Co-authored-by: Martin Geisler <mgeisler@google.com>
94 lines
2.9 KiB
Markdown
94 lines
2.9 KiB
Markdown
---
|
|
minutes: 5
|
|
---
|
|
|
|
# Try Conversions
|
|
|
|
The effective expansion of `?` is a little more complicated than previously indicated:
|
|
|
|
```rust,ignore
|
|
expression?
|
|
```
|
|
|
|
works the same as
|
|
|
|
```rust,ignore
|
|
match expression {
|
|
Ok(value) => value,
|
|
Err(err) => return Err(From::from(err)),
|
|
}
|
|
```
|
|
|
|
The `From::from` call here means we attempt to convert the error type to the
|
|
type returned by the function. This makes it easy to encapsulate errors into
|
|
higher-level errors.
|
|
|
|
## Example
|
|
|
|
```rust,editable
|
|
use std::error::Error;
|
|
use std::fmt::{self, Display, Formatter};
|
|
use std::fs::{self, File};
|
|
use std::io::{self, Read};
|
|
|
|
#[derive(Debug)]
|
|
enum ReadUsernameError {
|
|
IoError(io::Error),
|
|
EmptyUsername(String),
|
|
}
|
|
|
|
impl Error for ReadUsernameError {}
|
|
|
|
impl Display for ReadUsernameError {
|
|
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
|
|
match self {
|
|
Self::IoError(e) => write!(f, "IO error: {e}"),
|
|
Self::EmptyUsername(filename) => write!(f, "Found no username in {filename}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<io::Error> for ReadUsernameError {
|
|
fn from(err: io::Error) -> ReadUsernameError {
|
|
ReadUsernameError::IoError(err)
|
|
}
|
|
}
|
|
|
|
fn read_username(path: &str) -> Result<String, ReadUsernameError> {
|
|
let mut username = String::with_capacity(100);
|
|
File::open(path)?.read_to_string(&mut username)?;
|
|
if username.is_empty() {
|
|
return Err(ReadUsernameError::EmptyUsername(String::from(path)));
|
|
}
|
|
Ok(username)
|
|
}
|
|
|
|
fn main() {
|
|
//fs::write("config.dat", "").unwrap();
|
|
let username = read_username("config.dat");
|
|
println!("username or error: {username:?}");
|
|
}
|
|
```
|
|
|
|
<details>
|
|
|
|
The return type of the function has to be compatible with the nested functions it calls. For instance,
|
|
a function returning a `Result<T, Err>` can only apply the `?` operator on a function returning a
|
|
`Result<AnyT, Err>`. It cannot apply the `?` operator on a function returning an `Option<AnyT>` or `Result<T, OtherErr>`
|
|
unless `OtherErr` implements `From<Err>`. Reciprocally, a function returning an `Option<T>` can only apply the `?` operator
|
|
on a function returning an `Option<AnyT>`.
|
|
|
|
You can convert incompatible types into one another with the different `Option` and `Result` methods
|
|
such as `Option::ok_or`, `Result::ok`, `Result::err`.
|
|
|
|
|
|
It is good practice for all error types that don't need to be `no_std` to implement `std::error::Error`, which requires `Debug` and `Display`. The `Error` crate for `core` is only available in [nightly](https://github.com/rust-lang/rust/issues/103765), so not fully `no_std` compatible yet.
|
|
|
|
It's generally helpful for them to implement `Clone` and `Eq` too where possible, to make
|
|
life easier for tests and consumers of your library. In this case we can't easily do so, because
|
|
`io::Error` doesn't implement them.
|
|
|
|
A common alternative to a `From` implementation is `Result::map_err`, especially when the conversion only happens in one place.
|
|
|
|
</details>
|