Merge branch 'main' into iter-map-option

.github/workflows/check.yml

@@ -199,7 +199,10 @@ jobs:
 
   bleeding-check:
     continue-on-error: true
-    runs-on: macos-latest
+    strategy:
+      matrix:
+        os: [macos-latest, ubuntu-latest]
+    runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4
 
@@ -226,7 +229,7 @@ jobs:
         run: |
           ulimit -s 8176
           moon test --target native
-          moon test --release --target native
+          moon test --target native --release
 
       - name: moon bundle
         run: moon bundle --all

buffer/buffer.mbt

@@ -80,7 +80,7 @@ pub fn write_bytes(self : Buffer, value : Bytes) -> Unit {
 }
 
 /// Write a sub-string into buffer.
-pub fn write_sub_string(
+pub fn write_substring(
   self : Buffer,
   value : String,
   start : Int,
@@ -92,6 +92,17 @@ pub fn write_sub_string(
   self.len += len * 2
 }
 
+/// Write a sub-string into buffer.
+/// @alert deprecated "Use `Buffer::write_substring` instead"
+pub fn write_sub_string(
+  self : Buffer,
+  value : String,
+  start : Int,
+  len : Int
+) -> Unit {
+  self.write_substring(value, start, len)
+}
+
 /// Write a char into buffer.
 pub fn write_char(self : Buffer, value : Char) -> Unit {
   self.grow_if_necessary(self.len + 4)

buffer/buffer.mbti

@@ -14,7 +14,8 @@ impl Buffer {
   write_char(Self, Char) -> Unit
   write_object(Self, Show) -> Unit
   write_string(Self, String) -> Unit
-  write_sub_string(Self, String, Int, Int) -> Unit
+  write_sub_string(Self, String, Int, Int) -> Unit //deprecated
+  write_substring(Self, String, Int, Int) -> Unit
 }
 
 // Type aliases

buffer/buffer_test.mbt

@@ -32,9 +32,9 @@ test "grow_if_necessary method" {
   assert_true!(buf.to_bytes().length() >= 60)
 }
 
-test "write_sub_string method" {
+test "write_substring method" {
   let buf = @buffer.new(size_hint=10)
-  buf.write_sub_string("Hello, World!", 7, 5)
+  buf.write_substring("Hello, World!", 7, 5)
   inspect!(buf, content="World")
 }
 
@@ -66,9 +66,9 @@ test "grow_if_necessary method" {
   assert_true!(buf.to_bytes().length() >= 60)
 }
 
-test "write_sub_string method" {
+test "write_substring method" {
   let buf = @buffer.new(size_hint=10)
-  buf.write_sub_string("Hello, World!", 7, 5)
+  buf.write_substring("Hello, World!", 7, 5)
   inspect!(buf, content="World")
 }
 
@@ -106,9 +106,9 @@ test "grow_if_necessary method" {
   assert_true!(buf.to_bytes().length() >= 60)
 }
 
-test "write_sub_string method" {
+test "write_substring method" {
   let buf = @buffer.new(size_hint=10)
-  buf.write_sub_string("Hello, World!", 7, 5)
+  buf.write_substring("Hello, World!", 7, 5)
   inspect!(buf, content="World")
 }
 

builtin/array.mbt

@@ -982,3 +982,7 @@ pub fn iter2[A](self : Array[A]) -> Iter2[Int, A] {
     },
   )
 }
+
+pub fn Array::default[T]() -> Array[T] {
+  []
+}

builtin/array_test.mbt

@@ -566,3 +566,11 @@ test "array_dedup - edge cases" {
   array.dedup()
   inspect!(array, content="[1, 2, 3, 4, 5]")
 }
+
+struct MX {
+  mm_num : Array[Int]
+} derive(Default, ToJson)
+
+test {
+  @json.inspect!(MX::default(), content={ "mm_num": [] })
+}

builtin/buffer.mbt

@@ -81,7 +81,7 @@ pub fn write_bytes(self : Buffer, value : Bytes) -> Unit {
 }
 
 /// Write a sub-string into buffer.
-pub fn write_sub_string(
+pub fn write_substring(
   self : Buffer,
   value : String,
   start : Int,
@@ -93,6 +93,17 @@ pub fn write_sub_string(
   self.len += len * 2
 }
 
+/// Write a sub-string into buffer.
+/// @alert deprecated "Use `Buffer::write_substring` instead"
+pub fn write_sub_string(
+  self : Buffer,
+  value : String,
+  start : Int,
+  len : Int
+) -> Unit {
+  self.write_substring(value, start, len)
+}
+
 /// Write a char into buffer.
 pub fn write_char(self : Buffer, value : Char) -> Unit {
   self.grow_if_necessary(self.len + 4)

builtin/builtin.mbti

@@ -55,6 +55,7 @@ impl Array {
   compare[T : Compare + Eq](Self[T], Self[T]) -> Int
   contains[T : Eq](Self[T], T) -> Bool
   dedup[T : Eq](Self[T]) -> Unit
+  default[T]() -> Self[T]
   drain[T](Self[T], Int, Int) -> Self[T]
   each[T](Self[T], (T) -> Unit) -> Unit
   eachi[T](Self[T], (Int, T) -> Unit) -> Unit
@@ -175,7 +176,8 @@ impl Buffer {
   write_char(Self, Char) -> Unit
   write_object(Self, Show) -> Unit
   write_string(Self, String) -> Unit
-  write_sub_string(Self, String, Int, Int) -> Unit
+  write_sub_string(Self, String, Int, Int) -> Unit //deprecated
+  write_substring(Self, String, Int, Int) -> Unit
 }
 
 pub type! Failure String
@@ -351,7 +353,7 @@ impl StringBuilder {
   write_char(Self, Char) -> Unit
   write_object[T : Show](Self, T) -> Unit
   write_string(Self, String) -> Unit
-  write_sub_string(Self, String, Int, Int) -> Unit
+  write_substring(Self, String, Int, Int) -> Unit
 }
 
 pub type UnsafeMaybeUninit
@@ -494,6 +496,7 @@ impl UInt {
   op_shr(UInt, Int) -> UInt
   op_sub(UInt, UInt) -> UInt
   popcnt(UInt) -> Int
+  reinterpret_as_float(UInt) -> Float
   reinterpret_as_int(UInt) -> Int
   shl(UInt, Int) -> UInt //deprecated
   shr(UInt, Int) -> UInt //deprecated
@@ -723,6 +726,7 @@ pub trait Hash {
 
 pub trait Logger {
   write_string(Self, String) -> Unit
+  write_substring(Self, String, Int, Int) -> Unit
   write_sub_string(Self, String, Int, Int) -> Unit
   write_char(Self, Char) -> Unit
 }
@@ -765,6 +769,8 @@ impl Hash for Tuple(6)
 
 impl Hash for Tuple(7)
 
+impl Logger::write_sub_string
+
 impl Show for Unit
 
 impl Show for Bool

builtin/intrinsics.mbt

@@ -307,6 +307,8 @@ pub fn Int::to_float(self : Int) -> Float = "%i32.to_f32"
 
 pub fn Int::reinterpret_as_float(self : Int) -> Float = "%i32.to_f32_reinterpret"
 
+pub fn UInt::reinterpret_as_float(self : UInt) -> Float = "%i32.to_f32_reinterpret"
+
 pub fn Byte::to_float(self : Byte) -> Float = "%byte.to_f32"
 
 pub fn Double::to_float(self : Double) -> Float = "%f64.to_f32"

builtin/intrinsics_test.mbt

@@ -412,3 +412,24 @@ test "Int::to_uint64 - Random Values" {
   inspect!(Int::to_uint64(1234567890), content="1234567890")
   inspect!(Int::to_uint64(-1234567890), content="18446744072474983726")
 }
+
+test "UInt::reinterpret_as_float roundtrip" {
+  let values = [
+    0x00000000U, // zero
+     0x80000000U, // negative zero
+     0x3F800000U, // 1.0
+     0xBF800000U, // -1.0
+     0x7F800000U, // positive infinity
+     0xFF800000U, // negative infinity
+     0x7FC00000U, // NaN
+     0x00800000U, // smallest positive normal float
+     0x7F7FFFFFU, // largest positive normal float
+     0x00000001U, // smallest positive subnormal float
+     0x007FFFFFU, // largest positive subnormal float
+  ]
+  for value in values {
+    let float_value = value.reinterpret_as_float()
+    let roundtrip_value = Float::reinterpret_as_uint(float_value)
+    assert_eq!(roundtrip_value, value)
+  }
+}

builtin/show.mbt

@@ -70,7 +70,7 @@ pub impl Show for String with output(self, logger) {
   let mut segment_start = 0
   fn flush_segment(i : Int) {
     if i > segment_start {
-      logger.write_sub_string(self, segment_start, i - segment_start)
+      logger.write_substring(self, segment_start, i - segment_start)
     }
     segment_start = i + 1
   }

builtin/string.mbt

@@ -26,19 +26,6 @@ pub fn substring(
   ~start : Int = 0,
   ~end : Int = self.length()
 ) -> String {
-  if start < 0 {
-    abort("String::substring: start index is negative")
-  }
-  if end < 0 {
-    abort("String::substring: end index is negative")
-  }
-  if start > end {
-    abort("String::substring: start index is greater than end index")
-  }
-  if end > self.length() {
-    abort(
-      "String::substring: end index is greater than the length of the string",
-    )
-  }
+  guard start >= 0 && start <= end && end <= self.length()
   unsafe_substring(self, start, end)
 }

builtin/stringbuilder_buffer.mbt

@@ -53,7 +53,7 @@ pub fn StringBuilder::write_char(self : StringBuilder, ch : Char) -> Unit {
   self.len += inc
 }
 
-pub fn StringBuilder::write_sub_string(
+pub fn StringBuilder::write_substring(
   self : StringBuilder,
   str : String,
   start : Int,

builtin/stringbuilder_concat.mbt

@@ -27,7 +27,7 @@ pub fn StringBuilder::write_char(self : StringBuilder, ch : Char) -> Unit {
   self.val += Char::to_string(ch)
 }
 
-pub fn StringBuilder::write_sub_string(
+pub fn StringBuilder::write_substring(
   self : StringBuilder,
   str : String,
   start : Int,

builtin/stringbuilder_test.mbt

@@ -12,10 +12,24 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// when we write the string into the buffer
+// we assume the string is utf16 and blit
+// we assume the bytes (in valid region [0, len)) is utf16
+// so that 
+fn id(s : String) -> String {
+  StringBuilder::new()..write_string(s).to_string()
+}
+
 test "stringbuilder" {
   let buf = StringBuilder::new()
   buf.write_string("hello")
   buf.write_char(' ')
-  buf.write_sub_string("world", 0, 3)
+  buf.write_substring("world", 0, 3)
   inspect!(buf.to_string(), content="hello wor")
 }
+
+test {
+  let data = ["a", "b", "c", "hello world"]
+  @json.inspect!(data.map(id), content=["a", "b", "c", "hello world"])
+  // assert_eq!(StringBuilder::new()..write_string("hello").to_string(), "hello")
+}

builtin/traits.mbt

@@ -47,10 +47,16 @@ pub trait Default {
 /// Trait for a logger, where debug logs can be written into
 pub trait Logger {
   write_string(Self, String) -> Unit
+  write_substring(Self, String, Int, Int) -> Unit
+  /// @alert deprecated "use `Logger::write_substring` instead"
   write_sub_string(Self, String, Int, Int) -> Unit
   write_char(Self, Char) -> Unit
 }
 
+impl Logger with write_sub_string(self, value, start, len) {
+  self.write_substring(value, start, len)
+}
+
 /// Trait for types that can be converted to `String`
 pub trait Show {
   // `output` is used for composition of aggregate structure.

bytes/bytes.mbt

@@ -39,7 +39,7 @@ pub fn Bytes::from_iter(iter : Iter[Byte]) -> Bytes {
 /// ```moonbit
 /// let b = @bytes.of([b'\x41', b'\x00', b'\x42'])
 /// ```
-/// 
+/// TODO: marked as intrinsic, inline if it is constant
 pub fn Bytes::of(arr : FixedArray[Byte]) -> Bytes {
   let rv = Bytes::new(arr.length())
   for i = 0; i < arr.length(); i = i + 1 {

bytes/bytes_test.mbt

@@ -37,6 +37,29 @@ test "from_array" {
   )
 }
 
+test "from_array literal" {
+  let b = @bytes.of([65, 0, 66, 0, 67, 0])
+  inspect!(
+    b,
+    content=
+      #|b"\x41\x00\x42\x00\x43\x00"
+    ,
+  )
+}
+
+test "from array literal" {
+  let b1 = @bytes.of(
+    [
+      b'\x41', b'\x00', b'\x42', b'\x00', b'\x43', b'\x00', b'\x44', b'\x00', b'\x45',
+      b'\x00', b'\x46', b'\x00', b'\x47', b'\x00', b'\x48', b'\x00', b'\x49', b'\x00',
+    ],
+  )
+  let b2 = @bytes.of(
+    [65, 0, 66, 0, 67, 0, 68, 0, 69, 0, 70, 0, 71, 0, 72, 0, 73, 0],
+  )
+  assert_eq!(b1, b2)
+}
+
 test "hash" {
   let b1 = @bytes.of(
     [

char/moon.pkg.json

@@ -1,7 +1,6 @@
 {
     "import": [
         "moonbitlang/core/builtin",
-        "moonbitlang/core/test",
         "moonbitlang/core/coverage"
     ]
 }

coverage/coverage.mbt

@@ -102,14 +102,14 @@ pub fn end() -> Unit {
     let mut start = 0
     for j = 0; j < str.length(); j = j + 1 {
       if str[j] == '\n' {
-        line_buf.write_sub_string(str, start, j)
+        line_buf.write_substring(str, start, j)
         println(line_buf.to_string())
         line_buf.reset()
         start = j + 1
       }
     }
     if start < str.length() {
-      line_buf.write_sub_string(str, start, str.length())
+      line_buf.write_substring(str, start, str.length())
     }
   }
   let trailing_line = line_buf.to_string()

deque/moon.pkg.json

@@ -1,9 +1,7 @@
 {
   "import": [
     "moonbitlang/core/builtin",
-    "moonbitlang/core/test",
-    "moonbitlang/core/coverage",
-    "moonbitlang/core/array"
+    "moonbitlang/core/coverage"
   ],
   "targets": {
     "panic_test.mbt": ["not", "native"]