feat: Option expect method

compiler/noirc_frontend/src/monomorphization/mod.rs

@@ -1038,10 +1038,10 @@ impl<'interner> Monomorphizer<'interner> {
         // since they cannot be passed from ACIR into Brillig
         if let HirType::Array(size, _) = typ {
             if let HirType::NotConstant = **size {
-                unreachable!("println does not support slices. Convert the slice to an array before passing it to println");
+                unreachable!("println and format strings do not support slices. Convert the slice to an array before passing it to println");
             }
         } else if matches!(typ, HirType::MutableReference(_)) {
-            unreachable!("println does not support mutable references.");
+            unreachable!("println and format strings do not support mutable references.");
         }
 
         let printable_type: PrintableType = typ.into();

docs/docs/noir/standard_library/options.md

@@ -56,6 +56,10 @@ Returns the wrapped value if `self.is_some()`. Otherwise, returns the given defa
 
 Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return a default value.
 
+### expect
+
+Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value. The custom message is expected to be a format string.
+
 ### map
 
 If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.

noir_stdlib/src/option.nr

@@ -56,6 +56,12 @@ impl<T> Option<T> {
         }
     }
 
+    /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value
+    fn expect<N, MessageTypes>(self, message: fmtstr<N, MessageTypes>) -> T {
+        assert(self.is_some(), message);
+        self._value
+    }
+
     /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.
     pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> Option<U> {
         if self._is_some {

test_programs/compile_failure/assert_msg_runtime/Prover.toml

@@ -0,0 +1,2 @@
+x = "5"
+y = "10"

test_programs/compile_failure/brillig_assert_msg_runtime/Prover.toml

@@ -0,0 +1 @@
+x = "5"

test_programs/compile_failure/option_expect/Nargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "option_expect"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.23.0"
+
+[dependencies]

test_programs/compile_failure/option_expect/src/main.nr

@@ -0,0 +1,8 @@
+fn main() {
+    let inner_value = 3;
+    let none = Option::none();
+    let some = Option::some(inner_value);
+
+    assert(some.expect(f"Should have the value {inner_value}") == 3);
+    assert(none.expect(f"Should have the value {inner_value}") == 3);
+}

test_programs/compile_failure/option_expect_bad_input/Nargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "option_expect_bad_input"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.23.0"
+
+[dependencies]

test_programs/compile_failure/option_expect_bad_input/src/main.nr

@@ -0,0 +1,6 @@
+fn main() {
+    let inner_value = 3;
+    let some = Option::some(inner_value);
+
+    assert(some.expect("Should have the value {inner_value}") == 3);
+}

test_programs/compile_success_empty/option/src/main.nr

@@ -1,5 +1,3 @@
-use dep::std::option::Option;
-
 fn main() {
     let ten = 10; // giving this a name, to ensure that the Option functions work with closures
     let none = Option::none();
@@ -22,6 +20,8 @@ fn main() {
     assert(some.map(|x| x * 2).unwrap() == 6);
     assert(some.map(|x| x * ten).unwrap() == 30);
 
+    assert(some.expect(f"Should have a value") == 3);
+
     assert(none.map_or(0, |x| x * 2) == 0);
     assert(some.map_or(0, |x| x * 2) == 6);
     assert(none.map_or(0, |x| x * ten) == 0);