Add Result::{ok, err, and, or, unwrap_or} as const

[clarfonthey]

Already opened tracking issue #92384.

I don't think that this should actually cause any issues as long as the constness is unstable, but we may want to double-check that this doesn't get interpreted as a weird Drop bound even for non-const usages.

[rust-highfive]

r? @scottmcm

(rust-highfive has picked a reviewer for you, use r? to override)

[clarfonthey]

Aaaaaand now I find out why these are not marked as const. Okay.

[PatchMixolydic]

I'm not too familiar with the feature, but would adding a ~const Drop bound work here?

Suggested change

	pub const fn ok(self) -> Option<T> {
	pub const fn ok(self) -> Option<T>
	where
	E: ~const Drop,
	{

[PatchMixolydic]

See also #91928, which constified most of Option's methods.

[clarfonthey]

You're right; there is a way to make this work. Reopening.

[clarfonthey]

Okay, so, a couple things.

1. I marked const fn drop under the feature const_drop. Haven't opened a tracking issue yet because I'm not sure if the lang/libs folks want to commit to that.
2. Right now, the destructor check is a bit overzealous; I have to manually drop values in order for it to only require the T: ~const Drop and E: ~const Drop bounds instead of the (larger) Self: ~const Drop bounds.

In general there should probably be just a tracking issue in general for what the semantics of ~const Drop would even be, since it seems like it shouldn't just be lumped in #67792 with all of the ~const stuff.

[slightlyoutofphase]

Have you tried writing the start of the None arms neither with x or _, but rather _x? Here's what I mean, specifically:

pub const fn ok(self) -> Option<T>
where
    E: ~const Drop,
{
    match self {
        Ok(x) => Some(x),
        Err(_x) => None,
    }
}

pub const fn err(self) -> Option<E>
where
    T: ~const Drop,
{
    match self {
        Ok(_x) => None,
        Err(x) => Some(x),
    }
}

I kind of feel like that might make it work without the drop() function needing to be directly involved at all.

[slightlyoutofphase]

I kind of feel like that might make it work without the drop() function needing to be directly involved at all.

Yeah, I was on to something here. The following works exactly as written, for example:

#![feature(const_fn_trait_bound, const_precise_live_drops, const_trait_impl)]

pub const fn ok<T, E>(res: Result<T, E>) -> Option<T>
where
    E: ~const Drop,
{
    match res {
        Ok(x) => Some(x),
        // Actually works without the leading `_` also,
        // but then you get an "unused variable" lint.
        Err(_x) => None,
    }
}

pub const fn err<T, E>(res: Result<T, E>) -> Option<E>
where
    T: ~const Drop,
{
    match res {
        // Actually works without the leading `_` also,
        // but then you get an "unused variable" lint.
        Ok(_x) => None,
        Err(x) => Some(x),
    }
}

const A: Result<u32, &str> = Ok(2);
const B: Result<u32, &str> = Err("Nothing here");
const C: Option<u32> = ok(A);
const D: Option<u32> = ok(B);
const E: Option<&str> = err(A);
const F: Option<&str> = err(B);

fn main() {
    assert_eq!(C, Some(2));
    assert_eq!(D, None);
    assert_eq!(E, None);
    assert_eq!(F, Some("Nothing here"));
}

Playground link for the above.

[scottmcm]

I'm going to re-roll this to someone who will hopefully have more ~const Drop context.

r? rust-lang/libs

[clarfonthey]

Since this hasn't been CRed yet and I found that there were a few other methods like these, I decided to add them to the PR with the appropriate ~const Drop bounds. I don't think this should be an issue, but if you'd prefer to limit it to just ok and err, let me know.

cc @joshtriplett since you seem to have won the review lottery.

[bors]

📌 Commit 19645ac has been approved by fee1-dead

[fee1-dead]

@bors r-

Blocked on #93412

[clarfonthey]

Now that that's merged, I think this is ready to merge again? Let me know if there are any changes in the code and I can fix them, @fee1-dead.

also r? @fee1-dead since I guess you're taking this over now just kidding, only org members can do this

[fee1-dead]

cc @oli-obk for potential blockers (otherwise r=me)

[oli-obk]

@bors r=fee1-dead

[bors]

📌 Commit 19645ac has been approved by fee1-dead