Revert "migrate view"

This reverts commit 8421d62.

Author: bobzhang

array/array.mbti

@@ -1,6 +1,5 @@
 package moonbitlang/core/array
 
-alias @moonbitlang/core/bytes as @bytes
 alias @moonbitlang/core/quickcheck as @quickcheck
 
 // Values
@@ -9,7 +8,6 @@ alias @moonbitlang/core/quickcheck as @quickcheck
 impl FixedArray {
   all[T](Self[T], (T) -> Bool) -> Bool
   any[T](Self[T], (T) -> Bool) -> Bool
-  blit_from_bytesview(Self[Byte], Int, @bytes.BytesView) -> Unit
   contains[T : Eq](Self[T], T) -> Bool
   copy[T](Self[T]) -> Self[T]
   each[T](Self[T], (T) -> Unit) -> Unit
@@ -70,24 +68,10 @@ impl ArrayView {
   contains[T : Eq](Self[T], T) -> Bool
   each[T](Self[T], (T) -> Unit) -> Unit
   eachi[T](Self[T], (Int, T) -> Unit) -> Unit
-  filter[T](Self[T], (T) -> Bool) -> Array[T]
-  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]
-  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]
-  mapi_inplace[T](Self[T], (Int, T) -> T) -> Unit
-  rev_fold[A, B](Self[A], init~ : B, (B, A) -> B) -> B
-  rev_foldi[A, B](Self[A], init~ : B, (Int, B, A) -> B) -> B
   rev_inplace[T](Self[T]) -> Unit
 }
-impl[T : Compare] Compare for ArrayView[T]
-impl[T : Eq] Eq for ArrayView[T]
-impl[X : Show] Show for ArrayView[X]
 
 // Type aliases
-pub typealias View[T] = ArrayView[T]
 
 // Traits
 

array/blit.mbt

@@ -56,36 +56,3 @@ test "copy" {
   a.blit_to(a, len=2, src_offset=1)
   inspect!(a, content="[2, 3, 3, 4]")
 }
-
-///|
-/// Copy bytes from a @bytes.View into a fixed array of bytes.
-///
-/// Parameters:
-///
-/// * `self` : The destination fixed array of bytes.
-/// * `bytes_offset` : The starting position in the destination array where bytes will be copied.
-/// * `src` : The source View to copy from.
-///
-/// Throws a panic if:
-/// * `bytes_offset` is negative
-/// * The destination array is too small to hold all bytes from the source View
-///
-/// Example:
-///
-/// ```moonbit
-///  let arr = FixedArray::make(4, b'\x00')
-///  let view = b"\x01\x02\x03"[1:]
-///  arr.blit_from_bytesview(1, view)
-///  inspect!(arr, content="[b'\\x00', b'\\x02', b'\\x03', b'\\x00']")
-/// ```
-pub fn FixedArray::blit_from_bytesview(
-  self : FixedArray[Byte],
-  bytes_offset : Int,
-  src : @bytes.View
-) -> Unit {
-  let src_len = src.length()
-  guard bytes_offset >= 0 && bytes_offset + src_len - 1 < self.length()
-  for i = 0, j = bytes_offset; i < src_len; i = i + 1, j = j + 1 {
-    self[j] = src[i]
-  }
-}

array/moon.pkg.json

@@ -1,12 +1,12 @@
 {
   "import": [
     "moonbitlang/core/builtin",
-    "moonbitlang/core/bytes",
+
     "moonbitlang/core/test",
     "moonbitlang/core/quickcheck",
     "moonbitlang/core/quickcheck/splitmix"
   ],
-  "test-import": ["moonbitlang/core/random", "moonbitlang/core/json"],
+  "test-import": ["moonbitlang/core/random"],
   "targets": {
     "array_js.mbt": ["js"],
     "array_nonjs.mbt": ["not", "js"],

array/view.mbt

@@ -12,20 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-///|
-///
-/// A `@array.View` represents a view into a section of an array without copying the data.
-///
-/// # Example
-///
-/// ```moonbit
-/// let arr = [1, 2, 3, 4, 5]
-/// let view = arr[1:4]  // Creates a view of elements at indices 1,2,3
-/// assert_eq!(view[0], 2)
-/// assert_eq!(view.length(), 3)
-/// ```
-pub typealias View[T] = ArrayView[T]
-
 ///|
 /// Reverses the elements in the array view in place.
 ///
@@ -42,7 +28,7 @@ pub typealias View[T] = ArrayView[T]
 ///   inspect!(arr, content="[5, 4, 3, 2, 1]")
 /// }
 /// ```
-pub fn View::rev_inplace[T](self : View[T]) -> Unit {
+pub fn ArrayView::rev_inplace[T](self : ArrayView[T]) -> Unit {
   let mid_len = self.length() / 2
   for i = 0; i < mid_len; i = i + 1 {
     let j = self.length() - i - 1
@@ -69,7 +55,7 @@ pub fn View::rev_inplace[T](self : View[T]) -> Unit {
 ///   inspect!(sum, content="6")
 /// }
 /// ```
-pub fn View::each[T](self : View[T], f : (T) -> Unit) -> Unit {
+pub fn ArrayView::each[T](self : ArrayView[T], f : (T) -> Unit) -> Unit {
   for v in self {
     f(v)
   }
@@ -86,7 +72,7 @@ pub fn View::each[T](self : View[T], f : (T) -> Unit) -> Unit {
 /// v.eachi(fn (i, x) { sum = sum + x + i })
 /// assert_eq!(sum, 15)
 /// ```
-pub fn View::eachi[T](self : View[T], f : (Int, T) -> Unit) -> Unit {
+pub fn ArrayView::eachi[T](self : ArrayView[T], f : (Int, T) -> Unit) -> Unit {
   for i, v in self {
     f(i, v)
   }
@@ -102,7 +88,7 @@ pub fn View::eachi[T](self : View[T], f : (Int, T) -> Unit) -> Unit {
 /// assert_false!(v[:].all(fn(elem) { elem % 2 == 0 }))
 /// assert_true!(v[1:4].all(fn(elem) { elem % 2 == 0 }))
 /// ```
-pub fn View::all[T](self : View[T], f : (T) -> Bool) -> Bool {
+pub fn ArrayView::all[T](self : ArrayView[T], f : (T) -> Bool) -> Bool {
   for v in self {
     if not(f(v)) {
       return false
@@ -121,7 +107,7 @@ pub fn View::all[T](self : View[T], f : (T) -> Bool) -> Bool {
 /// assert_true!(v.any(fn(ele) { ele < 6 }))
 /// assert_false!(v.any(fn(ele) { ele < 1 }))
 /// ```
-pub fn View::any[T](self : View[T], f : (T) -> Bool) -> Bool {
+pub fn ArrayView::any[T](self : ArrayView[T], f : (T) -> Bool) -> Bool {
   for v in self {
     if f(v) {
       return true
@@ -151,7 +137,7 @@ pub fn View::any[T](self : View[T], f : (T) -> Bool) -> Bool {
 ///   inspect!(arr.contains(6), content="false")
 /// }
 /// ```
-pub fn View::contains[T : Eq](self : View[T], value : T) -> Bool {
+pub fn ArrayView::contains[T : Eq](self : ArrayView[T], value : T) -> Bool {
   for v in self {
     if v == value {
       break true
@@ -160,224 +146,3 @@ pub fn View::contains[T : Eq](self : View[T], value : T) -> Bool {
     false
   }
 }
-
-///|
-/// Returns an iterator that yields each element of the array view in sequence
-/// from start to end.
-///
-/// Parameters:
-///
-/// * `array_view` : The array view to iterate over.
-///
-/// Returns an iterator that yields elements of type `A` from the array view.
-///
-/// Example:
-///
-/// ```moonbit
-/// test "View::iter" {
-///   let arr = [1, 2, 3]
-///   let view = arr[1:]
-///   let mut sum = 0
-///   view.iter().each(fn(x) { sum = sum + x })
-///   inspect!(sum, content="5")
-/// }
-/// ```
-pub fn View::iter[A](self : View[A]) -> Iter[A] {
-  Iter::new(fn(yield_) {
-    for v in self {
-      guard let IterContinue = yield_(v) else { x => break x }
-
-    } else {
-      IterContinue
-    }
-  })
-}
-
-///|
-/// Fold out values from an View according to certain rules.
-///
-/// # Example
-/// ```
-/// let sum = [1, 2, 3, 4, 5][:].fold(init=0, fn { sum, elem => sum + elem })
-/// assert_eq!(sum, 15)
-/// ```
-pub fn View::fold[A, B](self : View[A], init~ : B, f : (B, A) -> B) -> B {
-  for i = 0, acc = init; i < self.length(); {
-    continue i + 1, f(acc, self[i])
-  } else {
-    acc
-  }
-}
-
-///|
-/// Fold out values from an View according to certain rules in reversed turn.
-///
-/// # Example
-/// ```
-/// let sum = [1, 2, 3, 4, 5][:].rev_fold(init=0, fn { sum, elem => sum + elem })
-/// assert_eq!(sum, 15)
-/// ```
-pub fn View::rev_fold[A, B](self : View[A], init~ : B, f : (B, A) -> B) -> B {
-  for i = self.length() - 1, acc = init; i >= 0; {
-    continue i - 1, f(acc, self[i])
-  } else {
-    acc
-  }
-}
-
-///|
-/// Fold out values from an View according to certain rules with index.
-///
-/// # Example
-/// ```
-/// let sum = [1, 2, 3, 4, 5][:].foldi(init=0, fn { index, sum, _elem => sum + index })
-/// assert_eq!(sum, 10)
-/// ```
-pub fn View::foldi[A, B](self : View[A], init~ : B, f : (Int, B, A) -> B) -> B {
-  for i = 0, acc = init; i < self.length(); {
-    continue i + 1, f(i, acc, self[i])
-  } else {
-    acc
-  }
-}
-
-///|
-/// Fold out values from an View according to certain rules in reversed turn with index.
-///
-/// # Example
-/// ```
-/// let sum = [1, 2, 3, 4, 5][:].rev_foldi(init=0, fn { index, sum, _elem => sum + index })
-/// assert_eq!(sum, 10)
-/// ```
-pub fn View::rev_foldi[A, B](
-  self : View[A],
-  init~ : B,
-  f : (Int, B, A) -> B
-) -> B {
-  let len = self.length()
-  for i = len - 1, acc = init; i >= 0; {
-    continue i - 1, f(len - i - 1, acc, self[i])
-  } else {
-    acc
-  }
-}
-
-///|
-/// Maps a function over the elements of the array view.
-///
-/// # Example
-/// ```
-/// let v = [3, 4, 5]
-/// let v2 = v[1:].map(fn (x) {x + 1})
-/// assert_eq!(v2, [5, 6])
-/// ```
-pub fn View::map[T, U](self : View[T], f : (T) -> U) -> Array[U] {
-  if self.length() == 0 {
-    return []
-  }
-  Array::makei(self.length(), fn(i) { f(self[i]) })
-}
-
-///|
-/// Maps a function over the elements of the array view in place.
-///
-/// # Example
-/// ```
-/// let v = [3, 4, 5]
-/// v[1:].map_inplace(fn (x) {x + 1})
-/// assert_eq!(v, [3, 5, 6])
-/// ```
-pub fn View::map_inplace[T](self : View[T], f : (T) -> T) -> Unit {
-  for i, v in self {
-    self[i] = f(v)
-  }
-}
-
-///|
-/// Maps a function over the elements of the array view with index.
-///
-/// # Example
-/// ```
-/// let v = [3, 4, 5]
-/// let v2 = v[1:].mapi(fn (i, x) {x + i})
-/// assert_eq!(v2, [4, 6])
-/// ```
-pub fn View::mapi[T, U](self : View[T], f : (Int, T) -> U) -> Array[U] {
-  if self.length() == 0 {
-    return []
-  }
-  Array::makei(self.length(), fn(i) { f(i, self[i]) })
-}
-
-///|
-/// Maps a function over the elements of the array view with index in place.
-///
-/// # Example
-/// ```
-/// let v = [3, 4, 5]
-/// v[1:].mapi_inplace(fn (i, x) {x + i})
-/// assert_eq!(v, [3, 4, 6])
-/// ```
-pub fn View::mapi_inplace[T](self : View[T], f : (Int, T) -> T) -> Unit {
-  for i, v in self {
-    self[i] = f(i, v)
-  }
-}
-
-///|
-/// Filters the array view with a predicate function.
-///
-/// # Example
-/// ```
-/// let arr = [1, 2, 3, 4, 5, 6]
-/// let v = arr[2:].filter(fn (x) { x % 2 == 0 })
-/// assert_eq!(v, [4, 6])
-/// ```
-pub fn View::filter[T](self : View[T], f : (T) -> Bool) -> Array[T] {
-  let arr = []
-  for v in self {
-    if f(v) {
-      arr.push(v)
-    }
-  }
-  arr
-}
-
-///|
-pub impl[X : Show] Show for View[X] with output(self, logger) {
-  logger.write_iter(self.iter())
-}
-
-///|
-pub impl[T : Eq] Eq for View[T] with op_equal(self, other) -> Bool {
-  if self.length() != other.length() {
-    return false
-  }
-  for i in 0..<self.length() {
-    if not(self[i] == other[i]) {
-      return false
-    }
-  } else {
-    true
-  }
-}
-
-///|
-pub impl[T : Compare] Compare for View[T] with compare(self, other) -> Int {
-  let len_self = self.length()
-  let len_other = other.length()
-  if len_self < len_other {
-    -1
-  } else if len_self > len_other {
-    1
-  } else {
-    for i in 0..<len_self {
-      let cmp = self[i].compare(other[i])
-      if cmp != 0 {
-        break cmp
-      }
-    } else {
-      0
-    }
-  }
-}