Hacker News Reader

Comment by jacobr1 | Hacker News Reader

We might not be able to always reason about function totality, but perhaps sometimes we can. Isn't that what `std::convert::Infallible` is trying to do? So you get

   fn try_from(value: U) -> Result<Self, Infallible>

In which case you could potentially avoid the need for an unwrap.

View on HN

Could you give a more complete example? I see the type signature for the function you're proposing, but I still don't understand what is supposed to replace .unwrap() on the inside of the function.

The "fix" would be to return a Result. Which is a sum of an error and the type you want to return.

But again, the function cannot fail. It could return a Result<Vec2, Infallible>, I guess, but then you're just pushing the unwrap to caller without any need to.

That's the entire point of the OP. That it can't fail so you might as well call unwrap.

You can't return an Infallible, though, because it has no variants. You still need to do something at the point of unwrap().

You'd pair it with something like this https://docs.rs/unwrap-infallible/

I don't see how that would work.

    d[0..4].try_into()

The type of the result is something like:

    Result<[u8; 4], TryFromSliceError>

How do I convert that into

    Result<[u8; 4], Infallible>

As far as I can tell, Infallible is there because you're implementing a trait which returns an error, but you don't have an error to return at all.

In jacobr1's comment we already have a way to get a Result<_, Infallible>. But converting a slice to an array returns a real error type, so my comment wouldn't apply.

For your case just stick with `.try_into().unwrap()`. It's the easiest way. Unless of course someone on crates.io made a fancy crate with const generics.

Reply on news.ycombinator.com