Result with lifetime parameter - enum with lifetime parameter applied to default T<'a> and E<'a> parameter (Rust)

Question

I'm attempting to make a Result with a lifetime parameter, as an additional restrain on the T (::Ok(T)) and E (::Err(E)) generic parameters.

// enums A<'a> and B<'a> elided

pub enum Result<'a, T=A<'a>, E=B<'a>> {
    Ok(T),
    Err(E),
}

unused parameter, suggestion: add PhantomData

So it didn't work. I read that I can hack around the unused parameter error with PhantomData, but that seems dirty to me.

Neither did this work:

pub enum Result<T=A<'a>, E=B<'a>> {
    Ok(T),
    Err(E),
}

undefined parameter, suggestion: add parameter before T
(twice)

This suggestion throws me for a loop!

How do I put a generic type with a lifetime parameter, in my enum generic parameter default value?

It would help if you included some example code, that shows the context of what you're trying to do. Because it's not clear why using the standard `Result` is not possible, i.e. having a return type of `Result, B<'a>>`. — vallentin, Jan 19 '21 at 18:09
Instead of default types, you can use an alias: `type MyResult<'a> = Result, B<'a>>;` — kmdreko, Jan 19 '21 at 19:30

score 1 · Answer 1 · answered Jan 20 '21 at 23:16

The error is correct, this type would make no sense:

Since the lifetime is only used in default parameters, what would the lifetime be in cases like this:

let foo = Result::Ok(42); // What's the lifetime in this instance?

?

The lifetime isn't used, this is where the error message comes from.

The question doesn't provide much context, but it does seem like you intend to only use A<'_> and B<'_> in your type. If that is the case, then you must use

pub enum Result<'a> {
    Ok(A<'a>),
    Err(B<'a>),
}

which is valid. However that would raise the question of why you're not using the built-in Result type, maybe combined with a type alias to avoid repetition: type Result<'a> = std::result::Result<A<'a>, B<'a>>;. This is pretty common to do, even the standard library does it a few times:

std::io::Result: type Result<T> = Result<T, Error>;
std::fmt::Result: type Result = Result<(), Error>;

Thank you! I was struggling with excessively long `Result` types, and it didn't "click" that I could make module-local type aliases. I do still wonder how I could make an `enum` where the lifetimes of `T` and `E` are always the same so that I can construct the `enum` like `let e = Result<'a, A, B>` and have the variants of the `enum` become `::T>` and `::E>`, but I've since realized I have no practical need for this. — Willem, Jan 21 '21 at 13:51

Result with lifetime parameter - enum with lifetime parameter applied to default T<'a> and E<'a> parameter (Rust)

1 Answers1