Add missing IArray operations

Author: nicolasstucki

library/src/scala/IArray.scala

@@ -1,7 +1,8 @@
 package scala
 import reflect.ClassTag
 
-import scala.collection.immutable
+import scala.collection._
+import scala.collection.mutable.Buffer
 
 opaque type IArray[+T] = Array[_ <: T]
 
@@ -104,17 +105,17 @@ object IArray:
     genericArrayOps(arr).flatten
 
   /** Folds the elements of this array using the specified associative binary operator. */
-  extension [T](arr: IArray[T]) def fold[U >: T: ClassTag](z: U)(op: (U, U) => U): U =
+  extension [T](arr: IArray[T]) def fold[U >: T](z: U)(op: (U, U) => U): U =
     genericArrayOps(arr).fold(z)(op)
 
   /** Applies a binary operator to a start value and all elements of this array,
     * going left to right. */
-  extension [T](arr: IArray[T]) def foldLeft[U: ClassTag](z: U)(op: (U, T) => U): U =
+  extension [T](arr: IArray[T]) def foldLeft[U](z: U)(op: (U, T) => U): U =
     genericArrayOps(arr).foldLeft(z)(op)
 
   /** Applies a binary operator to all elements of this array and a start value,
     * going right to left. */
-  extension [T](arr: IArray[T]) def foldRight[U: ClassTag](z: U)(op: (T, U) => U): U =
+  extension [T](arr: IArray[T]) def foldRight[U](z: U)(op: (T, U) => U): U =
     genericArrayOps(arr).foldRight(z)(op)
 
   /** Tests whether a predicate holds for all elements of this array. */
@@ -217,7 +218,7 @@ object IArray:
 
   /** Sorts this array according to the Ordering which results from transforming
     * an implicitly given Ordering with a transformation function. */
-  extension [T](arr: IArray[T]) def sortBy[U: ClassTag](f: T => U)(using math.Ordering[U]): IArray[T] =
+  extension [T](arr: IArray[T]) def sortBy[U](f: T => U)(using math.Ordering[U]): IArray[T] =
     genericArrayOps(arr).sortBy(f)
 
   /** Sorts this array according to a comparison function. */
@@ -237,7 +238,7 @@ object IArray:
     genericArrayOps(arr).splitAt(n)
 
   /** Tests whether this array starts with the given array. */
-  extension [T](arr: IArray[T]) def startsWith[U >: T: ClassTag](that: IArray[U], offset: Int = 0): Boolean =
+  extension [T](arr: IArray[T]) def startsWith[U >: T](that: IArray[U], offset: Int = 0): Boolean =
     genericArrayOps(arr).startsWith(that)
 
   /** The rest of the array without its first element. */
@@ -264,11 +265,115 @@ object IArray:
   extension [U: ClassTag, V: ClassTag](arr: IArray[(U, V)]) def unzip: (IArray[U], IArray[V]) =
     genericArrayOps(arr).unzip
 
-  /** Returns an array formed from this array and another iterable collection
-    * by combining corresponding elements in pairs.
-    * If one of the two collections is longer than the other, its remaining elements are ignored. */
-  extension [T](arr: IArray[T]) def zip[U: ClassTag](that: IArray[U]): IArray[(T, U)] =
-    genericArrayOps(arr).zip(that)
+  extension [A](arr: IArray[A])
+    def :+ [B >: A: ClassTag](x: B): IArray[B] = genericArrayOps(arr) :+ x
+    def :++ [B >: A: ClassTag](suffix: IterableOnce[B]): IArray[B] = genericArrayOps(arr) :++ suffix
+    def addString(b: mutable.StringBuilder): mutable.StringBuilder = arr.toSeq.addString(b)
+    def addString(b: mutable.StringBuilder, sep: String): mutable.StringBuilder = arr.toSeq.addString(b, sep)
+    def addString(b: mutable.StringBuilder, start: String, sep: String, end: String): mutable.StringBuilder = arr.toSeq.addString(b, start, sep, end)
+    def appended[B >: A: ClassTag](x: B): IArray[B] = genericArrayOps(arr).appended(x)
+    def appendedAll[B >: A: ClassTag](suffix: IterableOnce[B]): IArray[B] = genericArrayOps(arr).appendedAll(suffix)
+    def collect[B: ClassTag](pf: PartialFunction[A, B]): IArray[B] = genericArrayOps(arr).collect(pf)
+    def collectFirst[B](f: PartialFunction[A, B]): Option[B] = genericArrayOps(arr).collectFirst(f)
+    def combinations(n: Int): Iterator[IArray[A]] = genericArrayOps(arr).combinations(n)
+    def concat[B >: A: ClassTag](suffix: IterableOnce[B]): IArray[B] = genericArrayOps(arr).concat(suffix)
+    def containsSlice[B](that: Seq[B]): Boolean = arr.toSeq.containsSlice(that)
+    def corresponds[B](that: IterableOnce[B])(p: (A, B) => Boolean): Boolean = arr.toSeq.corresponds(that)(p)
+    def diff[B >: A](that: Seq[B]): IArray[A] = genericArrayOps(arr).diff(that)
+    def distinct: IArray[A] = genericArrayOps(arr).distinct
+    def distinctBy[B](f: A => B): IArray[A] = genericArrayOps(arr).distinctBy(f)
+    def empty: immutable.ArraySeq[A] = arr.toSeq.empty
+    def endsWith[B >: A](that: Iterable[B]): Boolean = genericArrayOps(arr).endsWith(that)
+    def findLast(p: A => Boolean): Option[A] = arr.toSeq.findLast(p)
+    def groupBy[K](f: A => K): immutable.Map[K, IArray[A]] = genericArrayOps(arr).groupBy(f)
+    def groupMap[K, B: ClassTag](key: A => K)(f: A => B): immutable.Map[K, IArray[B]] = genericArrayOps(arr).groupMap(key)(f)
+    def groupMapReduce[K, B](key: (A) => K)(f: (A) => B)(reduce: (B, B) => B): immutable.Map[K, B] = arr.toSeq.groupMapReduce(key)(f)(reduce)
+    def grouped(size: Int): Iterator[IArray[A]] = genericArrayOps(arr).grouped(size)
+    def indexOfSlice[B >: A](that: Seq[B]): Int = arr.toSeq.indexOfSlice(that)
+    def indexOfSlice[B >: A](that: Seq[B], from: Int): Int = arr.toSeq.indexOfSlice(that, from)
+    def inits: Iterator[IArray[A]] = genericArrayOps(arr).inits
+    def intersect[B >: A](that: Seq[B]): IArray[A] = genericArrayOps(arr).intersect(that)
+    def isTraversableAgain: Boolean = arr.toSeq.isTraversableAgain
+    def knownSize: Int = arr.length
+    def lastIndexOfSlice[B >: A](that: Seq[B]): Int = arr.toSeq.lastIndexOfSlice(that)
+    def lastIndexOfSlice[B >: A](that: Seq[B], end: Int): Int = arr.toSeq.lastIndexOfSlice(that, end)
+    def lazyZip[B](that: Iterable[B]): LazyZip2[A, B, IArray[A]] = genericArrayOps(arr).lazyZip[B](that).asInstanceOf[LazyZip2[A, B, IArray[A]]]
+    def lengthCompare(len: Int): Int = genericArrayOps(arr).lengthCompare(len)
+    def lengthIs: IterableOps.SizeCompareOps = arr.toSeq.lengthIs
+    def max[B >: A](using math.Ordering[B]): A = arr.toSeq.max[B]
+    def maxBy[B](f: A => B)(using math.Ordering[B]): A = arr.toSeq.maxBy(f)
+    def maxByOption[B](f: A => B)(using math.Ordering[B]): Option[A] = arr.toSeq.maxByOption(f)
+    def maxOption[B >: A](using math.Ordering[B]): Option[B] = arr.toSeq.maxOption[B]
+    def min[B >: A](using math.Ordering[B]): A = arr.toSeq.min[B]
+    def minBy[B](f: A => B)(using math.Ordering[B]): A = arr.toSeq.minBy(f)
+    def minByOption[B](f: A => B)(using math.Ordering[B]): Option[A] = arr.toSeq.minByOption(f)
+    def minOption[B >: A](using math.Ordering[B]): Option[B] = arr.toSeq.minOption[B]
+    def mkString: String = arr.toSeq.mkString
+    def mkString(sep: String): String = arr.toSeq.mkString(sep)
+    def mkString(start: String, sep: String, end: String): String = arr.toSeq.mkString(start, sep, end)
+    def padTo[B >: A: ClassTag](len: Int, elem: B): IArray[B] = genericArrayOps(arr).padTo(len, elem)
+    def partitionMap[A1: ClassTag, A2: ClassTag](f: A => Either[A1, A2]): (IArray[A1], IArray[A2]) = genericArrayOps(arr).partitionMap(f)
+    def patch[B >: A: ClassTag](from: Int, other: IterableOnce[B], replaced: Int): IArray[B] = genericArrayOps(arr).patch(from, other, replaced)
+    def permutations: Iterator[IArray[A]] = genericArrayOps(arr).permutations
+    def prepended[B >: A: ClassTag](x: B): IArray[B] = genericArrayOps(arr).prepended(x)
+    def prependedAll[B >: A: ClassTag](prefix: IterableOnce[B]): IArray[B] = genericArrayOps(arr).prependedAll(prefix)
+    def product[B >: A](using math.Numeric[B]): B = arr.toSeq.product[B]
+    def reduce[B >: A](op: (B, B) => B): B = arr.toSeq.reduce(op)
+    def reduceLeft[B >: A](op: (B, A) => B): B = arr.toSeq.reduceLeft(op)
+    def reduceRight[B >: A](op: (A, B) => B): B = arr.toSeq.reduceRight(op)
+    def reverseIterator: Iterator[A] = genericArrayOps(arr).reverseIterator
+    def sameElements[B >: A](that: IterableOnce[B]): Boolean = arr.toSeq.sameElements(that)
+    def search[B >: A](elem: B)(using Ordering[B]): Searching.SearchResult = arr.toSeq.search(elem)
+    def search[B >: A](elem: B, from: Int, to: Int)(using Ordering[B]): Searching.SearchResult = arr.toSeq.search(elem, from, to)
+    def segmentLength(p: (A) => Boolean, from: Int): Int = arr.toSeq.segmentLength(p, from)
+    def segmentLength(p: (A) => Boolean): Int = arr.toSeq.segmentLength(p)
+    def sizeCompare(that: Iterable[_]): Int = arr.toSeq.sizeCompare(that)
+    def sizeCompare(otherSize: Int): Int = genericArrayOps(arr).sizeCompare(otherSize)
+    def sizeIs: IterableOps.SizeCompareOps = arr.toSeq.sizeIs
+    def sliding(size: Int, step: Int = 1): Iterator[IArray[A]] = genericArrayOps(arr).sliding(size, step)
+    def startsWith[B >: A](that: IterableOnce[B], offset: Int): Boolean = genericArrayOps(arr).startsWith(that, offset)
+    def stepper[S <: Stepper[_]](using StepperShape[A, S]): S = genericArrayOps(arr).stepper[S]
+    def sum[B >: A](using math.Numeric[B]): B = arr.toSeq.sum[B]
+    def tails: Iterator[IArray[A]] = genericArrayOps(arr).tails
+    def tapEach[U](f: (A) => U): IArray[A] =
+      arr.toSeq.foreach(f)
+      arr
+    def to[C1](factory: Factory[A, C1]): C1 = arr.toSeq.to(factory)
+    def toBuffer[B >: A]: Buffer[B] = arr.toSeq.toBuffer[B]
+    def toIndexedSeq: immutable.IndexedSeq[A] = arr.toSeq.toIndexedSeq
+    def toIterable: Iterable[A] = arr.toSeq.toIterable
+    def toList: List[A] = arr.toSeq.toList
+    def toSet: Set[A] = arr.toSeq.toSet
+    def toVector: Vector[A] = arr.toSeq.toVector
+    def updated[B >: A: ClassTag](index: Int, elem: B): IArray[B] = genericArrayOps(arr).updated(index, elem)
+    def view: SeqView[A] = genericArrayOps(arr).view
+    // TODO
+    // def withFilter(p: A => Boolean): ArrayOps.WithFilter[A] =
+    //   genericArrayOps(arr).withFilter(p)
+    def zip[B](that: IterableOnce[B]): IArray[(A, B)] = genericArrayOps(arr).zip(that)
+    def zipAll[A1 >: A, B](that: Iterable[B], thisElem: A1, thatElem: B): IArray[(A1, B)] = genericArrayOps(arr).zipAll(that, thisElem, thatElem)
+    def zipWithIndex: IArray[(A, Int)] = genericArrayOps(arr).zipWithIndex
+  end extension
+
+  extension [A: ClassTag](arr: IArray[IterableOnce[A]])
+    def flatten: IArray[A] = genericArrayOps(arr).flatten
+
+  extension [A: ClassTag](prefix: IterableOnce[A])
+    def ++:(arr: IArray[A]): IArray[A] = genericArrayOps(arr).prependedAll(prefix)
+
+  extension [A: ClassTag](x: A)
+    def +:(arr: IArray[A]): IArray[A] = genericArrayOps(arr).prepended(x)
+
+  extension [A1, A2](arr: IArray[(A1, A2)])
+    def toMap: Map[A1, A2] = arr.toSeq.toMap
+
+  extension [A1: ClassTag, A2: ClassTag, A3: ClassTag](arr: IArray[(A1, A2, A3)])
+    def unzip3: (IArray[A1], IArray[A2], IArray[A3]) = genericArrayOps(arr).unzip3
+
+  // TODO
+  // extension [A](arr: IArray[IArray[A]])
+  //   def transpose[B](implicit asArray: A => Array[B]): IArray[IArray[B]] =
+  //     genericArrayOps(arr).transpose(using asArray.asInstanceOf)
 
   /** Conversion from IArray to immutable.ArraySeq */
   extension [T](arr: IArray[T]) def toSeq: immutable.ArraySeq[T] =
@@ -372,7 +477,7 @@ object IArray:
     // `Array.concat` should arguably take in a `Seq[Array[_ <: T]]`,
     // but since it currently takes a `Seq[Array[T]]` we have to perform a cast,
     // knowing tacitly that `concat` is not going to do the wrong thing.
-    Array.concat[T](xss.asInstanceOf[Seq[Array[T]]]: _*)
+    Array.concat[T](xss.asInstanceOf[immutable.Seq[Array[T]]]: _*)
 
   /** Returns an immutable array that contains the results of some element computation a number
    *  of times. Each element is determined by a separate computation.
@@ -521,4 +626,4 @@ object IArray:
   def unapplySeq[T](x: IArray[T]): Array.UnapplySeqWrapper[_ <: T] =
     Array.unapplySeq(x)
 
-end IArray
+end IArray

tests/run/IArrayOps.check

@@ -0,0 +1,136 @@
+ArraySeq(1, 2, 3)
+true
+false
+ArraySeq(1, 9, 3)
+ArraySeq(1, a, 3)
+ArraySeq(1, 2, 3, 0)
+ArraySeq(1, 1, 2, 3)
+ArraySeq(1, 5, 4, 3)
+1
+1
+ArraySeq(1, 5, 4, 3)
+ArraySeq(5, 4, 3)
+ArraySeq()
+ArraySeq(1, 2, 3, 5, 4, 5, 6)
+ArraySeq(1, 2, 3, 7)
+ArraySeq(8, 1, 2, 3)
+ArraySeq(5, 4, 5, 6, 12, 13, 14)
+ArraySeq(12, 13, 14, 5, 4, 5, 6)
+123
+1-2-3
+(1,2,3)
+ArraySeq(1, 2, 3, 5)
+ArraySeq(1, 2, 3, 1, 4)
+ArraySeq(5, 1, 2, 3)
+ArraySeq(5, 6, 1, 2, 3)
+ArraySeq(2, 6)
+Some(2)
+List(ArraySeq(1), ArraySeq(2), ArraySeq(3))
+List(ArraySeq(1, 2), ArraySeq(1, 3), ArraySeq(2, 3))
+List(ArraySeq(1, 2, 3))
+ArraySeq(1, 2, 3, 8, 9)
+true
+true
+false
+ArraySeq(3)
+ArraySeq(3)
+ArraySeq(1, 2, 3)
+ArraySeq(5, 4, 6)
+ArraySeq(5, 4)
+true
+Some(1)
+Some(2)
+6
+6
+6
+6
+6
+6
+Map(1 -> ArraySeq(1), 2 -> ArraySeq(2), 3 -> ArraySeq(3))
+Map(0 -> ArraySeq(2), 1 -> ArraySeq(1, 3))
+Map(1 -> ArraySeq(1), 2 -> ArraySeq(2), 3 -> ArraySeq(3))
+Map(0 -> ArraySeq(2), 1 -> ArraySeq(1, 3))
+Map(1 -> 1, 2 -> 2, 3 -> 3)
+Map(0 -> 2, 1 -> 13)
+List(ArraySeq(1, 2), ArraySeq(3))
+0
+1
+-1
+1
+0
+1
+0
+1
+List(ArraySeq(1, 2, 3), ArraySeq(1, 2), ArraySeq(1), ArraySeq())
+List(ArraySeq(1, 2, 3), ArraySeq(2, 3), ArraySeq(3), ArraySeq())
+ArraySeq(1, 2)
+ArraySeq(2, 3)
+3
+ArraySeq(1, 2, 3).lazyZip(ArraySeq(5, 4, 5, 6))
+List((1,5), (2,4), (3,5))
+0
+1
+-1
+3
+Some(3)
+3
+Some(3)
+1
+Some(1)
+1
+Some(1)
+123
+1-2-3
+(1,2,3)
+ArraySeq((1,5), (2,4), (3,5))
+ArraySeq((1,5), (2,5), (3,5))
+ArraySeq((1,5), (2,5), (3,4))
+ArraySeq(1, 2)
+ArraySeq(a, b)
+ArraySeq(1, 2)
+ArraySeq(a, b)
+ArraySeq(x, y)
+ArraySeq(1, 2, 3, 0, 0, 0)
+ArraySeq(1, 2, 3)
+ArraySeq()
+ArraySeq()
+ArraySeq(1, 2, 3)
+ArraySeq(1, 6, 7, 8, 9)
+List(ArraySeq(1, 2, 3), ArraySeq(1, 3, 2), ArraySeq(2, 1, 3), ArraySeq(2, 3, 1), ArraySeq(3, 1, 2), ArraySeq(3, 2, 1))
+6
+6
+List(1, 2, 3)
+List(3, 2, 1)
+true
+false
+1
+0
+-1
+1
+List(ArraySeq(1, 2), ArraySeq(2, 3))
+List(ArraySeq(5, 4, 5), ArraySeq(5, 6))
+ArraySeq(6, 5, 5, 4)
+true
+true
+1
+2
+3
+ArraySeq(1, 2, 3)
+ArraySeq((1,0), (2,1), (3,2))
+List(1, 2, 3)
+Vector(1, 2, 3)
+ArrayBuffer(1, 2, 3)
+ArraySeq(1, 2, 3)
+ArraySeq(1, 2, 3)
+List(1, 2, 3)
+Set(1, 2, 3)
+Vector(1, 2, 3)
+ArrayView(1, 2, 3)
+Map(1 -> 5, 2 -> 4, 3 -> 5)
+ArraySeq()
+true
+false
+false
+ArraySeq(1, 2, 2, 3)
+Found(1)
+InsertionPoint(2)