Impl Try for Option

[huntiep]

This is part of #31436.

[rust-highfive]

Thanks for the pull request, and welcome! The Rust team is excited to review your changes, and you should hear from @alexcrichton (or someone else) soon.

If any changes to this PR are deemed necessary, please add them as extra commits. This ensures that the reviewer can see what has changed since they last reviewed the code. Due to the way GitHub handles out-of-date commits, this should also make it reasonably obvious what issues have or haven't been addressed. Large or tricky changes may require several passes of review and changes.

Please see the contribution instructions for more information.

[kennytm]

Wrong documentation?

[huntiep]

Yes, I needed something there in order to compile and forgot to change it. I'm not sure what to replace it with; maybe The equivalent of Option::None for a Result type.?

[scottmcm]

This is exciting, and applying right after branching for release is probably the best option we have for insta-stable things like this. (This will allow ? on Option without a feature gate, right?)

Something I didn't want to push in the RFC discussion, but thought interesting: what about a None type (instead of Missing) for <Option<T> as Try>::Error? Then at the type level it's also "an option is either a T or None". Sample implementation: https://doc.rust-lang.org/nightly/unstable-book/library-features/try-trait.html

That's intentionally non-constructible for now, since what I think it ought to be is type None = Option<!>; so that let _: None = None; would be valid, and more importantly that a throw sugar (in auto-wrapping) would allow throw None; and return 4; (paralleling return None; and return Some(4);).

Though I guess the type will stay unstable for a while, so it doesn't matter for now...

[oli-obk]

This is not going through the Option. I already works now... Maybe you meant to use Some here?

[oli-obk]

And None here

[oli-obk]

This is also nothing new... maybe change it into a compile-fail test by using Some/None and triggering a compilation error

[huntiep]

I didn't see any tests for Result's Try implemenation, but if they exist I can remove these tests.

[alexcrichton]

r? @aturon

Also cc @rust-lang/lang, especially @scottmcm's comment where I think this is insta-stable

[nikomatsakis]

I think one way to prevent it from being insta-stable would be to make it #[cfg(nightly)], right? Have we rejected this path for some reason?

I am open to bikeshedding the name of Missing -- I agree it doesn't feel right to me. None might be better, though if we ever get types for variants, that might be .. surprising?

[MoSal]

Maybe ErrNone or TryNone or TryErrNone.

[kennytm]

@nikomatsakis Previous discussion https://internals.rust-lang.org/t/setting-cfg-nightly-on-nightly-by-default/1893

[nikomatsakis]

@kennytm well that was more about a public "cfg", but yeah apparently we don't have #[cfg(nightly)] even without rustc. For some reason, I thought we did. Regardless, it's not a great suggestion; it wouldn't require any opt-in, which is really what you want.

[huntiep]

I also like ErrNone over Missing. I just followed the impl outlined in the RFC.

At this point what do I need to do?

[nikomatsakis]

I think we should settle on the name -- I am not 100% sure when we should merge this RFC though. The insta-stable thing bothers me, but I don't have a good idea what else to do about it.

[nikomatsakis]

@rust-lang/lang @rust-lang/libs -- anybody care to "weigh in" on the name of the "error type" to use in the Try impl for Option? The RFC said Missing, but ErrNone has been proposed as an alternative. Some newtype is needed, at least.

[kennytm]

If we follow the naming practice in libstd, it should be ***Error (e.g. NoneError) instead of ErrNone.

[withoutboats]

What's the reason not to use ()?

[kennytm]

@withoutboats rust-lang/rfcs#1859 explained why the error must be a dedicated type (to prevent accidentally ?-returning an Option<T> as Result<T, ()> and vice-versa).

[huntiep]

I think NoneError is fine, as long as it is well documented. Right now Missing is documented as

/// The equivalent of `Option::None` for a `Result::Err`.

Any thoughts on how to better document this, regardless of what the final name is?

[alexcrichton]

Ergonomically at least this seems most likely to arise in something like:

impl From<Missing> for MyErrorType

(if at all). That way you could option? in functions that return Result. In that sense From<Missing> does indeed seem a little ambiguous, but either From<ErrNone> or From<NoneError> are both more clear. Note, though that From<option::Missing> is also pretty clear.

[sfackler]

WasNone is another naming option.

[nikomatsakis]

@withoutboats

What's the reason not to use ()?

The feeling was that () is not sufficiently precise. In particular, one could readily imagine there being other "option-like" types that might also default to use (), and this would allow interconversion between them when you didn't really want to allow that. For example:

enum List<T> {
    Nil,
    Cons(T, Box<List<T>>),
}

Imagine that I implemented Try for List and made the "error" case be () (because it seemed like a reasonable default). Granted, this is probably not the best example, though it's not so uncommon for "lists" to be a monad, so I could imagine someone doing it. Anyway, this led to the recommendation to use a newtype, so that the intention is more explicit.

[nikomatsakis]

👍 for NoneError. I like that. I think the documentation should probably be something like:

"The error type that results from applying the try operator (?) to a None value. If you wish to allow x? (where x is an Option<T>) to be converted into your error type, you can implement impl From<NoneError> for YourErrorType. In that case, x? within a function that returns Result<_, YourErrorType> will translate a None value into an Err result."

[nikomatsakis]

@huntiep I took the liberty of rebasing for you.

[huntiep]

@nikomatsakis I'm sorry, I missed that part of your last comment. For future reference, can you briefly explain what you meant by rebase?

[shepmaster]

@huntiep it refers to git rebase. You can do git rebase --help or check out some pages like this one to learn more. Many times it's done to "clean up" a branch before merging by removing "intermediate" work that's not important to track forever, or to resolve any merge conflicts.

[shepmaster]

@nikomatsakis did you mean to review at bors?

[aturon]

@bors: r=nikomatsakis

[bors]

📌 Commit e30d92b has been approved by nikomatsakis

[bors]

⌛️ Testing commit e30d92b with merge 6f87d20...

[bors]

☀️ Test successful - status-appveyor, status-travis
Approved by: nikomatsakis
Pushing 6f87d20 to master...