Move extension methods to IArray class

Author: Antoine Brunner

library/src-bootstrapped/scala/IArray.scala

@@ -223,4 +223,165 @@ object IArray {
    *  @return  sequence wrapped in a [[scala.Some]], if `x` is a Seq, otherwise `None`
    */
    def unapplySeq[T](x: IArray[T]) = Array.unapplySeq[T](x.asInstanceOf[Array[T]])
+
+
+
+  /** All the methods on Array[T] that don't mutate in-place can be used with IArray[T].
+   */
+  given arrayOps: [T](arr: IArray[T]) {
+    def ++[U >: T: ClassTag](that: IArray[U]): IArray[U] =
+      (arr.asInstanceOf[Array[T]] ++ that.asInstanceOf[Array[U]]).asInstanceOf
+
+    def contains(elem: T): Boolean =
+      arr.asInstanceOf[Array[T]].contains(elem)
+
+    def count(p: T => Boolean): Int =
+      arr.asInstanceOf[Array[T]].count(p)
+
+    def drop(n: Int): IArray[T] =
+      arr.asInstanceOf[Array[T]].drop(n).asInstanceOf
+
+    def dropRight(n: Int): IArray[T] =
+      arr.asInstanceOf[Array[T]].dropRight(n).asInstanceOf
+
+    def dropWhile(p: T => Boolean): IArray[T] =
+      arr.asInstanceOf[Array[T]].dropWhile(p).asInstanceOf
+
+    def exists(p: T => Boolean): IArray[T] =
+      arr.asInstanceOf[Array[T]].exists(p).asInstanceOf
+
+    def filter(p: T => Boolean): IArray[T] =
+      arr.asInstanceOf[Array[T]].filter(p).asInstanceOf
+
+    def filterNot(p: T => Boolean): IArray[T] =
+      arr.asInstanceOf[Array[T]].filterNot(p).asInstanceOf
+
+    def find(p: T => Boolean): Option[T] =
+      arr.asInstanceOf[Array[T]].find(p).asInstanceOf
+
+    def flatMap[U: ClassTag](f: T => IterableOnce[U]): IArray[U] =
+      arr.asInstanceOf[Array[T]].flatMap(f).asInstanceOf
+
+    def flatten[U: ClassTag](given T => Iterable[U]): IArray[U] =
+      arr.asInstanceOf[Array[T]].flatten.asInstanceOf
+
+    def fold[U >: T: ClassTag](z: U)(op: (U, U) => U): U =
+      arr.asInstanceOf[Array[T]].fold(z)(op).asInstanceOf
+
+    def foldLeft[U >: T: ClassTag](z: U)(op: (U, T) => U): U =
+      arr.asInstanceOf[Array[T]].foldLeft(z)(op).asInstanceOf
+
+    def foldRight[U >: T: ClassTag](z: U)(op: (T, U) => U): U =
+      arr.asInstanceOf[Array[T]].foldRight(z)(op).asInstanceOf
+
+    def forall(p: T => Boolean): Boolean =
+      arr.asInstanceOf[Array[T]].forall(p)
+
+    def foreach[U](f: T => U): Unit =
+      arr.asInstanceOf[Array[T]].foreach(f)
+
+    def head: T =
+      arr.asInstanceOf[Array[T]].head
+
+    def headOption: Option[T] =
+      arr.asInstanceOf[Array[T]].headOption
+
+    def indexOf(elem: T, from: Int = 0): Int =
+      arr.asInstanceOf[Array[T]].indexOf(elem, from)
+
+    def indexWhere(p: T => Boolean, from: Int = 0): Int =
+      arr.asInstanceOf[Array[T]].indexWhere(p, from)
+
+    def indices: Range =
+      arr.asInstanceOf[Array[T]].indices.asInstanceOf
+
+    def init: IArray[T] =
+      arr.asInstanceOf[Array[T]].init.asInstanceOf
+
+    def isEmpty: Boolean =
+      arr.asInstanceOf[Array[T]].isEmpty
+
+    def iterator: Iterator[T] =
+      arr.asInstanceOf[Array[T]].iterator
+
+    def last: T =
+      arr.asInstanceOf[Array[T]].last
+
+    def lastOption: Option[T] =
+      arr.asInstanceOf[Array[T]].lastOption
+
+    def lastIndexOf(elem: T, from: Int = 0): Int =
+      arr.asInstanceOf[Array[T]].lastIndexOf(elem, from)
+
+    def lastIndexWhere(p: T => Boolean, from: Int = 0): Int =
+      arr.asInstanceOf[Array[T]].lastIndexWhere(p, from)
+
+    def map[U: ClassTag](f: T => U): IArray[U] =
+      arr.asInstanceOf[Array[T]].map(f).asInstanceOf
+
+    def nonEmpty: Boolean =
+      arr.asInstanceOf[Array[T]].nonEmpty
+
+    def partition(p: T => Boolean): (IArray[T], IArray[T]) = arr.asInstanceOf[Array[T]].partition(p) match {
+      case (x, y) => (x.asInstanceOf[IArray[T]], y.asInstanceOf[IArray[T]])
+    }
+
+    def reverse: IArray[T] =
+      arr.asInstanceOf[Array[T]].reverse.asInstanceOf
+
+    def scan[U >: T: ClassTag](z: U)(op: (U, U) => U): Array[U] =
+      arr.asInstanceOf[Array[T]].scan(z)(op).asInstanceOf
+
+    def scanLeft[U: ClassTag](z: U)(op: (U, T) => U): Array[U] =
+      arr.asInstanceOf[Array[T]].scanLeft(z)(op).asInstanceOf
+
+    def scanRight[U: ClassTag](z: U)(op: (T, U) => U): Array[U] =
+      arr.asInstanceOf[Array[T]].scanRight(z)(op).asInstanceOf
+
+    def size: Int =
+      arr.asInstanceOf[Array[T]].size
+
+    def slice(from: Int, until: Int): Array[T] =
+      arr.asInstanceOf[Array[T]].slice(from, until).asInstanceOf
+
+    def sortBy[U: ClassTag](f: T => U)(given math.Ordering[U]): IArray[T] =
+      arr.asInstanceOf[Array[T]].sortBy(f).asInstanceOf
+
+    def sortWith(f: (T, T) => Boolean): IArray[T] =
+      arr.asInstanceOf[Array[T]].sortWith(f).asInstanceOf
+
+    def sorted(given math.Ordering[T]): IArray[T] =
+      arr.asInstanceOf[Array[T]].sorted.asInstanceOf
+
+    def span(p: T => Boolean): (IArray[T], IArray[T]) = arr.asInstanceOf[Array[T]].span(p) match {
+      case (x, y) => (x.asInstanceOf[IArray[T]], y.asInstanceOf[IArray[T]])
+    }
+
+    def splitAt(n: Int): (IArray[T], IArray[T]) = arr.asInstanceOf[Array[T]].splitAt(n) match {
+      case (x, y) => (x.asInstanceOf[IArray[T]], y.asInstanceOf[IArray[T]])
+    }
+
+    def startsWith[U >: T: ClassTag](that: IArray[U], offset: Int = 0): Boolean =
+      arr.asInstanceOf[Array[T]].startsWith(that.asInstanceOf[Array[U]])
+
+    def tail: IArray[T] =
+      arr.asInstanceOf[Array[T]].tail.asInstanceOf
+
+    def take(n: Int): IArray[T] =
+      arr.asInstanceOf[Array[T]].take(n).asInstanceOf
+
+    def takeRight(n: Int): IArray[T] =
+      arr.asInstanceOf[Array[T]].takeRight(n).asInstanceOf
+
+    def takeWhile(p: T => Boolean): IArray[T] =
+      arr.asInstanceOf[Array[T]].takeWhile(p).asInstanceOf
+
+    def unzip[U: ClassTag, V: ClassTag](given T => (U, V)): (IArray[U], IArray[V]) =
+      arr.asInstanceOf[Array[T]].unzip(asPair, ct1, ct2) match {
+        case (x, y) => (x.asInstanceOf[IArray[U]], y.asInstanceOf[IArray[V]])
+      }
+
+    def zip[U: ClassTag](that: IterableOnce[U]): IArray[(T, U)] =
+      arr.asInstanceOf[Array[T]].zip(that).asInstanceOf
+  }
 }

library/src/scala/runtime/DynamicTuple.scala

@@ -5,163 +5,6 @@ import scala.reflect.ClassTag
 
 object DynamicTuple {
 
-  given iarrayOps: [T](arr: IArray[T]) {
-    def ++[U >: T: ClassTag](that: IArray[U]): IArray[U] =
-      (arr.asInstanceOf[Array[T]] ++ that.asInstanceOf[Array[U]]).asInstanceOf
-
-    def contains(elem: T): Boolean =
-      arr.asInstanceOf[Array[T]].contains(elem)
-
-    def count(p: T => Boolean): Int =
-      arr.asInstanceOf[Array[T]].count(p)
-
-    def drop(n: Int): IArray[T] =
-      arr.asInstanceOf[Array[T]].drop(n).asInstanceOf
-
-    def dropRight(n: Int): IArray[T] =
-      arr.asInstanceOf[Array[T]].dropRight(n).asInstanceOf
-
-    def dropWhile(p: T => Boolean): IArray[T] =
-      arr.asInstanceOf[Array[T]].dropWhile(p).asInstanceOf
-
-    def exists(p: T => Boolean): IArray[T] =
-      arr.asInstanceOf[Array[T]].exists(p).asInstanceOf
-
-    def filter(p: T => Boolean): IArray[T] =
-      arr.asInstanceOf[Array[T]].filter(p).asInstanceOf
-
-    def filterNot(p: T => Boolean): IArray[T] =
-      arr.asInstanceOf[Array[T]].filterNot(p).asInstanceOf
-
-    def find(p: T => Boolean): Option[T] =
-      arr.asInstanceOf[Array[T]].find(p).asInstanceOf
-
-    def flatMap[U: ClassTag](f: T => IterableOnce[U]): IArray[U] =
-      arr.asInstanceOf[Array[T]].flatMap(f).asInstanceOf
-
-    def flatten[U: ClassTag](given T => Iterable[U]): IArray[U] =
-      arr.asInstanceOf[Array[T]].flatten.asInstanceOf
-
-    def fold[U >: T: ClassTag](z: U)(op: (U, U) => U): U =
-      arr.asInstanceOf[Array[T]].fold(z)(op).asInstanceOf
-
-    def foldLeft[U >: T: ClassTag](z: U)(op: (U, T) => U): U =
-      arr.asInstanceOf[Array[T]].foldLeft(z)(op).asInstanceOf
-
-    def foldRight[U >: T: ClassTag](z: U)(op: (T, U) => U): U =
-      arr.asInstanceOf[Array[T]].foldRight(z)(op).asInstanceOf
-
-    def forall(p: T => Boolean): Boolean =
-      arr.asInstanceOf[Array[T]].forall(p)
-
-    def foreach[U](f: T => U): Unit =
-      arr.asInstanceOf[Array[T]].foreach(f)
-
-    def head: T =
-      arr.asInstanceOf[Array[T]].head
-
-    def headOption: Option[T] =
-      arr.asInstanceOf[Array[T]].headOption
-
-    def indexOf(elem: T, from: Int = 0): Int =
-      arr.asInstanceOf[Array[T]].indexOf(elem, from)
-
-    def indexWhere(p: T => Boolean, from: Int = 0): Int =
-      arr.asInstanceOf[Array[T]].indexWhere(p, from)
-
-    def indices: Range =
-      arr.asInstanceOf[Array[T]].indices.asInstanceOf
-
-    def init: IArray[T] =
-      arr.asInstanceOf[Array[T]].init.asInstanceOf
-
-    def isEmpty: Boolean =
-      arr.asInstanceOf[Array[T]].isEmpty
-
-    def iterator: Iterator[T] =
-      arr.asInstanceOf[Array[T]].iterator
-
-    def last: T =
-      arr.asInstanceOf[Array[T]].last
-
-    def lastOption: Option[T] =
-      arr.asInstanceOf[Array[T]].lastOption
-
-    def lastIndexOf(elem: T, from: Int = 0): Int =
-      arr.asInstanceOf[Array[T]].lastIndexOf(elem, from)
-
-    def lastIndexWhere(p: T => Boolean, from: Int = 0): Int =
-      arr.asInstanceOf[Array[T]].lastIndexWhere(p, from)
-
-    def map[U: ClassTag](f: T => U): IArray[U] =
-      arr.asInstanceOf[Array[T]].map(f).asInstanceOf
-
-    def nonEmpty: Boolean =
-      arr.asInstanceOf[Array[T]].nonEmpty
-
-    def partition(p: T => Boolean): (IArray[T], IArray[T]) = arr.asInstanceOf[Array[T]].partition(p) match {
-      case (x, y) => (x.asInstanceOf[IArray[T]], y.asInstanceOf[IArray[T]])
-    }
-
-    def reverse: IArray[T] =
-      arr.asInstanceOf[Array[T]].reverse.asInstanceOf
-
-    def scan[U >: T: ClassTag](z: U)(op: (U, U) => U): Array[U] =
-      arr.asInstanceOf[Array[T]].scan(z)(op).asInstanceOf
-
-    def scanLeft[U: ClassTag](z: U)(op: (U, T) => U): Array[U] =
-      arr.asInstanceOf[Array[T]].scanLeft(z)(op).asInstanceOf
-
-    def scanRight[U: ClassTag](z: U)(op: (T, U) => U): Array[U] =
-      arr.asInstanceOf[Array[T]].scanRight(z)(op).asInstanceOf
-
-    def size: Int =
-      arr.asInstanceOf[Array[T]].size
-
-    def slice(from: Int, until: Int): Array[T] =
-      arr.asInstanceOf[Array[T]].slice(from, until).asInstanceOf
-
-    def sortBy[U: ClassTag](f: T => U)(given math.Ordering[U]): IArray[T] =
-      arr.asInstanceOf[Array[T]].sortBy(f).asInstanceOf
-
-    def sortWith(f: (T, T) => Boolean): IArray[T] =
-      arr.asInstanceOf[Array[T]].sortWith(f).asInstanceOf
-
-    def sorted(given math.Ordering[T]): IArray[T] =
-      arr.asInstanceOf[Array[T]].sorted.asInstanceOf
-
-    def span(p: T => Boolean): (IArray[T], IArray[T]) = arr.asInstanceOf[Array[T]].span(p) match {
-      case (x, y) => (x.asInstanceOf[IArray[T]], y.asInstanceOf[IArray[T]])
-    }
-
-    def splitAt(n: Int): (IArray[T], IArray[T]) = arr.asInstanceOf[Array[T]].splitAt(n) match {
-      case (x, y) => (x.asInstanceOf[IArray[T]], y.asInstanceOf[IArray[T]])
-    }
-
-    def startsWith[U >: T: ClassTag](that: IArray[U], offset: Int = 0): Boolean =
-      arr.asInstanceOf[Array[T]].startsWith(that.asInstanceOf[Array[U]])
-
-    def tail: IArray[T] =
-      arr.asInstanceOf[Array[T]].tail.asInstanceOf
-
-    def take(n: Int): IArray[T] =
-      arr.asInstanceOf[Array[T]].take(n).asInstanceOf
-
-    def takeRight(n: Int): IArray[T] =
-      arr.asInstanceOf[Array[T]].takeRight(n).asInstanceOf
-
-    def takeWhile(p: T => Boolean): IArray[T] =
-      arr.asInstanceOf[Array[T]].takeWhile(p).asInstanceOf
-
-    def unzip[U: ClassTag, V: ClassTag](given T => (U, V)): (IArray[U], IArray[V]) =
-      arr.asInstanceOf[Array[T]].unzip(asPair, ct1, ct2) match {
-        case (x, y) => (x.asInstanceOf[IArray[U]], y.asInstanceOf[IArray[V]])
-      }
-
-    def zip[U: ClassTag](that: IterableOnce[U]): IArray[(T, U)] =
-      arr.asInstanceOf[Array[T]].zip(that).asInstanceOf
-  }
-
   inline val MaxSpecialized = 22
   inline private val XXL = MaxSpecialized + 1