Support implicit broadening using the try operator

[Zk2u]

Taking the example:

use terrors::OneOf;

struct Timeout;
struct AllocationFailure;

fn allocate_box() -> Result<Box<u8>, OneOf<(AllocationFailure,)>> {
    Err(AllocationFailure.into())
}

fn send() -> Result<(), OneOf<(Timeout,)>> {
    Err(Timeout.into())
}

fn allocate_and_send() -> Result<(), OneOf<(AllocationFailure, Timeout)>> {
    let boxed_byte: Box<u8> = allocate_box().map_err(OneOf::broaden)?;
    send().map_err(OneOf::broaden)?;

    Ok(())
}

// ...

Instead of using allocate_box().map_err(OneOf::broaden)?, we could implement Into for any subset of a OneOf so this can be simplified to just allocate_box()?, and the ? operator will implicitly broaden the error.

[spacejam]

I haven't found a way to support this using the current type system due to the requirement of having an additional Index type which allows the prolog-like type system to resolve correctly. If you or anyone else finds a way to support this with the stable From trait I would be very curious to see how it is possible.

[musjj]

Another annoying thing is that .into() doesn't work if OneOf has multiple members:

use terrors::OneOf;

struct Timeout;
struct AllocationFailure;

fn allocate_box() -> Result<Box<u8>, OneOf<(AllocationFailure, Timeout)>> {
    Err(AllocationFailure.into()) // the trait bound `terrors::OneOf<(AllocationFailure, Timeout)>: std::convert::From<AllocationFailure>` is not satisfied
}

I had hoped that this library would be a nicer and more explicit anyhow alternative. But this is a huge hit in ergonomics, since you need to litter your code with .map_err(OneOf::new) or .map_err(OneOf::broaden) on every call site.

But I suppose that this is just impossible due to Rust's limitations.