# 1.0.0[−][src]Macro std::try

    macro_rules! try {
        ( $ expr : expr ) => { ... };
        ( $ expr : expr , ) => { ... };
    }

Helper macro for reducing boilerplate code for matching `Result` together with converting downstream errors.

The `?` operator was added to replace `try!` and should be used instead. Furthermore, `try` is a reserved word in Rust 2018, so if you must use it, you will need to use the raw-identifier syntax: `r#try`.

`try!` matches the given `Result`. In case of the `Ok` variant, the expression has the value of the wrapped value.

In case of the `Err` variant, it retrieves the inner error. `try!` then performs conversion using `From`. This provides automatic conversion between specialized errors and more general ones. The resulting error is then immediately returned.

Because of the early return, `try!` can only be used in functions that return `Result`.

# Examples

    use std::io;
    use std::fs::File;
    use std::io::prelude::*;

    enum MyError {
        FileWriteError
    }

    impl From<io::Error> for MyError {
        fn from(e: io::Error) -> MyError {
            MyError::FileWriteError
        }
    }

    // The preferred method of quick returning Errors
    fn write_to_file_question() -> Result<(), MyError> {
        let mut file = File::create("my_best_friends.txt")?;
        file.write_all(b"This is a list of my best friends.")?;
        Ok(())
    }

    // The previous method of quick returning Errors
    fn write_to_file_using_try() -> Result<(), MyError> {
        let mut file = r#try!(File::create("my_best_friends.txt"));
        r#try!(file.write_all(b"This is a list of my best friends."));
        Ok(())
    }

    // This is equivalent to:
    fn write_to_file_using_match() -> Result<(), MyError> {
        let mut file = r#try!(File::create("my_best_friends.txt"));
        match file.write_all(b"This is a list of my best friends.") {
            Ok(v) => v,
            Err(e) => return Err(From::from(e)),
        }
        Ok(())
    }Run

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)