Mark Result::{ok,err} as #[must_use]

[upsuper]

In a discussion in our Rust group, someone incorrectly uses ok() without checking its return value, causing confusing issue. As Result::{is_ok, is_err} are already marked #[must_use] in #59610, I don't see any reason Result::{ok, err} shouldn't be.

cc #48926

[Mark-Simulacrum]

Result::ok is an accepted style for "ignoring" results -- I'm not sure that's a good thing, but it's the reality today, so I don't think marking it as must_use is viable. Marking err but not ok would be quite odd, I expect, so we'd probably not want to do that either.

Personally I think until we come up with a proper pattern for "ignoring" must_use values and document that we shouldn't change things here. I've personally not found a solution -- let _ = result I'm not a fan of; result.ok(); I'm also not a big fan of personally, both look somewhat unnatural. Though maybe that's not a bad thing.

[upsuper]

How is it "accepted"? What's the logic behind having it such style? How widely used it is?

I personally think let _ = is the general style for ignoring anything which otherwise would be warned for not being used. If you insist that there should be a method, adding something like .ignore() is probably an option as well.

[Mark-Simulacrum]

I'm not saying that there should be a method, but I have definitely heard and probably read that .ok() is how some people work around the must_use lint today.

To be clear I'm not really opposed to this marking, I just am uncertain we should do it, as these methods are sometimes used in a way where the return type isn't "must use." Maybe that doesn't make much sense :)

[kornelski]

I've used .ok() in a few places for silencing must_use, but I'd be happy to change that code.

.ok() by itself is not entirely clear. Did I mean to assert that the result is always OK? Did I mean to use the Option and forgot to bind it?

.ignore_result() or .ignore_err() would be clearer. If the language gets #[must_bind] to make let _ = safer, that'd be better too.

[edward-shen]

I'm a big fan of .ignore(). Thinking about it, an implementation would basically just be

fn ignore(self) {}

which is reminds me of drop. Maybe drop should really be the conventional way to ignore a Result?

I think between an .ignore() and drop I would still prefer a convenience method (especially since it's postfix!) on Result (and if it's not clear, to also throw #[must_use] on .ok()).