Rust's error handling is in my opinion perfect. An operation that can fail will return a Result<T, E> type, it will either be Ok(T), or Err(E). You can pattern match a Result, and decide what to do with it.

Or, more likely, you just want to pass that error back up to your calling function to decide what to do with it, so you just put a ? on the end of your function call like this:

    let result = potentially_failing_function()?;

I'm mostly familiar with it in F#, Scala, and Haskell, but I suspect any language with some functional roots has an equivalent.

The F# For Fun and Profit blog has a decent post explaining it. That blog doesn't appear to be maintained anymore, but it is archived: https://web.archive.org/web/20180329001511/https://fsharpfor...

You can find examples in Scala with `for` comprehensions as well.

java:

    Optional<String> result = returnsAnOptional();
    if (result.isPresent()) {
        log.info("result is {}", result.get());
    }

    // and

    returnsAnOptional().map(r -> log.info("result is {}", r);

Rust does.