Merge branch 'main' into revert-bytesview-primitive

Author: Yu-zh

array/array.mbt

@@ -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_test.mbt

@@ -716,8 +716,7 @@ test "Array[String]::join" {
   inspect(["a", "b", "c"].join(","), content="a,b,c")
   inspect(["a", "b", "c"].join(""), content="abc")
   inspect(["a", "b", "c"].join(" "), content="a b c")
-  inspect(["a", "b", "c"].join(" "), content="a b c")
-  inspect(["a", "b", "c"].join(" "), content="a b c")
-  inspect(["a", "b", "c"].join(" "), content="a b c")
-  inspect(["a", "b", "c"].join(" "), content="a b c")
+  inspect!(["123", "456"].join(""), content="123456")
+  inspect!(["aaa", "bbb", "ccc"].join(" "), content="aaa bbb ccc")
+  inspect!([].join(" "))
 }

bool/README.mbt.md

@@ -8,10 +8,6 @@ The package allows converting boolean values to various integer types. `true` is
 
 ```moonbit
 test "bool to integer conversions" {
-  // Direct function calls
-  inspect(@bool.to_int(true), content="1")
-  inspect(@bool.to_int(false), content="0")
-
   // Method syntax
   inspect(true.to_int(), content="1")
   inspect(false.to_int(), content="0")

builtin/builtin.mbti

@@ -540,6 +540,7 @@ impl String {
   get(String, Int) -> Char
   length(String) -> Int
   make(Int, Char) -> String
+  #deprecated
   op_get(String, Int) -> Char
   substring(String, start~ : Int = .., end? : Int) -> String
   to_string(String) -> String
@@ -557,6 +558,7 @@ impl FixedArray {
   blit_from_string(Self[Byte], Int, String, Int, Int) -> Unit
   blit_to[A](Self[A], Self[A], len~ : Int, src_offset~ : Int = .., dst_offset~ : Int = ..) -> Unit
   fill[T](Self[T], T) -> Unit
+  #deprecated
   get[T](Self[T], Int) -> T
   is_empty[T](Self[T]) -> Bool
   iter[T](Self[T]) -> Iter[T]
@@ -580,6 +582,7 @@ impl Bytes {
   make(Int, Byte) -> Bytes
   makei(Int, (Int) -> Byte) -> Bytes
   new(Int) -> Bytes
+  #deprecated
   of_string(String) -> Bytes
   op_get(Bytes, Int) -> Byte
   to_unchecked_string(Bytes, offset~ : Int = .., length~ : Int = ..) -> String

builtin/byte.mbt

@@ -132,8 +132,8 @@ pub impl Compare for Byte with compare(self : Byte, that : Byte) -> Int {
 }
 
 ///|
-fn alphabet(self : Int) -> String {
-  match self {
+fn alphabet(x : Int) -> String {
+  match x {
     0 => "0"
     1 => "1"
     2 => "2"

builtin/bytes.mbt

@@ -68,6 +68,7 @@ pub fn Bytes::makei(length : Int, value : (Int) -> Byte) -> Bytes {
 ///   inspect(bytes, content="b\"\\x41\\x00\\x42\\x00\\x43\\x00\"")
 /// }
 /// ```
+#deprecated("Use `str.to_bytes()` instead")
 pub fn Bytes::of_string(str : String) -> Bytes {
   FixedArray::make(str.length() * 2, Byte::default())
   ..blit_from_string(0, str, 0, str.length())

builtin/bytes_test.mbt

@@ -13,23 +13,16 @@
 // limitations under the License.
 
 ///|
-test "to_string" {
-  let bytes = Bytes::of_string("Hello, World!")
-  assert_eq!(bytes.to_unchecked_string(), "Hello, World!")
-}
+const HELLO_WORLD = b"H\x00e\x00l\x00l\x00o\x00,\x00 \x00W\x00o\x00r\x00l\x00d\x00!\x00"
 
 ///|
-test "of_string" {
-  let str = "Hello, World!"
-  let bytes = Bytes::of_string(str)
-  assert_eq!(bytes.length(), str.length() * 2)
+test "to_string" {
+  assert_eq!(HELLO_WORLD.to_unchecked_string(), "Hello, World!")
 }
 
 ///|
 test "sub_string" {
-  let bytes = Bytes::of_string("Hello, World!")
-  assert_eq!(bytes.to_unchecked_string(offset=0, length=5 * 2), "Hello")
-  // assert_eq(bytes.sub_string(10, 5 * 2), "World")?
+  assert_eq!(HELLO_WORLD.to_unchecked_string(offset=0, length=5 * 2), "Hello")
 }
 
 ///|
@@ -42,9 +35,11 @@ test "blit_from_string" {
 
 ///|
 test "copy" {
-  let bytes = Bytes::of_string("Hello, World!")
-  let copy_bytes = bytes.copy()
-  assert_eq!(copy_bytes.to_unchecked_string(), bytes.to_unchecked_string())
+  let copy_bytes = HELLO_WORLD.copy()
+  assert_eq!(
+    copy_bytes.to_unchecked_string(),
+    HELLO_WORLD.to_unchecked_string(),
+  )
 }
 
 ///|
@@ -157,10 +152,9 @@ test "set_utf16be_char" {
 
 ///|
 test "op_equal" {
-  let bytes = Bytes::of_string("Hello, World!")
-  let copy_bytes = bytes.copy()
-  assert_eq!(bytes, copy_bytes)
-  assert_not_eq!(bytes, Bytes::new(10))
+  let copy_bytes = HELLO_WORLD.copy()
+  assert_eq!(HELLO_WORLD, copy_bytes)
+  assert_not_eq!(HELLO_WORLD, Bytes::new(10))
 }
 
 ///|

builtin/intrinsics.mbt

@@ -1581,6 +1581,7 @@ pub fn[T] FixedArray::unsafe_set(
 ///   inspect(arr.get(3), content="None")
 /// }
 /// ```
+#deprecated("use `arr.op_get(i)`(arr[i]) instead")
 pub fn[T] FixedArray::get(self : FixedArray[T], idx : Int) -> T = "%fixedarray.get"
 
 ///|
@@ -1731,31 +1732,7 @@ pub fn String::length(self : String) -> Int = "%string_length"
 pub fn String::charcode_length(self : String) -> Int = "%string_length"
 
 ///|
-/// Retrieves the charcode (UTF-16 code unit) at the specified index in a string.
-///
-/// Parameters:
-///
-/// * `string` : The string from which to retrieve the charcode.
-/// * `index` : The position in the string from which to retrieve the charcode.
-///
-/// Throws a runtime error if `index` is negative or greater than or equal to the
-/// length of the string.
-///
-/// Example:
-///
-/// ```moonbit
-/// test "String::op_get" {
-///   let s = "Hello, 世界!"
-///   inspect(s[0], content="H")
-///   inspect(s[7], content="世")
-/// }
-///
-/// test "panic String::op_get/out_of_bounds" {
-///   let s = "Hello"
-///   ignore(s[5]) // Index out of bounds
-/// }
-/// ```
-///
+#deprecated("use `String::charcode_at` and `Int::to_char` instead")
 pub fn String::op_get(self : String, idx : Int) -> Char = "%string_get"
 
 ///|

builtin/panic_test.mbt

@@ -241,19 +241,19 @@ test "panic from_octets coverage for empty octets" {
 
 ///|
 test "panic sub_string with invalid byte_length" {
-  let bytes = Bytes::of_string("Hello, World!")
+  let bytes = b"Hello, World!"
   bytes.to_unchecked_string(offset=0, length=-1) |> ignore
 }
 
 ///|
 test "panic sub_string with invalid byte_offset" {
-  let bytes = Bytes::of_string("Hello, World!")
+  let bytes = b"Hello, World!"
   bytes.to_unchecked_string(offset=-1, length=5) |> ignore
 }
 
 ///|
 test "panic sub_string with invalid byte_offset + byte_length" {
-  let bytes = Bytes::of_string("Hello, World!")
+  let bytes = b"Hello, World!"
   bytes.to_unchecked_string(offset=0, length=bytes.length() + 1) |> ignore
 }
 

byte/README.mbt.md

@@ -22,7 +22,7 @@ test "byte conversion" {
   let byte = b'A'
   inspect(byte.to_uint64(), content="65")
   let byte = b' '
-  inspect(@byte.to_uint64(byte), content="32")
+  inspect(byte.to_uint64(), content="32")
 }
 ```
 

byte/byte_test.mbt

@@ -30,25 +30,25 @@ test "int to byte" {
 
 ///|
 test "grouped test for boundary cases" {
-  inspect(@moonbitlang/core/byte.to_uint64(b'\x00'), content="0")
-  inspect(@moonbitlang/core/byte.to_uint64(b'\xFF'), content="255")
+  inspect(b'\x00'.to_uint64(), content="0")
+  inspect(b'\xFF'.to_uint64(), content="255")
 }
 
 ///|
 test "grouped test for random cases" {
-  inspect(@moonbitlang/core/byte.to_uint64(b'\x10'), content="16")
-  inspect(@moonbitlang/core/byte.to_uint64(b'\x2A'), content="42")
-  inspect(@moonbitlang/core/byte.to_uint64(b'\x7F'), content="127")
-  inspect(@moonbitlang/core/byte.to_uint64(b'\x80'), content="128")
-  inspect(@moonbitlang/core/byte.to_uint64(b'\xAA'), content="170")
-  inspect(@moonbitlang/core/byte.to_uint64(b'\x55'), content="85")
+  inspect(b'\x10'.to_uint64(), content="16")
+  inspect(b'\x2A'.to_uint64(), content="42")
+  inspect(b'\x7F'.to_uint64(), content="127")
+  inspect(b'\x80'.to_uint64(), content="128")
+  inspect(b'\xAA'.to_uint64(), content="170")
+  inspect(b'\x55'.to_uint64(), content="85")
 }
 
 ///|
 test "additional random cases" {
-  inspect(@moonbitlang/core/byte.to_uint64(b'\x3C'), content="60")
-  inspect(@moonbitlang/core/byte.to_uint64(b'\x64'), content="100")
-  inspect(@moonbitlang/core/byte.to_uint64(b'\x99'), content="153")
+  inspect(b'\x3C'.to_uint64(), content="60")
+  inspect(b'\x64'.to_uint64(), content="100")
+  inspect(b'\x99'.to_uint64(), content="153")
 }
 
 ///|

char/README.mbt.md

@@ -9,18 +9,18 @@ Functions for determining if a character belongs to various ASCII categories.
 ```moonbit
 test "ascii classification" {
   // Basic ASCII checks
-  inspect(@char.is_ascii('A'), content="true")
-  inspect(@char.is_ascii('λ'), content="false")
+  inspect('A'.is_ascii(), content="true")
+  inspect('λ'.is_ascii(), content="false")
 
   // Letter classification
-  inspect(@char.is_ascii_alphabetic('Z'), content="true")
-  inspect(@char.is_ascii_alphabetic('1'), content="false")
+  inspect('Z'.is_ascii_alphabetic(), content="true")
+  inspect('1'.is_ascii_alphabetic(), content="false")
 
   // Case classification
-  inspect(@char.is_ascii_uppercase('A'), content="true")
-  inspect(@char.is_ascii_uppercase('a'), content="false")
-  inspect(@char.is_ascii_lowercase('a'), content="true")
-  inspect(@char.is_ascii_lowercase('A'), content="false")
+  inspect('A'.is_ascii_uppercase(), content="true")
+  inspect('a'.is_ascii_uppercase(), content="false")
+  inspect('a'.is_ascii_lowercase(), content="true")
+  inspect('A'.is_ascii_lowercase(), content="false")
 }
 ```
 
@@ -31,24 +31,24 @@ Functions for identifying digits in different number bases.
 ```moonbit
 test "number classification" {
   // Decimal digits
-  inspect(@char.is_ascii_digit('5'), content="true")
-  inspect(@char.is_ascii_digit('x'), content="false")
+  inspect('5'.is_ascii_digit(), content="true")
+  inspect('x'.is_ascii_digit(), content="false")
 
   // Hexadecimal digits
-  inspect(@char.is_ascii_hexdigit('F'), content="true")
-  inspect(@char.is_ascii_hexdigit('G'), content="false")
+  inspect('F'.is_ascii_hexdigit(), content="true")
+  inspect('G'.is_ascii_hexdigit(), content="false")
 
   // Octal digits
-  inspect(@char.is_ascii_octdigit('7'), content="true")
-  inspect(@char.is_ascii_octdigit('8'), content="false")
+  inspect('7'.is_ascii_octdigit(), content="true")
+  inspect('8'.is_ascii_octdigit(), content="false")
 
   // Custom base digits
-  inspect(@char.is_digit('5', 6U), content="true")
-  inspect(@char.is_digit('6', 6U), content="false")
+  inspect('5'.is_digit(6U), content="true")
+  inspect('6'.is_digit(6U), content="false")
 
   // General numeric characters
-  inspect(@char.is_numeric('1'), content="true")
-  inspect(@char.is_numeric('A'), content="false")
+  inspect('1'.is_numeric(), content="true")
+  inspect('A'.is_numeric(), content="false")
 }
 ```
 
@@ -59,17 +59,17 @@ Functions for identifying whitespace, control characters and other special chara
 ```moonbit
 test "special characters" {
   // Whitespace characters
-  inspect(@char.is_ascii_whitespace(' '), content="true")
-  inspect(@char.is_whitespace('\n'), content="true")
+  inspect(' '.is_ascii_whitespace(), content="true")
+  inspect('\n'.is_whitespace(), content="true")
 
   // Control characters
-  inspect(@char.is_ascii_control('\u0000'), content="true")
-  inspect(@char.is_control('\u007F'), content="true")
+  inspect('\u0000'.is_ascii_control(), content="true")
+  inspect('\u007F'.is_control(), content="true")
 
   // Graphic and punctuation characters
-  inspect(@char.is_ascii_graphic('!'), content="true")
-  inspect(@char.is_ascii_graphic(' '), content="false")
-  inspect(@char.is_ascii_punctuation(','), content="true")
+  inspect('!'.is_ascii_graphic(), content="true")
+  inspect(' '.is_ascii_graphic(), content="false")
+  inspect(','.is_ascii_punctuation(), content="true")
 }
 ```
 

deque/deque.mbt

@@ -352,7 +352,7 @@ pub fn[A] unsafe_pop_front(self : T[A]) -> Unit {
 #deprecated("Use `unsafe_pop_front` instead")
 #coverage.skip
 pub fn[A] pop_front_exn(self : T[A]) -> Unit {
-  unsafe_pop_front(self)
+  self.unsafe_pop_front()
 }
 
 ///|
@@ -409,7 +409,7 @@ pub fn[A] unsafe_pop_back(self : T[A]) -> Unit {
 #deprecated("Use `unsafe_pop_back` instead")
 #coverage.skip
 pub fn[A] pop_back_exn(self : T[A]) -> Unit {
-  unsafe_pop_back(self)
+  self.unsafe_pop_back()
 }
 
 ///|

deque/deque_test.mbt

@@ -693,7 +693,7 @@ test "test_clone_from" {
         for _idx in 0..<pfu {
           u.push_front(2)
         }
-        let v = @deque.copy(u)
+        let v = u.copy()
         assert_eq!(v, u)
       }
     }