Merge branch 'main' into Feat/@ArrayView-blit_to()

Author: Asterless

.github/workflows/check.yml

@@ -82,10 +82,6 @@ jobs:
         run: |
           moon test --target native --release
 
-      - name: moon test --doc
-        run: |
-          moon test --doc
-
       - name: moon bundle
         run: moon bundle --all
 
@@ -227,10 +223,6 @@ jobs:
         env: 
           MOONC_INTERNAL_PARAMS: allocator = tlsf-mbt |
 
-      - name: moon test --doc
-        run: |
-          moon test --doc
-
       - name: moon check
         run: moon check
 

array/array.mbti

@@ -7,33 +7,9 @@ import(
 )
 
 // Values
-fn[T] copy(Array[T]) -> Array[T]
-
-fn[A, B] filter_map(Array[A], (A) -> B? raise?) -> Array[B] raise?
-
-fn join(Array[String], @string.StringView) -> String
-
-fn[A] last(Array[A]) -> A?
-
 #deprecated
 fn[T] push_iter(Array[T], Iter[T]) -> Unit
 
-fn[T] shuffle(Array[T], rand~ : (Int) -> Int) -> Array[T]
-
-fn[T] shuffle_in_place(Array[T], rand~ : (Int) -> Int) -> Unit
-
-fn[T : Compare] sort(Array[T]) -> Unit
-
-fn[T] sort_by(Array[T], (T, T) -> Int) -> Unit
-
-fn[T, K : Compare] sort_by_key(Array[T], (T) -> K) -> Unit
-
-fn[T1, T2] unzip(Array[(T1, T2)]) -> (Array[T1], Array[T2])
-
-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 raise?) -> Array[C] raise?
 
 // Types and methods
@@ -118,7 +94,7 @@ impl[X : Show] Show for ArrayView[X]
 impl[A : @quickcheck.Arbitrary] @quickcheck.Arbitrary for ArrayView[A]
 
 // Type aliases
-pub typealias View[T] = ArrayView[T]
+pub typealias ArrayView as View
 
 // Traits
 

array/array_test.mbt

@@ -401,15 +401,15 @@ test "flatten" {
 
 ///|
 test "fold" {
-  let sum = [1, 2, 3, 4, 5].fold(init=0, fn { sum, elem => sum + elem })
+  let sum = [1, 2, 3, 4, 5].fold(init=0, (sum, elem) => sum + elem)
   assert_eq(sum, 15)
 }
 
 ///|
 test "rev_fold" {
-  let sum = [1, 2, 3, 4, 5].rev_fold(init=0, fn { sum, elem => sum + elem })
+  let sum = [1, 2, 3, 4, 5].rev_fold(init=0, (sum, elem) => sum + elem)
   assert_eq(sum, 15)
-  let op = fn { sum, elem => sum - elem }
+  let op = (sum, elem) => sum - elem
   let data = [1, 2, 3, 4, 5]
   let ss0 = data.rev_fold(init=0, op)
   let ss1 = data.rev().fold(init=0, op)
@@ -418,19 +418,15 @@ test "rev_fold" {
 
 ///|
 test "foldi" {
-  let sum = [1, 2, 3, 4, 5].foldi(init=0, fn {
-    index, sum, _elem => sum + index
-  })
+  let sum = [1, 2, 3, 4, 5].foldi(init=0, (index, sum, _elem) => sum + index)
   assert_eq(sum, 10)
 }
 
 ///|
 test "rev_foldi" {
-  let sum = [1, 2, 3, 4, 5].rev_foldi(init=0, fn {
-    index, sum, _elem => sum + index
-  })
+  let sum = [1, 2, 3, 4, 5].rev_foldi(init=0, (index, sum, _elem) => sum + index)
   assert_eq(sum, 10)
-  let op = fn { index, sum, elem => index - sum - elem }
+  let op = (index, sum, elem) => index - sum - elem
   let data = [1, 2, 3, 4, 5, 10]
   let v0 = data.rev_foldi(init=0, op)
   let v1 = data.rev().foldi(init=0, op)
@@ -514,13 +510,10 @@ test "shrink_to_fit_2" {
 ///|
 test "iter" {
   let buf = StringBuilder::new(size_hint=5)
-  [1, 2, 3, 4, 5].iter().each(fn { x => buf.write_string(x.to_string()) })
+  [1, 2, 3, 4, 5].iter().each(x => buf.write_string(x.to_string()))
   inspect(buf, content="12345")
   buf.reset()
-  [1, 2, 3, 4, 5]
-  .iter()
-  .take(2)
-  .each(fn { x => buf.write_string(x.to_string()) })
+  [1, 2, 3, 4, 5].iter().take(2).each(x => buf.write_string(x.to_string()))
   inspect(buf, content="12")
 }
 

array/fixedarray.mbt

@@ -341,12 +341,12 @@ pub fn[T] FixedArray::makei(
 
 ///|
 test "fixedarray_new_with_index" {
-  let empty = FixedArray::makei(0, fn { i => i })
+  let empty = FixedArray::makei(0, i => i)
   assert_eq(empty.length(), 0)
-  let simple_arr = FixedArray::makei(1, fn { i => i })
+  let simple_arr = FixedArray::makei(1, i => i)
   assert_eq(simple_arr.length(), 1)
   assert_eq(simple_arr[0], 0)
-  let arr = FixedArray::makei(2, fn { i => i })
+  let arr = FixedArray::makei(2, i => i)
   assert_eq(arr.length(), 2)
   assert_eq(arr[0], 0)
   assert_eq(arr[1], 1)
@@ -385,7 +385,7 @@ test "from_array" {
 ///
 /// # Example
 /// ```mbt
-///   let sum = [1, 2, 3, 4, 5].fold(init=0, fn { sum, elem => sum + elem })
+///   let sum = [1, 2, 3, 4, 5].fold(init=0, (sum, elem) => sum + elem)
 ///   assert_eq(sum, 15)
 /// ```
 pub fn[A, B] FixedArray::fold(
@@ -402,13 +402,12 @@ pub fn[A, B] FixedArray::fold(
 
 ///|
 test "fold" {
-  let sum = ([] : FixedArray[_]).fold(init=1, fn { sum, elem => sum + elem })
+  let sum = ([] : FixedArray[_]).fold(init=1, (sum, elem) => sum + elem)
   assert_eq(sum, 1)
-  let sum = ([1] : FixedArray[_]).fold(init=2, fn { sum, elem => sum + elem })
+  let sum = ([1] : FixedArray[_]).fold(init=2, (sum, elem) => sum + elem)
   assert_eq(sum, 3)
-  let sum = ([1, 2, 3, 4, 5] : FixedArray[_]).fold(init=0, fn {
-    sum, elem => sum + elem
-  })
+  let sum = ([1, 2, 3, 4, 5] : FixedArray[_]).fold(init=0, (sum, elem) => sum +
+    elem)
   assert_eq(sum, 15)
 }
 
@@ -417,7 +416,7 @@ test "fold" {
 ///
 /// # Example
 /// ```mbt
-///   let sum = [1, 2, 3, 4, 5].rev_fold(init=0, fn { sum, elem => sum + elem })
+///   let sum = [1, 2, 3, 4, 5].rev_fold(init=0, (sum, elem) => sum + elem)
 ///   assert_eq(sum, 15)
 /// ```
 pub fn[A, B] FixedArray::rev_fold(
@@ -434,15 +433,12 @@ pub fn[A, B] FixedArray::rev_fold(
 
 ///|
 test "rev_fold" {
-  let sum = ([] : FixedArray[_]).rev_fold(init=1, fn { sum, elem => sum + elem })
+  let sum = ([] : FixedArray[_]).rev_fold(init=1, (sum, elem) => sum + elem)
   assert_eq(sum, 1)
-  let sum = ([1] : FixedArray[_]).rev_fold(init=2, fn {
-    sum, elem => sum + elem
-  })
+  let sum = ([1] : FixedArray[_]).rev_fold(init=2, (sum, elem) => sum + elem)
   assert_eq(sum, 3)
-  let sum = ([1, 2, 3, 4, 5] : FixedArray[_]).rev_fold(init=0, fn {
-    sum, elem => sum + elem
-  })
+  let sum = ([1, 2, 3, 4, 5] : FixedArray[_]).rev_fold(init=0, (sum, elem) => sum +
+    elem)
   assert_eq(sum, 15)
 }
 
@@ -451,7 +447,7 @@ test "rev_fold" {
 ///
 /// # Example
 /// ```mbt
-///   let sum = [1, 2, 3, 4, 5].foldi(init=0, fn { index, sum, _elem => sum + index })
+///   let sum = [1, 2, 3, 4, 5].foldi(init=0, (index, sum, _elem) => sum + index)
 ///   assert_eq(sum, 10)
 /// ```
 pub fn[A, B] FixedArray::foldi(
@@ -468,7 +464,7 @@ pub fn[A, B] FixedArray::foldi(
 
 ///|
 test "fold_lefti" {
-  let f = fn { index, sum, elem => index + sum + elem }
+  let f = (index, sum, elem) => index + sum + elem
   {
     let sum = ([] : FixedArray[_]).foldi(init=1, f)
     assert_eq(sum, 1)
@@ -486,7 +482,7 @@ test "fold_lefti" {
 ///
 /// # Example
 /// ```mbt
-///   let sum = [1, 2, 3, 4, 5].rev_foldi(init=0, fn { index, sum, _elem => sum + index })
+///   let sum = [1, 2, 3, 4, 5].rev_foldi(init=0, (index, sum, _elem) => sum + index)
 ///   assert_eq(sum, 10)
 /// ```
 pub fn[A, B] FixedArray::rev_foldi(
@@ -504,7 +500,7 @@ pub fn[A, B] FixedArray::rev_foldi(
 
 ///|
 test "rev_foldi" {
-  let f = fn { index, sum, elem => index + sum + elem }
+  let f = (index, sum, elem) => index + sum + elem
   {
     let sum = ([] : FixedArray[_]).rev_foldi(init=1, f)
     assert_eq(sum, 1)

array/fixedarray_sort.mbt

@@ -377,14 +377,13 @@ fn[T : Compare] fixed_choose_pivot(arr : FixedArraySlice[T]) -> (Int, Bool) {
   if len >= 8 {
     let a = len / 4 * 1
     let c = len / 4 * 3
-    fn sort_2(a : Int, b : Int) {
+    letrec sort_2 = fn(a : Int, b : Int) {
       if arr[a] > arr[b] {
         arr.swap(a, b)
         swaps += 1
       }
     }
-
-    fn sort_3(a : Int, b : Int, c : Int) {
+    and sort_3 = fn(a : Int, b : Int, c : Int) {
       sort_2(a, b)
       sort_2(b, c)
       sort_2(a, b)
@@ -533,7 +532,7 @@ pub fn[T : Compare] FixedArray::is_sorted(arr : FixedArray[T]) -> Bool {
 ///|
 test "stable_sort_complex" {
   let run_lens = [86, 64, 21, 20, 22]
-  let total_len = run_lens.fold(init=0, fn { acc, x => acc + x })
+  let total_len = run_lens.fold(init=0, (acc, x) => acc + x)
   let arr = FixedArray::make(total_len, 0)
   let mut index = 0
   for i = 0, len = run_lens.length(); i < len; i = i + 1 {

array/fixedarray_sort_by.mbt

@@ -287,14 +287,13 @@ fn[T] fixed_choose_pivot_by(
   if len >= 8 {
     let a = len / 4 * 1
     let c = len / 4 * 3
-    fn sort_2(a : Int, b : Int) {
+    letrec sort_2 = fn(a : Int, b : Int) {
       if cmp(arr[a], arr[b]) > 0 {
         arr.swap(a, b)
         swaps += 1
       }
     }
-
-    fn sort_3(a : Int, b : Int, c : Int) {
+    and sort_3 = fn(a : Int, b : Int, c : Int) {
       sort_2(a, b)
       sort_2(b, c)
       sort_2(a, b)

array/sort.mbt

@@ -170,14 +170,13 @@ fn[T : Compare] choose_pivot(arr : ArrayView[T]) -> (Int, Bool) {
   if len >= 8 {
     let a = len / 4 * 1
     let c = len / 4 * 3
-    fn sort_2(a : Int, b : Int) {
+    letrec sort_2 = fn(a : Int, b : Int) {
       if arr[a] > arr[b] {
         arr.swap(a, b)
         swaps += 1
       }
     }
-
-    fn sort_3(a : Int, b : Int, c : Int) {
+    and sort_3 = fn(a : Int, b : Int, c : Int) {
       sort_2(a, b)
       sort_2(b, c)
       sort_2(a, b)

array/sort_by.mbt

@@ -192,14 +192,13 @@ fn[T] choose_pivot_by(arr : ArrayView[T], cmp : (T, T) -> Int) -> (Int, Bool) {
   if len >= 8 {
     let a = len / 4 * 1
     let c = len / 4 * 3
-    fn sort_2(a : Int, b : Int) {
+    letrec sort_2 = fn(a : Int, b : Int) {
       if cmp(arr[a], arr[b]) > 0 {
         arr.swap(a, b)
         swaps += 1
       }
     }
-
-    fn sort_3(a : Int, b : Int, c : Int) {
+    and sort_3 = fn(a : Int, b : Int, c : Int) {
       sort_2(a, b)
       sort_2(b, c)
       sort_2(a, b)

array/view.mbt

@@ -219,7 +219,7 @@ pub fn[A] View::iter2(self : View[A]) -> Iter2[Int, A] {
 ///
 /// # Example
 /// ```mbt
-///   let sum = [1, 2, 3, 4, 5][:].fold(init=0, fn { sum, elem => sum + elem })
+///   let sum = [1, 2, 3, 4, 5][:].fold(init=0, (sum, elem) => sum + elem)
 ///   assert_eq(sum, 15)
 /// ```
 pub fn[A, B] View::fold(
@@ -239,7 +239,7 @@ pub fn[A, B] View::fold(
 ///
 /// # Example
 /// ```mbt
-///   let sum = [1, 2, 3, 4, 5][:].rev_fold(init=0, fn { sum, elem => sum + elem })
+///   let sum = [1, 2, 3, 4, 5][:].rev_fold(init=0, (sum, elem) => sum + elem)
 ///   assert_eq(sum, 15)
 /// ```
 pub fn[A, B] View::rev_fold(
@@ -259,7 +259,7 @@ pub fn[A, B] View::rev_fold(
 ///
 /// # Example
 /// ```mbt
-///   let sum = [1, 2, 3, 4, 5][:].foldi(init=0, fn { index, sum, _elem => sum + index })
+///   let sum = [1, 2, 3, 4, 5][:].foldi(init=0, (index, sum, _elem) => sum + index)
 ///   assert_eq(sum, 10)
 /// ```
 pub fn[A, B] View::foldi(

bench/bench.mbt

@@ -77,6 +77,7 @@ pub fn single_bench(
 }
 
 // NOTE: use a type parameter `Any` to avoid exposing `trait OpaqueValue` to users
+
 ///|
 /// Keep a value to prevent the optimizer from removing 
 /// the calculation that produces it.