moonbitlang · Guest0x0 · Jun 12, 2025 · Jun 11, 2025 · Jun 11, 2025 · Jun 11, 2025
diff --git a/array/array.mbt b/array/array.mbt
@@ -85,8 +85,8 @@ pub fnalias Array::push_iter
 /// ```
 pub fn[T] Array::makei(
   length : Int,
-  value : (Int) -> T?Error
-) -> Array[T]?Error {
+  value : (Int) -> T raise?
+) -> Array[T] raise? {
   if length <= 0 {
     []
   } else {
@@ -158,7 +158,10 @@ pub fn[T] shuffle(self : Array[T], rand~ : (Int) -> Int) -> Array[T] {
 /// 
 /// # Returns
 /// 
-pub fn[A, B] filter_map(self : Array[A], f : (A) -> B??Error) -> Array[B]?Error {
+pub fn[A, B] filter_map(
+  self : Array[A],
+  f : (A) -> B? raise?
+) -> Array[B] raise? {
   let result = []
   for x in self {
     if f(x) is Some(x) {
@@ -277,8 +280,8 @@ pub fn[T1, T2] unzip(self : Array[(T1, T2)]) -> (Array[T1], Array[T2]) {
 pub fn[A, B, C] zip_with(
   l : Array[A],
   r : Array[B],
-  merge : (A, B) -> C?Error
-) -> Array[C]?Error {
+  merge : (A, B) -> C raise?
+) -> Array[C] raise? {
   let length = if l.length() < r.length() { l.length() } else { r.length() }
   let arr = Array::new(capacity=length)
   for i = 0; i < length; i = i + 1 {

diff --git a/array/array.mbti b/array/array.mbti
@@ -9,7 +9,7 @@ import(
 // Values
 fn[T] copy(Array[T]) -> Array[T]
 
-fn[A, B] filter_map(Array[A], (A) -> B??Error) -> Array[B]?Error
+fn[A, B] filter_map(Array[A], (A) -> B? raise?) -> Array[B] raise?
 
 fn join(Array[String], @string.StringView) -> String
 
@@ -34,32 +34,32 @@ fn[A, B] zip(Array[A], Array[B]) -> Array[(A, B)]
 
 fn[A, B] zip_to_iter2(Array[A], Array[B]) -> Iter2[A, B]
 
-fn[A, B, C] zip_with(Array[A], Array[B], (A, B) -> C?Error) -> Array[C]?Error
+fn[A, B, C] zip_with(Array[A], Array[B], (A, B) -> C raise?) -> Array[C] raise?
 
 // Types and methods
-fn[T] FixedArray::all(Self[T], (T) -> Bool?Error) -> Bool?Error
-fn[T] FixedArray::any(Self[T], (T) -> Bool?Error) -> Bool?Error
+fn[T] FixedArray::all(Self[T], (T) -> Bool raise?) -> Bool raise?
+fn[T] FixedArray::any(Self[T], (T) -> Bool raise?) -> Bool raise?
 fn FixedArray::blit_from_bytesview(Self[Byte], Int, @bytes.View) -> Unit
 fn[T : Eq] FixedArray::contains(Self[T], T) -> Bool
 fn[T] FixedArray::copy(Self[T]) -> Self[T]
-fn[T] FixedArray::each(Self[T], (T) -> Unit?Error) -> Unit?Error
-fn[T] FixedArray::eachi(Self[T], (Int, T) -> Unit?Error) -> Unit?Error
+fn[T] FixedArray::each(Self[T], (T) -> Unit raise?) -> Unit raise?
+fn[T] FixedArray::eachi(Self[T], (Int, T) -> Unit raise?) -> Unit raise?
 fn[T : Eq] FixedArray::ends_with(Self[T], Self[T]) -> Bool
-fn[A, B] FixedArray::fold(Self[A], init~ : B, (B, A) -> B?Error) -> B?Error
-fn[A, B] FixedArray::foldi(Self[A], init~ : B, (Int, B, A) -> B?Error) -> B?Error
+fn[A, B] FixedArray::fold(Self[A], init~ : B, (B, A) -> B raise?) -> B raise?
+fn[A, B] FixedArray::foldi(Self[A], init~ : B, (Int, B, A) -> B raise?) -> B raise?
 fn[T] FixedArray::from_array(Array[T]) -> Self[T]
 fn[T] FixedArray::from_iter(Iter[T]) -> Self[T]
 fn[T : Compare] FixedArray::is_sorted(Self[T]) -> Bool
 fn FixedArray::join(Self[String], @string.StringView) -> String
 fn[A] FixedArray::last(Self[A]) -> A?
-fn[T] FixedArray::makei(Int, (Int) -> T?Error) -> Self[T]?Error
-fn[T, U] FixedArray::map(Self[T], (T) -> U?Error) -> Self[U]?Error
-fn[T, U] FixedArray::mapi(Self[T], (Int, T) -> U?Error) -> Self[U]?Error
+fn[T] FixedArray::makei(Int, (Int) -> T raise?) -> Self[T] raise?
+fn[T, U] FixedArray::map(Self[T], (T) -> U raise?) -> Self[U] raise?
+fn[T, U] FixedArray::mapi(Self[T], (Int, T) -> U raise?) -> Self[U] raise?
 fn[T] FixedArray::rev(Self[T]) -> Self[T]
-fn[T] FixedArray::rev_each(Self[T], (T) -> Unit?Error) -> Unit?Error
-fn[T] FixedArray::rev_eachi(Self[T], (Int, T) -> Unit?Error) -> Unit?Error
-fn[A, B] FixedArray::rev_fold(Self[A], init~ : B, (B, A) -> B?Error) -> B?Error
-fn[A, B] FixedArray::rev_foldi(Self[A], init~ : B, (Int, B, A) -> B?Error) -> B?Error
+fn[T] FixedArray::rev_each(Self[T], (T) -> Unit raise?) -> Unit raise?
+fn[T] FixedArray::rev_eachi(Self[T], (Int, T) -> Unit raise?) -> Unit raise?
+fn[A, B] FixedArray::rev_fold(Self[A], init~ : B, (B, A) -> B raise?) -> B raise?
+fn[A, B] FixedArray::rev_foldi(Self[A], init~ : B, (Int, B, A) -> B raise?) -> B raise?
 fn[T] FixedArray::rev_inplace(Self[T]) -> Unit
 fn[T : Eq] FixedArray::search(Self[T], T) -> Int?
 fn[T : Compare] FixedArray::sort(Self[T]) -> Unit
@@ -75,11 +75,11 @@ impl[T : Hash] Hash for FixedArray[T]
 impl[X : @quickcheck.Arbitrary] @quickcheck.Arbitrary for FixedArray[X]
 
 fn[T] Array::copy(Self[T]) -> Self[T]
-fn[A, B] Array::filter_map(Self[A], (A) -> B??Error) -> Self[B]?Error
+fn[A, B] Array::filter_map(Self[A], (A) -> B? raise?) -> Self[B] raise?
 fn[T] Array::from_iter(Iter[T]) -> Self[T]
 fn Array::join(Self[String], @string.StringView) -> String
 fn[A] Array::last(Self[A]) -> A?
-fn[T] Array::makei(Int, (Int) -> T?Error) -> Self[T]?Error
+fn[T] Array::makei(Int, (Int) -> T raise?) -> Self[T] raise?
 fn[T] Array::push_iter(Self[T], Iter[T]) -> Unit
 fn[T] Array::shuffle(Self[T], rand~ : (Int) -> Int) -> Self[T]
 fn[T] Array::shuffle_in_place(Self[T], rand~ : (Int) -> Int) -> Unit
@@ -91,23 +91,23 @@ fn[A, B] Array::zip(Self[A], Self[B]) -> Self[(A, B)]
 fn[A, B] Array::zip_to_iter2(Self[A], Self[B]) -> Iter2[A, B]
 impl[X : @quickcheck.Arbitrary] @quickcheck.Arbitrary for Array[X]
 
-fn[T] ArrayView::all(Self[T], (T) -> Bool?Error) -> Bool?Error
-fn[T] ArrayView::any(Self[T], (T) -> Bool?Error) -> Bool?Error
+fn[T] ArrayView::all(Self[T], (T) -> Bool raise?) -> Bool raise?
+fn[T] ArrayView::any(Self[T], (T) -> Bool raise?) -> Bool raise?
 fn[T : Eq] ArrayView::contains(Self[T], T) -> Bool
-fn[T] ArrayView::each(Self[T], (T) -> Unit?Error) -> Unit?Error
-fn[T] ArrayView::eachi(Self[T], (Int, T) -> Unit?Error) -> Unit?Error
-fn[T] ArrayView::filter(Self[T], (T) -> Bool?Error) -> Array[T]?Error
-fn[A, B] ArrayView::fold(Self[A], init~ : B, (B, A) -> B?Error) -> B?Error
-fn[A, B] ArrayView::foldi(Self[A], init~ : B, (Int, B, A) -> B?Error) -> B?Error
+fn[T] ArrayView::each(Self[T], (T) -> Unit raise?) -> Unit raise?
+fn[T] ArrayView::eachi(Self[T], (Int, T) -> Unit raise?) -> Unit raise?
+fn[T] ArrayView::filter(Self[T], (T) -> Bool raise?) -> Array[T] raise?
+fn[A, B] ArrayView::fold(Self[A], init~ : B, (B, A) -> B raise?) -> B raise?
+fn[A, B] ArrayView::foldi(Self[A], init~ : B, (Int, B, A) -> B raise?) -> B raise?
 fn[A] ArrayView::iter(Self[A]) -> Iter[A]
 fn[A] ArrayView::iter2(Self[A]) -> Iter2[Int, A]
 fn ArrayView::join(Self[String], @string.StringView) -> String
-fn[T, U] ArrayView::map(Self[T], (T) -> U?Error) -> Array[U]?Error
-fn[T] ArrayView::map_inplace(Self[T], (T) -> T?Error) -> Unit?Error
-fn[T, U] ArrayView::mapi(Self[T], (Int, T) -> U?Error) -> Array[U]?Error
-fn[T] ArrayView::mapi_inplace(Self[T], (Int, T) -> T?Error) -> Unit?Error
-fn[A, B] ArrayView::rev_fold(Self[A], init~ : B, (B, A) -> B?Error) -> B?Error
-fn[A, B] ArrayView::rev_foldi(Self[A], init~ : B, (Int, B, A) -> B?Error) -> B?Error
+fn[T, U] ArrayView::map(Self[T], (T) -> U raise?) -> Array[U] raise?
+fn[T] ArrayView::map_inplace(Self[T], (T) -> T raise?) -> Unit raise?
+fn[T, U] ArrayView::mapi(Self[T], (Int, T) -> U raise?) -> Array[U] raise?
+fn[T] ArrayView::mapi_inplace(Self[T], (Int, T) -> T raise?) -> Unit raise?
+fn[A, B] ArrayView::rev_fold(Self[A], init~ : B, (B, A) -> B raise?) -> B raise?
+fn[A, B] ArrayView::rev_foldi(Self[A], init~ : B, (Int, B, A) -> B raise?) -> B raise?
 fn[T] ArrayView::rev_inplace(Self[T]) -> Unit
 fn[T] ArrayView::to_array(Self[T]) -> Array[T]
 impl[T : Compare] Compare for ArrayView[T]

diff --git a/array/array_js.mbt b/array/array_js.mbt
@@ -13,7 +13,7 @@
 // limitations under the License.
 
 ///|
-priv extern type JSArray
+priv type JSArray
 
 ///|
 fn[T] JSArray::ofAnyArray(array : Array[T]) -> JSArray = "%identity"

diff --git a/array/fixedarray.mbt b/array/fixedarray.mbt
@@ -29,8 +29,8 @@
 /// ```
 pub fn[T] FixedArray::each(
   self : FixedArray[T],
-  f : (T) -> Unit?Error
-) -> Unit?Error {
+  f : (T) -> Unit raise?
+) -> Unit raise? {
   for v in self {
     f(v)
   }
@@ -83,8 +83,8 @@ test "each" {
 /// ```
 pub fn[T] FixedArray::eachi(
   self : FixedArray[T],
-  f : (Int, T) -> Unit?Error
-) -> Unit?Error {
+  f : (Int, T) -> Unit raise?
+) -> Unit raise? {
   for i, v in self {
     f(i, v)
   }
@@ -135,8 +135,8 @@ test "eachi" {
 /// ```
 pub fn[T] FixedArray::rev_each(
   self : FixedArray[T],
-  f : (T) -> Unit?Error
-) -> Unit?Error {
+  f : (T) -> Unit raise?
+) -> Unit raise? {
   for i = self.length() - 1; i >= 0; i = i - 1 {
     f(self[i])
   }
@@ -189,8 +189,8 @@ test "rev_each" {
 /// ```
 pub fn[T] FixedArray::rev_eachi(
   self : FixedArray[T],
-  f : (Int, T) -> Unit?Error
-) -> Unit?Error {
+  f : (Int, T) -> Unit raise?
+) -> Unit raise? {
   let len = self.length()
   for i in 0..<len {
     f(i, self[len - i - 1])
@@ -245,8 +245,8 @@ test "rev_eachi" {
 /// ```
 pub fn[T, U] FixedArray::map(
   self : FixedArray[T],
-  f : (T) -> U?Error
-) -> FixedArray[U]?Error {
+  f : (T) -> U raise?
+) -> FixedArray[U] raise? {
   if self.length() == 0 {
     return []
   }
@@ -280,8 +280,8 @@ test "map" {
 /// ```
 pub fn[T, U] FixedArray::mapi(
   self : FixedArray[T],
-  f : (Int, T) -> U?Error
-) -> FixedArray[U]?Error {
+  f : (Int, T) -> U raise?
+) -> FixedArray[U] raise? {
   if self.length() == 0 {
     return []
   }
@@ -328,8 +328,8 @@ test "mapi" {
 /// ```
 pub fn[T] FixedArray::makei(
   length : Int,
-  value : (Int) -> T?Error
-) -> FixedArray[T]?Error {
+  value : (Int) -> T raise?
+) -> FixedArray[T] raise? {
   if length <= 0 {
     []
   } else {
@@ -395,8 +395,8 @@ test "from_array" {
 pub fn[A, B] FixedArray::fold(
   self : FixedArray[A],
   init~ : B,
-  f : (B, A) -> B?Error
-) -> B?Error {
+  f : (B, A) -> B raise?
+) -> B raise? {
   for i = 0, acc = init; i < self.length(); {
     continue i + 1, f(acc, self[i])
   } else {
@@ -427,8 +427,8 @@ test "fold" {
 pub fn[A, B] FixedArray::rev_fold(
   self : FixedArray[A],
   init~ : B,
-  f : (B, A) -> B?Error
-) -> B?Error {
+  f : (B, A) -> B raise?
+) -> B raise? {
   for i = self.length() - 1, acc = init; i >= 0; {
     continue i - 1, f(acc, self[i])
   } else {
@@ -461,8 +461,8 @@ test "rev_fold" {
 pub fn[A, B] FixedArray::foldi(
   self : FixedArray[A],
   init~ : B,
-  f : (Int, B, A) -> B?Error
-) -> B?Error {
+  f : (Int, B, A) -> B raise?
+) -> B raise? {
   for i = 0, acc = init; i < self.length(); {
     continue i + 1, f(i, acc, self[i])
   } else {
@@ -496,8 +496,8 @@ test "fold_lefti" {
 pub fn[A, B] FixedArray::rev_foldi(
   self : FixedArray[A],
   init~ : B,
-  f : (Int, B, A) -> B?Error
-) -> B?Error {
+  f : (Int, B, A) -> B raise?
+) -> B raise? {
   let len = self.length()
   for i = len - 1, acc = init; i >= 0; {
     continue i - 1, f(len - i - 1, acc, self[i])
@@ -680,8 +680,8 @@ test "swap" {
 /// ```
 pub fn[T] FixedArray::all(
   self : FixedArray[T],
-  f : (T) -> Bool?Error
-) -> Bool?Error {
+  f : (T) -> Bool raise?
+) -> Bool raise? {
   for i in 0..<self.length() {
     if not(f(self[i])) {
       return false
@@ -719,8 +719,8 @@ test "all" {
 /// ```
 pub fn[T] FixedArray::any(
   self : FixedArray[T],
-  f : (T) -> Bool?Error
-) -> Bool?Error {
+  f : (T) -> Bool raise?
+) -> Bool raise? {
   for i in 0..<self.length() {
     if f(self[i]) {
       return true

diff --git a/array/fixedarray_sort.mbt b/array/fixedarray_sort.mbt
@@ -436,7 +436,7 @@ fn[T : Compare] fixed_sift_down(arr : FixedArraySlice[T], index : Int) -> Unit {
 }
 
 ///|
-fn fixed_test_sort(f : (FixedArray[Int]) -> Unit) -> Unit! {
+fn fixed_test_sort(f : (FixedArray[Int]) -> Unit) -> Unit raise {
   let arr : FixedArray[_] = [5, 4, 3, 2, 1]
   f(arr)
   assert_eq(arr, [1, 2, 3, 4, 5])

diff --git a/array/sort.mbt b/array/sort.mbt
@@ -229,7 +229,7 @@ fn[T : Compare] sift_down(arr : ArrayView[T], index : Int) -> Unit {
 }
 
 ///|
-fn test_sort(f : (Array[Int]) -> Unit) -> Unit! {
+fn test_sort(f : (Array[Int]) -> Unit) -> Unit raise {
   let arr = [5, 4, 3, 2, 1]
   f(arr)
   assert_eq(arr, [1, 2, 3, 4, 5])