Try_v2

Provides a derive macro for Try & optionally Try_ConvertResult for interconversion with std::result::Result and Try_Iterator for iterating over IntoIterator and collecting from FromIterator analogous to how Result & Option do this. See (try_trait_v2) for more details of the underlying trait.

Requires

nightly
#![feature(never_type)]
#![feature(try_trait_v2)]
#![feature(try_trait_v2_residual)]
optionally: #![feature(iterator_try_collect)] (if using Try_Iterator)

Limitations on the annotated type

must be an enum
must have at least one generic type
the first generic type must be the Output type (produced when not short circuiting)
the output variant (does not short-circuit) must be the first variant and store the output type as the only unnamed field

See the full documentation for specifics on the generated code.

Example Usage

#![feature(never_type)]
#![feature(try_trait_v2)]
#![feature(try_trait_v2_residual)]
use try_v2::{Try, Try_ConvertResult};

#[derive(Try, Try_ConvertResult)]
enum TestResult<T> {
    Ok(T),
    TestsFailed,
    OtherError(String)
}

// Basic short circuiting thanks to `#[derive(Try)]`
fn run_tests() -> TestResult<()> {
    TestResult::OtherError("oops!".to_string())?; // <- Function short-circuits here ...
    TestResult::TestsFailed?;
    TestResult::Ok(())
}

assert!(matches!(run_tests(), TestResult::OtherError(msg) if msg == "oops!"));


// Conversion from std::result::Result thanks to `#[derive(Try_ConvertResult)]`
struct TestFailure {}

impl<T> From<TestFailure> for TestResult<T> {
    fn from(err: TestFailure) -> Self {
        TestResult::TestsFailed
    }
}

fn run_more_tests() -> TestResult<()> {
    std::result::Result::Err(TestFailure{})?; // <- Function short-circuits here & converts to a TestResult...
    TestResult::Ok(())
}

assert!(matches!(run_more_tests(), TestResult::TestsFailed));

MSRV

1.85.1, in case you are using a fixed version of nightly just to get access to specific unstable features.

Currently untested (may work, may not ...)