improve panic message on expect

This is something that has been bothering me for years,
which (naively) seems simple to fix.

The message passed to `.expect(msg)` is printed in
(at least potentially) confusing tway to the user:

```
let x: Option<u32> = None;
x.expect("valid x value");

// thread 'main' panicked at ...:
// valid x value
```

IMO, it would be much better if it got reported as:

```
// thread 'main' panicked at ...:
// expected: valid x value
```

Then, no matter how the message is formulated, it
should be clear that it was the *expectation*, not
the failing condition itself.

Author: dpc

library/core/src/option.rs

@@ -955,7 +955,7 @@ impl<T> Option<T> {
     pub const fn expect(self, msg: &str) -> T {
         match self {
             Some(val) => val,
-            None => expect_failed(msg),
+            None => expect_failed("expected: ", msg),
         }
     }
 
@@ -1783,7 +1783,11 @@ impl<T> Option<T> {
     where
         P: FnOnce(&mut T) -> bool,
     {
-        if self.as_mut().map_or(false, predicate) { self.take() } else { None }
+        if self.as_mut().map_or(false, predicate) {
+            self.take()
+        } else {
+            None
+        }
     }
 
     /// Replaces the actual value in the option by the value given in parameter,
@@ -2045,8 +2049,8 @@ const fn unwrap_failed() -> ! {
 #[cfg_attr(feature = "panic_immediate_abort", inline)]
 #[cold]
 #[track_caller]
-const fn expect_failed(msg: &str) -> ! {
-    panic_display(&msg)
+const fn expect_failed(prefix: &str, msg: &str) -> ! {
+    panic_fmt(const_format_args!("{prefix}{msg}"))
 }
 
 /////////////////////////////////////////////////////////////////////////////

library/core/src/result.rs

@@ -1086,7 +1086,7 @@ impl<T, E> Result<T, E> {
     {
         match self {
             Ok(t) => t,
-            Err(e) => unwrap_failed(msg, &e),
+            Err(e) => unwrap_failed("expected: ", msg, &e),
         }
     }
 
@@ -1134,7 +1134,7 @@ impl<T, E> Result<T, E> {
     {
         match self {
             Ok(t) => t,
-            Err(e) => unwrap_failed("called `Result::unwrap()` on an `Err` value", &e),
+            Err(e) => unwrap_failed("", "called `Result::unwrap()` on an `Err` value", &e),
         }
     }
 
@@ -1197,7 +1197,7 @@ impl<T, E> Result<T, E> {
         T: fmt::Debug,
     {
         match self {
-            Ok(t) => unwrap_failed(msg, &t),
+            Ok(t) => unwrap_failed("expected error: ", msg, &t),
             Err(e) => e,
         }
     }
@@ -1228,7 +1228,7 @@ impl<T, E> Result<T, E> {
         T: fmt::Debug,
     {
         match self {
-            Ok(t) => unwrap_failed("called `Result::unwrap_err()` on an `Ok` value", &t),
+            Ok(t) => unwrap_failed("", "called `Result::unwrap_err()` on an `Ok` value", &t),
             Err(e) => e,
         }
     }
@@ -1728,8 +1728,8 @@ impl<T, E> Result<Result<T, E>, E> {
 #[inline(never)]
 #[cold]
 #[track_caller]
-fn unwrap_failed(msg: &str, error: &dyn fmt::Debug) -> ! {
-    panic!("{msg}: {error:?}")
+fn unwrap_failed(prefix: &str, msg: &str, error: &dyn fmt::Debug) -> ! {
+    panic!("{prefix}{msg}: {error:?}")
 }
 
 // This is a separate function to avoid constructing a `dyn Debug`
@@ -1740,7 +1740,7 @@ fn unwrap_failed(msg: &str, error: &dyn fmt::Debug) -> ! {
 #[inline]
 #[cold]
 #[track_caller]
-fn unwrap_failed<T>(_msg: &str, _error: &T) -> ! {
+fn unwrap_failed<T>(_prefix: &str, _msg: &str, _error: &T) -> ! {
     panic!()
 }