feat: Add Option<T> to noir stdlib

crates/nargo_cli/tests/test_data/option/Nargo.toml

@@ -0,0 +1,5 @@
+[package]
+authors = [""]
+compiler_version = "0.7.0"
+
+[dependencies]

crates/nargo_cli/tests/test_data/option/src/main.nr

@@ -0,0 +1,53 @@
+use dep::std::option::Option;
+
+fn main() {
+    let none = Option::none();
+    let some = Option::some(3);
+
+    assert(none.is_none());
+    assert(some.is_some());
+
+    assert(some.unwrap() == 3);
+
+    assert(none.unwrap_or(2) == 2);
+    assert(some.unwrap_or(2) == 3);
+
+    assert(none.unwrap_or_else(|| 5) == 5);
+    assert(some.unwrap_or_else(|| 5) == 3);
+
+    assert(none.map(|x| x * 2).is_none());
+    assert(some.map(|x| x * 2).unwrap() == 6);
+
+    assert(none.map_or(0, |x| x * 2) == 0);
+    assert(some.map_or(0, |x| x * 2) == 6);
+
+    assert(none.map_or_else(|| 0, |x| x * 2) == 0);
+    assert(some.map_or_else(|| 0, |x| x * 2) == 6);
+
+    assert(none.and(none).is_none());
+    assert(none.and(some).is_none());
+    assert(some.and(none).is_none());
+    assert(some.and(some).is_some());
+
+    let add1_u64 = |value: Field| Option::some(value as u64 + 1);
+
+    assert(none.and_then(|_value| Option::none()).is_none());
+    assert(none.and_then(add1_u64).is_none());
+    assert(some.and_then(|_value| Option::none()).is_none());
+    assert(some.and_then(add1_u64).unwrap() == 4);
+
+    assert(none.or(none).is_none());
+    assert(none.or(some).is_some());
+    assert(some.or(none).is_some());
+    assert(some.or(some).is_some());
+
+    assert(none.or_else(|| Option::none()).is_none());
+    assert(none.or_else(|| Option::some(5)).is_some());
+    assert(some.or_else(|| Option::none()).is_some());
+    assert(some.or_else(|| Option::some(5)).is_some());
+
+    assert(none.xor(none).is_none());
+    assert(none.xor(some).is_some());
+    assert(some.xor(none).is_some());
+    assert(some.xor(some).is_none());
+}

noir_stdlib/src/lib.nr

@@ -14,6 +14,7 @@ mod ec;
 mod unsafe;
 mod collections;
 mod compat;
+mod option;
 
 // Oracle calls are required to be wrapped in an unconstrained function
 // Thus, the only argument to the `println` oracle is expected to always be an ident 

noir_stdlib/src/option.nr

@@ -0,0 +1,113 @@
+struct Option<T> {
+    _is_some: bool,
+    value: T,
+}
+
+impl<T> Option<T> {
+    fn none() -> Self {
+        Self { _is_some: false, value: crate::unsafe::zeroed() }
+    }
+
+    fn some(value: T) -> Self {
+        Self { _is_some: true, value }
+    }
+
+    fn is_none(self) -> bool {
+        !self._is_some
+    }
+
+    fn is_some(self) -> bool {
+        self._is_some
+    }
+
+    fn unwrap(self) -> T {
+        assert(self._is_some);
+        self.value
+    }
+
+    fn unwrap_or(self, default: T) -> T {
+        if self._is_some {
+            self.value
+        } else {
+            default
+        }
+    }
+
+    fn unwrap_or_else(self, default: fn() -> T) -> T {
+        if self._is_some {
+            self.value
+        } else {
+            default()
+        }
+    }
+
+    fn map<U>(self, f: fn(T) -> U) -> Option<U> {
+        if self._is_some {
+            Option::some(f(self.value))
+        } else {
+            Option::none()
+        }
+    }
+
+    fn map_or<U>(self, default: U, f: fn(T) -> U) -> U {
+        if self._is_some {
+            f(self.value)
+        } else {
+            default
+        }
+    }
+
+    fn map_or_else<U>(self, default: fn() -> U, f: fn(T) -> U) -> U {
+        if self._is_some {
+            f(self.value)
+        } else {
+            default()
+        }
+    }
+
+    fn and(self, other: Self) -> Self {
+        if self.is_none() {
+            Option::none()
+        } else {
+            other
+        }
+    }
+
+    fn and_then<U>(self, f: fn(T) -> Option<U>) -> Option<U> {
+        if self._is_some {
+            f(self.value)
+        } else {
+            Option::none()
+        }
+    }
+
+    fn or(self, other: Self) -> Self {
+        if self._is_some {
+            self
+        } else {
+            other
+        }
+    }
+
+    fn or_else<U>(self, default: fn() -> Option<T>) -> Option<T> {
+        if self._is_some {
+            self
+        } else {
+            default()
+        }
+    }
+
+    fn xor(self, other: Self) -> Self {
+        if self._is_some {
+            if other._is_some {
+                Option::none()
+            } else {
+                self
+            }
+        } else if other._is_some {
+            other
+        } else {
+            Option::none()
+        }
+    }
+}