ArrayOps
(JVM / Native)

js.ArrayOps
(js.Array)

narr.Extensions
(NArr)

def width: Int

def knownSize: Int

def isEmpty: Boolean

def nonEmpty: Boolean

def head: T

def last: T

def headOption: Option[T]

def lastOption: Option[T]

def sizeCompare(otherSize: Int): Int

def lengthCompare(len: Int): Int

def sizeIs: Int

def lengthIs: Int

def slice(from: Int, until: Int): Array[T]

def tail: Array[T]

def init: Array[T]

def tails: Iterator[Array[T]]

def inits: Iterator[Array[T]]

def take(n: Int): Array[T]

def drop(n: Int): Array[T]

def takeRight(n: Int): Array[T]

def dropRight(n: Int): Array[T]

def takeWhile(p: T => Boolean): Array[T]

def dropWhile(p: T => Boolean): Array[T]

def iterator: Iterator[T]

def stepper[S <: Stepper[_]](
  implicit shape: StepperShape[T, S]
): S with EfficientSplit

def grouped(width: Int): Iterator[Array[T]]

def span(p: T => Boolean): (Array[T], Array[T])

def splitAt(n: Int): (Array[T], Array[T])

def partition(p: T => Boolean): (Array[T], Array[T])

def partitionMap[A1: ClassTag, A2: ClassTag](
  f: T => Either[A1, A2]
): (Array[A1], Array[A2])

def reverse: Array[T]

def reverseIterator: Iterator[T]

def filter(p: T => Boolean): Array[T]

def filterNot(p: T => Boolean): Array[T]

def sorted[B >: T](implicit ord: Ordering[B]): Array[T]

def sortWith(lt: (T, T) => Boolean): Array[T]

def sortBy[B](f: T => B)(implicit ord: Ordering[B]): Array[T]

def withFilter(p: T => Boolean): ArrayOps.WithFilter[T]

def indexOf(elem: T, from: Int = 0): Int

def indexWhere(p: T => Boolean, from: Int = 0): Int

def lastIndexOf(elem: T, end: Int = xs.length - 1): Int

def lastIndexWhere(p: T => Boolean, end: Int = xs.length - 1): Int

def find(p: T => Boolean): Option[T]

def exists(p: T => Boolean): Boolean

def forall(p: T => Boolean): Boolean

def foldLeft[B](z: B)(op: (B, T) => B): B

def scanLeft[ B : ClassTag ](z: B)(op: (B, T) => B): Array[B]

def scan[B >: T : ClassTag](z: B)(op: (B, B) => B): Array[B]

def scanRight[ B : ClassTag ](z: B)(op: (T, B) => B): Array[B]

def foldRight[B](z: B)(op: (T, B) => B): B

def fold[A1 >: T](z: A1)(op: (A1, A1) => A1): A1

def map[B](f: T => B)(implicit ct: ClassTag[B]): Array[B]

def mapInPlace(f: T => T): Array[T]

def flatMap[B : ClassTag](
  f: T => IterableOnce[B]
): Array[B]

def flatMap[BS, B](f: T => BS)(
  implicit asIterable: BS => Iterable[B], m: ClassTag[B]
): Array[B]

def flatten[B](
  implicit asIterable: T => IterableOnce[B], m: ClassTag[B]
): Array[B]

def collect[B: ClassTag](pf: PartialFunction[T, B]): Array[B]

def collectFirst[B](pf: PartialFunction[T, B]): Option[B]

def zip[B](that: IterableOnce[B]): Array[(T, B)]

def lazyZip[B](that: Iterable[B]): LazyZip2[T, B, Array[T]]

def zipAll[A1 >: T, B](
  that: Iterable[B], thisElem: A1, thatElem: B
): Array[(A1, B)]

def zipWithIndex: Array[(T, Int)]

def appended[B >: T : ClassTag](x: B): Array[B]

def :+ [B >: T : ClassTag](x: B): Array[B]

def prepended[B >: T : ClassTag](x: B): Array[B]

def +: [B >: T : ClassTag](x: B): Array[B]

def prependedAll[B >: T : ClassTag](prefix: IterableOnce[B]): Array[B]

def prependedAll[B >: T : ClassTag](prefix: Array[_ <: B]): Array[B]

def ++: [B >: T : ClassTag](prefix: IterableOnce[B]): Array[B]

def ++: [B >: T : ClassTag](prefix: Array[_ <: B]): Array[B]

def appendedAll[B >: T : ClassTag](suffix: IterableOnce[B]): Array[B]

def appendedAll[B >: T : ClassTag](suffix: Array[_ <: B]): Array[B]

def :++ [B >: T : ClassTag](suffix: IterableOnce[B]): Array[B]

def :++ [B >: T : ClassTag](suffix: Array[_ <: B]): Array[B]

def concat[B >: T : ClassTag](suffix: IterableOnce[B]): Array[B]

def concat[B >: T : ClassTag](suffix: Array[_ <: B]): Array[B]

def ++[B >: T : ClassTag](xs: IterableOnce[B]): Array[B]

def ++[B >: T : ClassTag](xs: Array[_ <: B]): Array[B]

def contains(elem: T): Boolean

def patch[B >: T : ClassTag](
  from: Int, other: IterableOnce[B], replaced: Int
): Array[B]

def unzip[A1, A2](
  implicit asPair: T => (A1, A2), ct1: ClassTag[A1], ct2: ClassTag[A2]
): (Array[A1], Array[A2])

def unzip3[A1, A2, A3](
  implicit asTriple: T => (A1, A2, A3),
  ct1: ClassTag[A1],
  ct2: ClassTag[A2],
  ct3: ClassTag[A3]
): (Array[A1], Array[A2], Array[A3])

def transpose[B](implicit asArray: T => Array[B]): Array[Array[B]]

def foreach[U](f: T => U): Unit

def distinct: Array[T]

def distinctBy[B](f: T => B): Array[T]

def padTo[B >: T : ClassTag](len: Int, elem: B): Array[B]

def indices: Range

def groupBy[K](f: T => K): immutable.Map[K, Array[T]]

def groupMap[K, B : ClassTag](
  key: T => K
)(
  f: T => B): immutable.Map[K, Array[B]]

def toSeq: immutable.Seq[T]

def toIndexedSeq: immutable.IndexedSeq[T]

def copyToArray[B >: T](xs: Array[B]): Int

def copyToArray[B >: T](xs: Array[B], start: Int): Int

def copyToArray[B >: T](xs: Array[B], start: Int, len: Int): Int

def toArray[B >: T: ClassTag]: Array[B]

def count(p: T => Boolean): Int

def startsWith[B >: T](that: Array[B]): Boolean

def startsWith[B >: T](that: Array[B], offset: Int): Boolean

def endsWith[B >: T](that: Array[B]): Boolean

def updated[B >: T : ClassTag](index: Int, elem: B): Array[B]

def view: IndexedSeqView[T]

def diff[B >: T](that: Seq[B]): Array[T]

def intersect[B >: T](that: Seq[B]): Array[T]

def sliding(width: Int, step: Int = 1): Iterator[Array[T]]

def combinations(n: Int): Iterator[Array[T]]

def permutations: Iterator[Array[T]]

def startsWith[B >: T](that: IterableOnce[B], offset: Int = 0): Boolean

def endsWith[B >: T](that: Iterable[B]): Boolean

def startsWithIterable[B >: T](that: IterableOnce[B], offset: Int = 0): Boolean

def endsWithIterable[B >: T](that: Iterable[B]): Boolean