Merge branch 'main' into main

Author: peter-jerry-ye

NOTICE

@@ -80,6 +80,8 @@ File `float/exp.mbt`, `float/log.mbt`, `double/mod_nonjs.mbt` and `double/scalbn
   and `src/math/exp2f_data.c`.
 - `double/mod_nonjs.mbt` is adapted from `src/math/fmod.c`.
 - `double/scalbn.mbt` is adapted from `src/math/scalbn.c`.
+- `math/hyperbolic.mbt` is adapted from `src/math/sinh.c`, `src/math/cosh.c`,
+`src/math/tanh.c`, `src/math/asinh.c`, `src/math/acosh.c`, and `src/math/atanh.c`.
 
 `float/log.mbt` and `float/exp.mbt` files are Copyright (c) 2017-2018 Arm Limited and licensed under the MIT
 license.
@@ -105,7 +107,8 @@ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-`double/mod_nonjs.mbt` and `double/scalbn.mbt` are licensed under the following license:
+`double/mod_nonjs.mbt`, `double/scalbn.mbt`, `math/algebraic.mbt`,
+`math/log.mbt` and `math/pow.mbt` are licensed under the following license:
 
 Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
 

abort/abort.mbt

@@ -23,10 +23,10 @@
 ///
 /// Returns a value of type `T`. However, this function never actually returns a
 /// value as it always causes a panic.
-pub fn abort[T](msg : String) -> T {
+pub fn[T] abort(msg : String) -> T {
   let _ = msg
   panic_impl()
 }
 
 ///|
-fn panic_impl[T]() -> T = "%panic"
+fn[T] panic_impl() -> T = "%panic"

abort/abort.mbti

@@ -1,7 +1,7 @@
 package "moonbitlang/core/abort"
 
 // Values
-fn abort[T](String) -> T
+fn[T] abort(String) -> T
 
 // Types and methods
 

array/README.mbt.md

@@ -16,9 +16,9 @@ test "array creation" {
 
   // Creating from iterator
   let arr3 = Array::from_iter("hello".iter())
-  inspect!(arr1, content="[1, 2, 3]")
-  inspect!(arr2, content="[0, 2, 4]")
-  inspect!(arr3, content="['h', 'e', 'l', 'l', 'o']")
+  inspect(arr1, content="[1, 2, 3]")
+  inspect(arr2, content="[0, 2, 4]")
+  inspect(arr3, content="['h', 'e', 'l', 'l', 'o']")
 }
 ```
 
@@ -44,9 +44,9 @@ test "array operations" {
 
   // Finding last element
   let last = nums.last()
-  inspect!(neg_evens, content="[-2, -4]")
-  inspect!(sum, content="15")
-  inspect!(last, content="Some(5)")
+  inspect(neg_evens, content="[-2, -4]")
+  inspect(sum, content="15")
+  inspect(last, content="Some(5)")
 }
 ```
 
@@ -61,13 +61,13 @@ test "sorting" {
   // Basic sorting - creates new sorted array
   let sorted1 = arr.copy()
   sorted1.sort()
-  inspect!(sorted1, content="[1, 1, 2, 3, 4, 5, 6, 9]")
+  inspect(sorted1, content="[1, 1, 2, 3, 4, 5, 6, 9]")
 
   // Custom comparison
   let strs = ["aa", "b", "ccc"]
   let sorted2 = strs.copy()
   sorted2.sort_by(fn(a, b) { a.length().compare(b.length()) })
-  inspect!(
+  inspect(
     sorted2,
     content=
       #|["b", "aa", "ccc"]
@@ -78,7 +78,7 @@ test "sorting" {
   let pairs = [(2, "b"), (1, "a"), (3, "c")]
   let sorted3 = pairs.copy()
   sorted3.sort_by_key(fn(p) { p.0 })
-  inspect!(
+  inspect(
     sorted3,
     content=
       #|[(1, "a"), (2, "b"), (3, "c")]
@@ -101,8 +101,8 @@ test "array views" {
 
   // Modify view in-place
   view.map_inplace(fn(x) { x + 1 })
-  inspect!(doubled, content="[4, 6, 8]")
-  inspect!(arr, content="[1, 3, 4, 5, 5]")
+  inspect(doubled, content="[4, 6, 8]")
+  inspect(arr, content="[1, 3, 4, 5, 5]")
 }
 ```
 
@@ -123,10 +123,10 @@ test "fixed arrays" {
   // Check if array starts/ends with sequence
   let starts = fixed.starts_with([1, 2])
   let ends = fixed.ends_with([2, 3])
-  inspect!(combined, content="[1, 2, 3, 4, 5]")
-  inspect!(has_two, content="true")
-  inspect!(starts, content="true")
-  inspect!(ends, content="true")
+  inspect(combined, content="[1, 2, 3, 4, 5]")
+  inspect(has_two, content="true")
+  inspect(starts, content="true")
+  inspect(ends, content="true")
 }
 ```
 
@@ -145,7 +145,7 @@ test "utilities" {
   // Using deterministic `rand` function below for demonstration
   // NOTE: When using a normal `rand` function, the actual result may vary
   let shuffled = nums.shuffle(rand=fn(_) { 1 })
-  inspect!(joined, content="hello world")
-  inspect!(shuffled, content="[1, 3, 4, 5, 2]")
+  inspect(joined, content="hello world")
+  inspect(shuffled, content="[1, 3, 4, 5, 2]")
 }
 ```

array/array.mbt

@@ -28,10 +28,10 @@
 /// test "Array::from_iter" {
 ///   let iter = Iter::singleton(42)
 ///   let arr = Array::from_iter(iter)
-///   inspect!(arr, content="[42]")
+///   inspect(arr, content="[42]")
 /// }
 /// ```
-pub fn Array::from_iter[T](iter : Iter[T]) -> Array[T] {
+pub fn[T] Array::from_iter(iter : Iter[T]) -> Array[T] {
   iter.collect()
 }
 
@@ -48,7 +48,7 @@ pub fn Array::from_iter[T](iter : Iter[T]) -> Array[T] {
 /// u.push_iter(v.iter())
 /// assert_eq!(u, [1, 2, 3, 4, 5, 6])
 /// ```
-pub fn push_iter[T](self : Array[T], iter : Iter[T]) -> Unit {
+pub fn[T] push_iter(self : Array[T], iter : Iter[T]) -> Unit {
   for x in iter {
     self.push(x)
   }
@@ -74,10 +74,10 @@ pub fn push_iter[T](self : Array[T], iter : Iter[T]) -> Unit {
 /// ```moonbit
 /// test "Array::makei" {
 ///   let arr = Array::makei(3, fn(i) { i * 2 })
-///   inspect!(arr, content="[0, 2, 4]")
+///   inspect(arr, content="[0, 2, 4]")
 /// }
 /// ```
-pub fn Array::makei[T](length : Int, value : (Int) -> T) -> Array[T] {
+pub fn[T] Array::makei(length : Int, value : (Int) -> T) -> Array[T] {
   if length <= 0 {
     []
   } else {
@@ -105,7 +105,7 @@ pub fn Array::makei[T](length : Int, value : (Int) -> T) -> Array[T] {
 /// }
 /// Array::shuffle_in_place(arr, rand=rand)
 /// ```
-pub fn shuffle_in_place[T](self : Array[T], rand~ : (Int) -> Int) -> Unit {
+pub fn[T] shuffle_in_place(self : Array[T], rand~ : (Int) -> Int) -> Unit {
   let n = self.length()
   for i = n - 1; i > 0; i = i - 1 {
     let j = rand(i + 1) % (i + 1)
@@ -131,7 +131,7 @@ pub fn shuffle_in_place[T](self : Array[T], rand~ : (Int) -> Int) -> Unit {
 /// }
 /// let _shuffled = Array::shuffle(arr, rand=rand)
 /// ```
-pub fn shuffle[T](self : Array[T], rand~ : (Int) -> Int) -> Array[T] {
+pub fn[T] shuffle(self : Array[T], rand~ : (Int) -> Int) -> Array[T] {
   let new_arr = self.copy()
   Array::shuffle_in_place(new_arr, rand~)
   new_arr
@@ -147,7 +147,7 @@ pub fn shuffle[T](self : Array[T], rand~ : (Int) -> Int) -> Array[T] {
 /// 
 /// # Returns
 /// 
-pub fn filter_map[A, B](self : Array[A], f : (A) -> B?) -> Array[B] {
+pub fn[A, B] filter_map(self : Array[A], f : (A) -> B?) -> Array[B] {
   let result = []
   for x in self {
     if f(x) is Some(x) {
@@ -173,12 +173,12 @@ pub fn filter_map[A, B](self : Array[A], f : (A) -> B?) -> Array[B] {
 /// ```moonbit
 /// test "last" {
 ///   let arr = [1, 2, 3]
-///   inspect!(arr.last(), content="Some(3)")
+///   inspect(arr.last(), content="Some(3)")
 ///   let empty : Array[Int] = []
-///   inspect!(empty.last(), content="None")
+///   inspect(empty.last(), content="None")
 /// }
 /// ```
-pub fn last[A](self : Array[A]) -> A? {
+pub fn[A] last(self : Array[A]) -> A? {
   match self {
     [] => None
     [.., last] => Some(last)
@@ -202,10 +202,10 @@ pub fn last[A](self : Array[A]) -> A? {
 /// test "zip" {
 ///   let arr1 = [1, 2, 3]
 ///   let arr2 = ['a', 'b', 'c']
-///   inspect!(arr1.zip(arr2), content="[(1, 'a'), (2, 'b'), (3, 'c')]")
+///   inspect(arr1.zip(arr2), content="[(1, 'a'), (2, 'b'), (3, 'c')]")
 /// }
 /// ```
-pub fn zip[A, B](self : Array[A], other : Array[B]) -> Array[(A, B)] {
+pub fn[A, B] zip(self : Array[A], other : Array[B]) -> Array[(A, B)] {
   let length = if self.length() < other.length() {
     self.length()
   } else {
@@ -237,10 +237,10 @@ pub fn zip[A, B](self : Array[A], other : Array[B]) -> Array[(A, B)] {
 ///   let arr1 = [1, 2, 3]
 ///   let arr2 = [4, 5, 6]
 ///   let add = fn(a, b) { a + b }
-///   inspect!(zip_with(arr1, arr2, add), content="[5, 7, 9]")
+///   inspect(zip_with(arr1, arr2, add), content="[5, 7, 9]")
 /// }
 /// ```
-pub fn zip_with[A, B, C](
+pub fn[A, B, C] zip_with(
   l : Array[A],
   r : Array[B],
   merge : (A, B) -> C
@@ -271,10 +271,10 @@ pub fn zip_with[A, B, C](
 /// test "zip_to_iter2" {
 ///   let arr1 = [1, 2, 3]
 ///   let arr2 = ['a', 'b', 'c']
-///   inspect!(arr1.zip_to_iter2(arr2).to_array(), content="[(1, 'a'), (2, 'b'), (3, 'c')]")
+///   inspect(arr1.zip_to_iter2(arr2).to_array(), content="[(1, 'a'), (2, 'b'), (3, 'c')]")
 /// }
 /// ```
-pub fn zip_to_iter2[A, B](self : Array[A], other : Array[B]) -> Iter2[A, B] {
+pub fn[A, B] zip_to_iter2(self : Array[A], other : Array[B]) -> Iter2[A, B] {
   Iter2::new(fn(yield_) {
     let length = if self.length() < other.length() {
       self.length()
@@ -302,5 +302,27 @@ pub impl[X : @quickcheck.Arbitrary] @quickcheck.Arbitrary for Array[X] with arbi
 
 ///|
 pub fn join(self : Array[String], separator : String) -> String {
-  @string.concat(self, separator~)
+  match self {
+    [] => ""
+    [hd, .. tl] => {
+      let mut size_hint = hd.length()
+      for s in tl {
+        size_hint += s.length() + separator.length()
+      }
+      size_hint = size_hint << 1
+      let buf = StringBuilder::new(size_hint~)
+      buf.write_string(hd)
+      if separator == "" {
+        for s in tl {
+          buf.write_string(s)
+        }
+      } else {
+        for s in tl {
+          buf.write_string(separator)
+          buf.write_string(s)
+        }
+      }
+      buf.to_string()
+    }
+  }
 }

array/array.mbti

@@ -6,31 +6,31 @@ import(
 )
 
 // Values
-fn copy[T](Array[T]) -> Array[T]
+fn[T] copy(Array[T]) -> Array[T]
 
-fn filter_map[A, B](Array[A], (A) -> B?) -> Array[B]
+fn[A, B] filter_map(Array[A], (A) -> B?) -> Array[B]
 
 fn join(Array[String], String) -> String
 
-fn last[A](Array[A]) -> A?
+fn[A] last(Array[A]) -> A?
 
-fn push_iter[T](Array[T], Iter[T]) -> Unit
+fn[T] push_iter(Array[T], Iter[T]) -> Unit
 
-fn shuffle[T](Array[T], rand~ : (Int) -> Int) -> Array[T]
+fn[T] shuffle(Array[T], rand~ : (Int) -> Int) -> Array[T]
 
-fn shuffle_in_place[T](Array[T], rand~ : (Int) -> Int) -> Unit
+fn[T] shuffle_in_place(Array[T], rand~ : (Int) -> Int) -> Unit
 
-fn sort[T : Compare](Array[T]) -> Unit
+fn[T : Compare] sort(Array[T]) -> Unit
 
-fn sort_by[T](Array[T], (T, T) -> Int) -> Unit
+fn[T] sort_by(Array[T], (T, T) -> Int) -> Unit
 
-fn sort_by_key[T, K : Compare](Array[T], (T) -> K) -> Unit
+fn[T, K : Compare] sort_by_key(Array[T], (T) -> K) -> Unit
 
-fn zip[A, B](Array[A], Array[B]) -> Array[(A, B)]
+fn[A, B] zip(Array[A], Array[B]) -> Array[(A, B)]
 
-fn zip_to_iter2[A, B](Array[A], Array[B]) -> Iter2[A, B]
+fn[A, B] zip_to_iter2(Array[A], Array[B]) -> Iter2[A, B]
 
-fn zip_with[A, B, C](Array[A], Array[B], (A, B) -> C) -> Array[C]
+fn[A, B, C] zip_with(Array[A], Array[B], (A, B) -> C) -> Array[C]
 
 // Types and methods
 impl FixedArray {
@@ -99,6 +99,7 @@ impl ArrayView {
   fold[A, B](Self[A], init~ : B, (B, A) -> B) -> B
   foldi[A, B](Self[A], init~ : B, (Int, B, A) -> B) -> B
   iter[A](Self[A]) -> Iter[A]
+  iter2[A](Self[A]) -> Iter2[Int, A]
   map[T, U](Self[T], (T) -> U) -> Array[U]
   map_inplace[T](Self[T], (T) -> T) -> Unit
   mapi[T, U](Self[T], (Int, T) -> U) -> Array[U]

array/array_js.mbt

@@ -16,16 +16,16 @@
 priv extern type JSArray
 
 ///|
-fn JSArray::ofAnyArray[T](array : Array[T]) -> JSArray = "%identity"
+fn[T] JSArray::ofAnyArray(array : Array[T]) -> JSArray = "%identity"
 
 ///|
-fn JSArray::toAnyArray[T](self : JSArray) -> Array[T] = "%identity"
+fn[T] JSArray::toAnyArray(self : JSArray) -> Array[T] = "%identity"
 
 ///|
-fn JSArray::ofAnyFixedArray[T](array : FixedArray[T]) -> JSArray = "%identity"
+fn[T] JSArray::ofAnyFixedArray(array : FixedArray[T]) -> JSArray = "%identity"
 
 ///|
-fn JSArray::toAnyFixedArray[T](self : JSArray) -> FixedArray[T] = "%identity"
+fn[T] JSArray::toAnyFixedArray(self : JSArray) -> FixedArray[T] = "%identity"
 
 ///|
 extern "js" fn JSArray::copy(self : JSArray) -> JSArray =
@@ -47,10 +47,10 @@ extern "js" fn JSArray::copy(self : JSArray) -> JSArray =
 /// test "copy" {
 ///   let original = [1, 2, 3]
 ///   let copied = original.copy()
-///   inspect!(copied, content="[1, 2, 3]")
-///   inspect!(physical_equal(original, copied), content="false")
+///   inspect(copied, content="[1, 2, 3]")
+///   inspect(physical_equal(original, copied), content="false")
 /// }
 /// ```
-pub fn copy[T](self : Array[T]) -> Array[T] {
+pub fn[T] copy(self : Array[T]) -> Array[T] {
   JSArray::ofAnyArray(self).copy().toAnyArray()
 }

array/array_nonjs.mbt

@@ -28,11 +28,11 @@
 /// test "copy" {
 ///   let original = [1, 2, 3]
 ///   let copied = original.copy()
-///   inspect!(copied, content="[1, 2, 3]")
-///   inspect!(physical_equal(original, copied), content="false")
+///   inspect(copied, content="[1, 2, 3]")
+///   inspect(physical_equal(original, copied), content="false")
 /// }
 /// ```
-pub fn copy[T](self : Array[T]) -> Array[T] {
+pub fn[T] copy(self : Array[T]) -> Array[T] {
   let len = self.length()
   if len == 0 {
     []