moonbitlang · peter-jerry-ye · Jun 26, 2025 · May 31, 2025 · May 31, 2025 · May 31, 2025
diff --git a/builtin/array.mbt b/builtin/array.mbt
@@ -1759,3 +1759,35 @@ pub impl[T] Default for Array[T] with default() {
 pub fn[A] Array::unsafe_pop_back(self : Array[A]) -> Unit {
   self.unsafe_pop() |> ignore
 }
+
+///|
+/// Truncates the array in-place to the specified length.
+///
+/// If `len` is greater than or equal to the current array length, 
+/// the function does nothing. If `len` is 0, the array is cleared.
+/// Otherwise, removes elements from the end until the array reaches the given length.
+///
+/// Parameters:
+///
+/// * `self` : The target array (modified in-place).
+/// * `len` : The new desired length (must be non-negative).
+///
+/// Important: 
+///   - If `len` is negative, the function does nothing.
+///   - If `len` exceeds current length, the array remains unchanged.
+///
+/// Example:
+///
+/// ```moonbit
+/// let arr = [1, 2, 3, 4, 5]
+/// arr.truncate(3)
+/// inspect(arr, content="[1, 2, 3]")
+/// ```
+pub fn[A] Array::truncate(self : Array[A], len : Int) -> Unit {
+  guard len >= 0 && len < self.length() else { return }
+  if len == 0 {
+    self.clear()
+    return
+  }
+  self.unsafe_truncate_to_length(len)
+}
diff --git a/builtin/builtin.mbti b/builtin/builtin.mbti
@@ -118,6 +118,7 @@ fn[T : Eq] Array::starts_with(Self[T], Self[T]) -> Bool
 fn[T : Eq] Array::strip_prefix(Self[T], Self[T]) -> Self[T]?
 fn[T : Eq] Array::strip_suffix(Self[T], Self[T]) -> Self[T]?
 fn[T] Array::swap(Self[T], Int, Int) -> Unit
+fn[A] Array::truncate(Self[A], Int) -> Unit
 fn[A] Array::unsafe_blit(Self[A], Int, Self[A], Int, Int) -> Unit
 fn[A] Array::unsafe_blit_fixed(Self[A], Int, FixedArray[A], Int, Int) -> Unit
 fn[T] Array::unsafe_get(Self[T], Int) -> T
@@ -302,6 +303,7 @@ impl Logger for StringBuilder
 impl Show for StringBuilder
 
 type UninitializedArray[T]
+fn[A] UninitializedArray::blit(Self[A], Self[A], len~ : Int, src_offset~ : Int = .., dst_offset~ : Int = ..) -> Self[A]
 fn[A] UninitializedArray::length(Self[A]) -> Int
 fn[T] UninitializedArray::make(Int) -> Self[T]
 fn[T] UninitializedArray::op_as_view(Self[T], start~ : Int = .., end? : Int) -> ArrayView[T]

diff --git a/builtin/uninitialized_array.mbt b/builtin/uninitialized_array.mbt
@@ -108,6 +108,53 @@ fn[T] UninitializedArray::unsafe_blit(
   FixedArray::unsafe_blit(dst.inner(), dst_offset, src.inner(), src_offset, len)
 }
 
+///|
+/// Copies a range of elements from one `UninitializedArray` to another, ensuring the destination array has enough space.
+///
+/// If the destination array is not large enough to hold the copied elements at the specified offset, a new larger array is created and returned.
+///
+/// Parameters:
+///
+/// * `self` : The source array (not modified).
+/// * `dst` : The destination array. May be modified in-place or replaced by a new array.
+/// * `len` : Number of elements to copy.
+/// * `src_offset` : Start index in the source array (default: 0).
+/// * `dst_offset` : Start index in the destination array (default: 0).
+///
+/// Returns:
+///   A new array if reallocation was necessary, otherwise the original `dst`.
+///
+/// Important:
+///   - Requires: `len >= 0`
+///   - Requires: `src_offset >= 0`
+///   - Requires: `dst_offset >= 0`
+///   - Requires: `src_offset + len <= self.length()`
+///   - Ensures: `dst_offset + len <= dst.length()` after call (either by expanding `dst` or using a new array)
+///   - Does not initialize or drop values; assumes caller handles memory safety.
+///
+pub fn[A] UninitializedArray::blit(
+  self : UninitializedArray[A],
+  dst : UninitializedArray[A],
+  len~ : Int,
+  src_offset~ : Int = 0,
+  dst_offset~ : Int = 0
+) -> UninitializedArray[A] {
+  guard len >= 0 &&
+    dst_offset >= 0 &&
+    src_offset >= 0 &&
+    dst_offset <= dst.length() &&
+    src_offset + len <= self.length()
+  if dst_offset + len > dst.length() {
+    let new_dst = UninitializedArray::make(dst_offset + len)
+    UninitializedArray::unsafe_blit(new_dst, 0, dst, 0, dst.length())
+    UninitializedArray::unsafe_blit(new_dst, dst_offset, self, src_offset, len)
+    new_dst
+  } else {
+    UninitializedArray::unsafe_blit(dst, dst_offset, self, src_offset, len)
+    dst
+  }
+}
+
 ///|
 test "op_as_view with valid_range" {
   let arr : UninitializedArray[Int] = UninitializedArray::make(5)

diff --git a/deque/deque.mbt b/deque/deque.mbt
@@ -1222,18 +1222,122 @@ pub fn[A] to_array(self : T[A]) -> Array[A] {
 }
 
 ///|
-/// Converts a deque to its JSON representation as an array.
+/// Joins the elements of a string deque into a single string, 
+/// separated by the specified separator.
 ///
 /// Parameters:
 ///
-/// * `self` : The deque to be converted to JSON.
+/// * `self` : The deque of strings to join.
+/// * `separator` : The separator to insert between elements (as a string view).
 ///
-/// Returns a JSON array containing all elements from the deque converted to
-/// their JSON representations.
+/// Returns the concatenated string. 
+///   - If the deque is empty, returns an empty string.
+///   - Efficiently pre-allocates memory based on calculated size hint.
+///   - Handles empty separators efficiently by direct concatenation.
+///
+/// Example:
+///
+/// ```moonbit
+///   let deque = @deque.of(["a","b","c"])
+///   let s1 = deque.join("")
+///   inspect(s1, content="abc")
+/// 
+///   let s2 = deque.join(",")
+///   inspect(s2, content="a,b,c")
+/// ```
+pub fn T::join(self : T[String], separator : @string.View) -> String {
+  let str = separator.to_string()
+  self.iter().join(str)
+}
+
+///|
+/// Removes and returns elements in the specified range [begin, end) from the deque.
+///
+/// Parameters:
+///
+/// * `self` : The target deque (modified in-place).
+/// * `begin` : Start index of the range (inclusive).
+/// * `end` : End index of the range (exclusive).
+///
+/// Important:
+///   - Requires `0 <= begin <= end <= self.length()`
+///   - Returns a new deque containing the drained elements.
+///   - Original deque retains elements outside [begin, end) in original order.
+///
+/// Example:
+///
+/// ```moonbit
+///   let deque = @deque.of([1,2,3,4,5,6,7,8,9])
+///   let deque_test = deque.drain(start=2, len=4)
+///   inspect(deque_test, content="@deque.of([3, 4, 5, 6])")
+///   inspect(deque, content="@deque.of([1, 2, 7, 8, 9])")
+/// ```
+pub fn[A] T::drain(self : T[A], start~ : Int, len~ : Int) -> T[A] {
+  let end = start + len
+  guard start >= 0 && end <= self.length()
+  let dq = new(capacity=len)
+  dq.buf = self.buf.blit(dq.buf, len~, src_offset=start, dst_offset=0)
+  ignore(
+    self.buf.blit(
+      self.buf,
+      len=self.length() - end,
+      src_offset=end,
+      dst_offset=start,
+    ),
+  )
+  self.tail = self.length() - end
+  self.len = self.length() - len
+  let deq1 = T::{ buf: dq.buf, len, head: 0, tail: len - 1 }
+  deq1
+}
+
+///|
+/// Flattens a high-dimensional deque into a lower-dimensional deque
+/// by concatenating all inner deques in order.
+///
+/// Parameters:
+///
+/// * `self` : The high-dimensional deque to flatten.
+///
+/// Returns a new lower-dimensional deque containing all elements 
+/// from inner deques in sequence.
+///
+/// Note:
+///   - Uses the first inner deque as base and appends subsequent deques.
+///   - Efficiently preserves element order across all inner deques.
 ///
 /// Example:
 ///
 /// ```moonbit
+///   let deque = @deque.of([@deque.of([1,2,3]),@deque.of([4,5,6]),@deque.of([7,8])])
+///   let deque_test = deque.flatten()
+///   inspect(deque_test, content="@deque.of([1, 2, 3, 4, 5, 6, 7, 8])")
+/// ```
+pub fn[A] T::flatten(self : T[T[A]]) -> T[A] {
+  let mut len = 0
+  for i in self {
+    len += i.length()
+  }
+  let dq = new(capacity=len)
+  let mut i = 0
+  for t in self {
+    dq.buf = t.buf.blit(dq.buf, len=t.length(), dst_offset=i, src_offset=0)
+    i += t.length()
+  }
+  let deq = T::{ buf: dq.buf, len, head: 0, tail: len - 1 }
+  deq
+}
+
+///|
+/// Converts a deque to its JSON representation as an array.
+///
+/// Parameters:
+///
+/// * `self` : The deque to be converted to JSON.
+///
+/// Returns a JSON array containing all elements from the deque converted to
+/// their JSON representations.
+/// test "T::to_json" {
 ///   let dq = @deque.of([1, 2, 3])
 ///   let json = dq.to_json()
 ///   inspect(json, content="Array([Number(1), Number(2), Number(3)])")

diff --git a/deque/deque.mbti b/deque/deque.mbti
@@ -2,6 +2,7 @@ package "moonbitlang/core/deque"
 
 import(
   "moonbitlang/core/json"
+  "moonbitlang/core/string"
 )
 
 // Values
@@ -21,14 +22,17 @@ fn[A] T::capacity(Self[A]) -> Int
 fn[A] T::clear(Self[A]) -> Unit
 fn[A : Eq] T::contains(Self[A], A) -> Bool
 fn[A] T::copy(Self[A]) -> Self[A]
+fn[A] T::drain(Self[A], start~ : Int, len~ : Int) -> Self[A]
 fn[A] T::each(Self[A], (A) -> Unit) -> Unit
 fn[A] T::eachi(Self[A], (Int, A) -> Unit) -> Unit
 #deprecated
 fn[A] T::filter_map_inplace(Self[A], (A) -> A?) -> Unit
+fn[A] T::flatten(Self[Self[A]]) -> Self[A]
 fn[A] T::front(Self[A]) -> A?
 fn[A] T::is_empty(Self[A]) -> Bool
 fn[A] T::iter(Self[A]) -> Iter[A]
 fn[A] T::iter2(Self[A]) -> Iter2[Int, A]
+fn T::join(Self[String], @string.StringView) -> String
 fn[A] T::length(Self[A]) -> Int
 fn[A, U] T::map(Self[A], (A) -> U) -> Self[U]
 fn[A, U] T::mapi(Self[A], (Int, A) -> U) -> Self[U]

diff --git a/deque/moon.pkg.json b/deque/moon.pkg.json
@@ -2,7 +2,8 @@
   "import": [
     "moonbitlang/core/builtin",
     "moonbitlang/core/json",
-    "moonbitlang/core/array"
+    "moonbitlang/core/array",
+    "moonbitlang/core/string"
   ],
   "targets": {
     "panic_test.mbt": ["not", "native", "llvm"]