Tracking issue for const `Option` functions #67441

9999years · 2019-12-20T01:53:49Z

Current candidates with feature = const_option:

impl<T> Option<T> {
    pub const fn as_mut(&mut self) -> Option<&mut T>;
    pub const fn expect(self, msg: &str) -> T;
    pub const fn unwrap(self) -> T;
    pub const unsafe fn unwrap_unchecked(self) -> T;
    pub const fn take(&mut self) -> Option<T>;
    pub const fn replace(&mut self, value: T) -> Option<T>;
}

impl<T> Option<&T> {
    pub const fn copied(self) -> Option<T>
    where
        T: Copy;
}

impl<T> Option<&mut T> {
    pub const fn copied(self) -> Option<T>
    where
        T: Copy;
}

impl<T, E> Option<Result<T, E>> {
    pub const fn transpose(self) -> Result<Option<T>, E>
}

impl<T> Option<Option<T>> {
    pub const fn flatten(self) -> Option<T>;
}

See also the meta-tracking issue for const fns, #57563.

Blocked on:

Also see the corresponding Result tracking issue: #82814.

The text was updated successfully, but these errors were encountered:

Make some Option methods const Tracking issue: rust-lang#67441 Constantify the following methods of `Option`: - `as_ref` - `is_some` - `is_none` - `iter` (not sure about this one, but it is possible, and will be useful when const traits are a thing) cc @rust-lang/wg-const-eval @rust-lang/libs

@oli-obk

…=oli-obk Make `Option::unwrap` unstably const This is lumped into the `const_option` feature gate (rust-lang#67441), which enables a potpourri of `Option` methods. cc @rust-lang/wg-const-eval r? @oli-obk

Stabilize some Option methods as const Stabilize the following methods of `Option` as const: - `is_some` - `is_none` - `as_ref` These methods are currently const under the unstable feature `const_option` (tracking issue: rust-lang#67441). I believe these methods to be eligible for stabilization because of the stabilization of rust-lang#49146 (Allow if and match in constants) and the trivial implementations, see also: [PR#75463](rust-lang#75463). Related: rust-lang#76225

peter-lyons-kehl · 2021-02-22T00:08:29Z

Yes for constantifying Option.expect.

However, as per https://doc.rust-lang.org/nightly/src/core/option.rs.html, Option.expect(self, msg: &str) calls (private) fn expect_failed(msg: &str), which uses panic!("{}", msg). Using panic! with more than one argument is not const-friendly:

    --> library/core/src/macros/mod.rs:18:38
     |
7    | / macro_rules! panic {
8    | |     () => (
9    | |         $crate::panic!("explicit panic")
10   | |     );
...    |
18   | |         $crate::panicking::panic_fmt($crate::format_args!($fmt, $($arg)+))
     | |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ in this macro invocation (#2)
19   | |     );
20   | | }
     | |_- in this expansion of `panic!` (#1)
...
761  | /     macro_rules! format_args {
762  | |         ($fmt:expr) => {{ /* compiler built-in */ }};
763  | |         ($fmt:expr, $($args:tt)*) => {{ /* compiler built-in */ }};
764  | |     }
     | |_____- in this expansion of `$crate::format_args!` (#2)
     | 
    ::: library/core/src/option.rs:1294:5
     |
1294 |       panic!("{}", msg)
     |       ----------------- in this macro invocation (#1)

Since that is not specific to Option, is there any discussion/plan/tracking issue on making panic const-friendly? Isn't it reasonable to assume that any panic is a panic? Or, can panic fail (for example, if formatting fails) and not panic?

memoryruins · 2021-02-22T00:21:35Z

@peter-kehl the tracking issue for panicking in constants is #51999

davidhewitt · 2021-03-13T19:46:41Z

FYI anyone looking at .unwrap_or - I just naively tried to add this, but given that T may impl Drop, this is currently unsupported.

I wonder if it would be feasible for the compiler to allow use of .unwrap_or for types that do impl drop - e.g. only fail when trying to const-evaluate .unwrap_or for T: impl Drop.

jhpratt · 2021-03-13T19:55:00Z

@davidhewitt Given that neither const trait impls nor const trait bounds are usable on stable, it would be quite unintuitive if this were. Even on nightly, const traits have yet to be RFC accepted.

davidhewitt · 2021-03-13T22:17:22Z

Sorry, I typo'd above - I meant to say only allow types which don't impl Drop.

We probably wouldn't want this in the function signature (should just be const fn unwrap_or(default: T)). The compiler could be aware that in some paths inside the function default is disposed of, and so reject substitutions during const evaluation for T which impl Drop.

TBH it sounds messy and slightly leaks information about the function implementation, so I'm unconvinced it's worth the effort. Just musing of a way to allow some forms of const unwrap_or before const impl Trait / const Drop is ready.

jhpratt · 2021-03-13T22:22:54Z

Yeah, I figured it was a typo and responded accordingly.

I still think it would be awkward to have this magically work for some types but not others, especially if this isn't in the function signature. I'd much rather wait for const trait impls to be RFC approved and land on stable, as that would allow way more than just this. Just look at the blockers on #82814 and realize that having const trait impls would allow ~80% of them (just guessing, I haven't bothered to actually calculate a percentage).

jhpratt · 2021-04-13T23:06:56Z

If/when #51999 is stabilized, Option::expect and Option::unwrap should be unblocked (I haven't checked this, it's just from reading source code).

CodesInChaos · 2021-04-29T15:32:02Z

@jhpratt Option::expect passes more than one argument to panic! (and the second argument isn't const), so it'll need more work than the minimal version of const panics considered for stabilization at the moment.

mbartlett21 · 2021-06-08T06:40:27Z

replace, take, and copied would also be some more that can be done.

Can @9999years add these to the list at the top?

…-replace, r=joshtriplett const fn for option copied, take & replace Tracking issue: [rust-lang#67441](rust-lang#67441) Adding const fn for the copied, take and replace method of Option. Also adding necessary unit test. It's my first contribution so I am pretty sure I don't know what I'm doing but there's a first for everything!

rfcbot · 2024-10-01T14:52:06Z

🔔 This is now entering its final comment period, as per the review above. 🔔

This makes the following API stable in const contexts: impl<T> Option<T> { pub const fn as_mut(&mut self) -> Option<&mut T>; pub const fn expect(self, msg: &str) -> T; pub const fn unwrap(self) -> T; pub const unsafe fn unwrap_unchecked(self) -> T; pub const fn take(&mut self) -> Option<T>; pub const fn replace(&mut self, value: T) -> Option<T>; } impl<T> Option<&T> { pub const fn copied(self) -> Option<T> where T: Copy; } impl<T> Option<&mut T> { pub const fn copied(self) -> Option<T> where T: Copy; } impl<T, E> Option<Result<T, E>> { pub const fn transpose(self) -> Result<Option<T>, E> } impl<T> Option<Option<T>> { pub const fn flatten(self) -> Option<T>; } The following functions make use of the unstable `const_precise_live_drops` feature: - `expect` - `unwrap` - `unwrap_unchecked` - `transpose` - `flatten` Fixes: <rust-lang#67441>

tgross35 · 2024-10-01T22:09:19Z

Candidate PR: #131120

rfcbot · 2024-10-11T16:16:04Z

The final comment period, with a disposition to merge, as per the review above, is now complete.

As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed.

This will be merged soon.

This makes the following API stable in const contexts: impl<T> Option<T> { pub const fn as_mut(&mut self) -> Option<&mut T>; pub const fn expect(self, msg: &str) -> T; pub const fn unwrap(self) -> T; pub const unsafe fn unwrap_unchecked(self) -> T; pub const fn take(&mut self) -> Option<T>; pub const fn replace(&mut self, value: T) -> Option<T>; } impl<T> Option<&T> { pub const fn copied(self) -> Option<T> where T: Copy; } impl<T> Option<&mut T> { pub const fn copied(self) -> Option<T> where T: Copy; } impl<T, E> Option<Result<T, E>> { pub const fn transpose(self) -> Result<Option<T>, E> } impl<T> Option<Option<T>> { pub const fn flatten(self) -> Option<T>; } The following functions make use of the unstable `const_precise_live_drops` feature: - `expect` - `unwrap` - `unwrap_unchecked` - `transpose` - `flatten` Fixes: <rust-lang#67441>

…=RalfJung Stabilize `const_option` This makes the following API stable in const contexts: ```rust impl<T> Option<T> { pub const fn as_mut(&mut self) -> Option<&mut T>; pub const fn expect(self, msg: &str) -> T; pub const fn unwrap(self) -> T; pub const unsafe fn unwrap_unchecked(self) -> T; pub const fn take(&mut self) -> Option<T>; pub const fn replace(&mut self, value: T) -> Option<T>; } impl<T> Option<&T> { pub const fn copied(self) -> Option<T> where T: Copy; } impl<T> Option<&mut T> { pub const fn copied(self) -> Option<T> where T: Copy; } impl<T, E> Option<Result<T, E>> { pub const fn transpose(self) -> Result<Option<T>, E> } impl<T> Option<Option<T>> { pub const fn flatten(self) -> Option<T>; } ``` The following functions make use of the unstable `const_precise_live_drops` feature: - `expect` - `unwrap` - `unwrap_unchecked` - `transpose` - `flatten` Fixes: <rust-lang#67441>

Rollup merge of rust-lang#131120 - tgross35:stabilize-const_option, r=RalfJung Stabilize `const_option` This makes the following API stable in const contexts: ```rust impl<T> Option<T> { pub const fn as_mut(&mut self) -> Option<&mut T>; pub const fn expect(self, msg: &str) -> T; pub const fn unwrap(self) -> T; pub const unsafe fn unwrap_unchecked(self) -> T; pub const fn take(&mut self) -> Option<T>; pub const fn replace(&mut self, value: T) -> Option<T>; } impl<T> Option<&T> { pub const fn copied(self) -> Option<T> where T: Copy; } impl<T> Option<&mut T> { pub const fn copied(self) -> Option<T> where T: Copy; } impl<T, E> Option<Result<T, E>> { pub const fn transpose(self) -> Result<Option<T>, E> } impl<T> Option<Option<T>> { pub const fn flatten(self) -> Option<T>; } ``` The following functions make use of the unstable `const_precise_live_drops` feature: - `expect` - `unwrap` - `unwrap_unchecked` - `transpose` - `flatten` Fixes: <rust-lang#67441>

RalfJung · 2024-10-13T16:41:10Z

This actually made it into 1.83. :-) That will be quite the release in terms of const.

This makes the following API stable in const contexts: impl<T> Option<T> { pub const fn as_mut(&mut self) -> Option<&mut T>; pub const fn expect(self, msg: &str) -> T; pub const fn unwrap(self) -> T; pub const unsafe fn unwrap_unchecked(self) -> T; pub const fn take(&mut self) -> Option<T>; pub const fn replace(&mut self, value: T) -> Option<T>; } impl<T> Option<&T> { pub const fn copied(self) -> Option<T> where T: Copy; } impl<T> Option<&mut T> { pub const fn copied(self) -> Option<T> where T: Copy; } impl<T, E> Option<Result<T, E>> { pub const fn transpose(self) -> Result<Option<T>, E> } impl<T> Option<Option<T>> { pub const fn flatten(self) -> Option<T>; } The following functions make use of the unstable `const_precise_live_drops` feature: - `expect` - `unwrap` - `unwrap_unchecked` - `transpose` - `flatten` Fixes: <rust-lang/rust#67441>

Stabilize `const_option` This makes the following API stable in const contexts: ```rust impl<T> Option<T> { pub const fn as_mut(&mut self) -> Option<&mut T>; pub const fn expect(self, msg: &str) -> T; pub const fn unwrap(self) -> T; pub const unsafe fn unwrap_unchecked(self) -> T; pub const fn take(&mut self) -> Option<T>; pub const fn replace(&mut self, value: T) -> Option<T>; } impl<T> Option<&T> { pub const fn copied(self) -> Option<T> where T: Copy; } impl<T> Option<&mut T> { pub const fn copied(self) -> Option<T> where T: Copy; } impl<T, E> Option<Result<T, E>> { pub const fn transpose(self) -> Result<Option<T>, E> } impl<T> Option<Option<T>> { pub const fn flatten(self) -> Option<T>; } ``` The following functions make use of the unstable `const_precise_live_drops` feature: - `expect` - `unwrap` - `unwrap_unchecked` - `transpose` - `flatten` Fixes: <rust-lang/rust#67441>

Fix two const-hacks Fix two pieces of code marked `FIXME(const-hack)` related to const_option rust-lang#67441.

Rollup merge of rust-lang#131706 - GKFX:fix-const-hacks, r=tgross35 Fix two const-hacks Fix two pieces of code marked `FIXME(const-hack)` related to const_option rust-lang#67441.

This makes the following API stable in const contexts: impl<T> Option<T> { pub const fn as_mut(&mut self) -> Option<&mut T>; pub const fn expect(self, msg: &str) -> T; pub const fn unwrap(self) -> T; pub const unsafe fn unwrap_unchecked(self) -> T; pub const fn take(&mut self) -> Option<T>; pub const fn replace(&mut self, value: T) -> Option<T>; } impl<T> Option<&T> { pub const fn copied(self) -> Option<T> where T: Copy; } impl<T> Option<&mut T> { pub const fn copied(self) -> Option<T> where T: Copy; } impl<T, E> Option<Result<T, E>> { pub const fn transpose(self) -> Result<Option<T>, E> } impl<T> Option<Option<T>> { pub const fn flatten(self) -> Option<T>; } The following functions make use of the unstable `const_precise_live_drops` feature: - `expect` - `unwrap` - `unwrap_unchecked` - `transpose` - `flatten` Fixes: <rust-lang/rust#67441>

Stabilize `const_option` This makes the following API stable in const contexts: ```rust impl<T> Option<T> { pub const fn as_mut(&mut self) -> Option<&mut T>; pub const fn expect(self, msg: &str) -> T; pub const fn unwrap(self) -> T; pub const unsafe fn unwrap_unchecked(self) -> T; pub const fn take(&mut self) -> Option<T>; pub const fn replace(&mut self, value: T) -> Option<T>; } impl<T> Option<&T> { pub const fn copied(self) -> Option<T> where T: Copy; } impl<T> Option<&mut T> { pub const fn copied(self) -> Option<T> where T: Copy; } impl<T, E> Option<Result<T, E>> { pub const fn transpose(self) -> Result<Option<T>, E> } impl<T> Option<Option<T>> { pub const fn flatten(self) -> Option<T>; } ``` The following functions make use of the unstable `const_precise_live_drops` feature: - `expect` - `unwrap` - `unwrap_unchecked` - `transpose` - `flatten` Fixes: <rust-lang/rust#67441>

JohnTitor added the C-tracking-issue Category: An issue tracking the progress of sth. like the implementation of an RFC label Dec 20, 2019

Centril added A-const-eval Area: Constant evaluation (MIR interpretation) A-const-fn Area: const fn foo(..) {..}. Pure functions which can be applied at compile time. T-libs-api Relevant to the library API team, which will review and decide on the PR/issue. labels Dec 20, 2019

a1phyr mentioned this issue Jul 1, 2020

Make some Option methods const #73930

Merged

ecstatic-morse mentioned this issue Jul 30, 2020

Make Option::unwrap unstably const #74956

Merged

KodrAus added the Libs-Tracked Libs issues that are tracked on the team's project board. label Jul 30, 2020

This was referenced Aug 30, 2020

Make some Ordering methods const #75463

Merged

Stabilize some Option methods as const #76135

Merged

faern mentioned this issue Sep 1, 2020

Convert Ipv{4,6}Network::new to const functions achanda/ipnetwork#137

Merged

RalfJung mentioned this issue Mar 5, 2021

Make some Option, Result methods unstably const #82130

Merged

lambinoo mentioned this issue Jul 2, 2021

const fn for option copied, take & replace #86828

Merged

lilasta mentioned this issue Oct 16, 2021

Make Option::as_mut const #89953

Merged

ObsidianMinor mentioned this issue Sep 25, 2024

Switch from nightly toolchain to stable 1.81 cloudflare/recapn#22

Merged

alex-700 mentioned this issue Sep 29, 2024

[refurb] implement hardcoded-string-charset (FURB156) astral-sh/ruff#13530

Merged

rfcbot added final-comment-period In the final comment period and will be merged soon unless new substantive objections are raised. and removed proposed-final-comment-period Proposed to merge/close by relevant subteam, see T-<team> label. Will enter FCP once signed off. labels Oct 1, 2024

tgross35 mentioned this issue Oct 1, 2024

Stabilize const_option #131120

Merged

rustbot mentioned this issue Oct 11, 2024

Tracking issue for release notes of #67441: Tracking issue for const Option functions #131553

Open

3 tasks

bors closed this as completed in #131120 Oct 13, 2024

GKFX mentioned this issue Oct 14, 2024

Fix two const-hacks #131706

Merged

matthiaskrgr added a commit to matthiaskrgr/rust that referenced this issue Oct 14, 2024

Rollup merge of rust-lang#131706 - GKFX:fix-const-hacks, r=tgross35

2fa07c7

Fix two const-hacks Fix two pieces of code marked `FIXME(const-hack)` related to const_option rust-lang#67441.

compiler-errors added a commit to compiler-errors/rust that referenced this issue Oct 15, 2024

Rollup merge of rust-lang#131706 - GKFX:fix-const-hacks, r=tgross35

08c12fa

Fix two const-hacks Fix two pieces of code marked `FIXME(const-hack)` related to const_option rust-lang#67441.

matthiaskrgr added a commit to matthiaskrgr/rust that referenced this issue Oct 15, 2024

Rollup merge of rust-lang#131706 - GKFX:fix-const-hacks, r=tgross35

83252bd

Fix two const-hacks Fix two pieces of code marked `FIXME(const-hack)` related to const_option rust-lang#67441.

apiraino removed the to-announce Announce this issue on triage meeting label Oct 17, 2024

langston-barrett mentioned this issue Oct 18, 2024

Use nonzero_lit AFLplusplus/LibAFL#2589

Merged

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Tracking issue for const `Option` functions #67441

Tracking issue for const `Option` functions #67441

9999years commented Dec 20, 2019 •

edited by RalfJung

Loading

peter-lyons-kehl commented Feb 22, 2021

memoryruins commented Feb 22, 2021

davidhewitt commented Mar 13, 2021

jhpratt commented Mar 13, 2021

davidhewitt commented Mar 13, 2021

jhpratt commented Mar 13, 2021

jhpratt commented Apr 13, 2021

CodesInChaos commented Apr 29, 2021

mbartlett21 commented Jun 8, 2021

rfcbot commented Oct 1, 2024

tgross35 commented Oct 1, 2024

rfcbot commented Oct 11, 2024

RalfJung commented Oct 13, 2024

Tracking issue for const Option functions #67441

Tracking issue for const Option functions #67441

Comments

9999years commented Dec 20, 2019 • edited by RalfJung Loading

peter-lyons-kehl commented Feb 22, 2021

memoryruins commented Feb 22, 2021

davidhewitt commented Mar 13, 2021

jhpratt commented Mar 13, 2021

davidhewitt commented Mar 13, 2021

jhpratt commented Mar 13, 2021

jhpratt commented Apr 13, 2021

CodesInChaos commented Apr 29, 2021

mbartlett21 commented Jun 8, 2021

rfcbot commented Oct 1, 2024

tgross35 commented Oct 1, 2024

rfcbot commented Oct 11, 2024

RalfJung commented Oct 13, 2024

Tracking issue for const `Option` functions #67441

Tracking issue for const `Option` functions #67441

9999years commented Dec 20, 2019 •

edited by RalfJung

Loading