The From<T> trait should not assume a valid into implementation can be provided

[mitchmindtree]

Currently, our From trait looks like this:

pub trait From<T> {
    fn from(b: T) -> Self;
    fn into(self) -> T;
}

This has the problem that it assumes both directions of conversion are infallible, which is not always the case!

We should consider following Rust's conventions for From and TryFrom here.

Ideally, From implementations should always be lossless (never lose information) and should always be infallible (can never revert). Fallible implementations should use a TryFrom alternative that returns a Result so that the user decide whether they want to revert on Err or handle it in some other way.

We can see this convention in Rust's std lib for the primitive types, e.g. it has impl From<u16> for u32, but does not have impl From<u32> for u16. Instead, it offers impl TryFrom<u32> for u16 which checks if the value is out of range.

TODO

• Remove the into method from the From<T> trait.
• Add a TryFrom<T> trait to support fallible conversions. Note that this requires associated types to ergonomically infer Self::Error type from implementations. Add associated items to impls and traits. #610. In the meantime, we could unblock ourselves from this by returning an Option rather than a Result and use None to imply conversion failure, and then switch to Result in the future once associated types land?
• Review From implementations in std to ensure all are infallible (i.e. don't revert). Replace fallible implementations with TryFrom and produce an error instead.
• Omit Into<T> until we support blanket implementations i.e. Implement trait Into<T> in lib-std #3399.

[mohammadfawaz]

That's fair. I suppose omitting Into for now altogether (until we're able to implement it properly) is better than having the bad implementation that we have today.