A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from https://www.scala-lang.org/api/2.13.7/scala/Array.html below:

Scala Standard Library 2.13.7 - scala.Array

final class Array[T] extends java.io.Serializable with java.lang.Cloneable



Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Array
  2. Cloneable
  3. Serializable
  4. AnyRef
  5. Any
Implicitly
  1. by genericArrayOps
  2. by copyArrayToImmutableIndexedSeq
  3. by any2stringadd
  4. by StringFormat
  5. by Ensuring
  6. by ArrowAssoc
Visibility
  1. Public
  2. Protected
Instance Constructors
  1.  new Array(_length: Int)
Value Members
  1.  final def !=(arg0: Any): Boolean
  2.  final def ##: Int
  3.  def +(other: String): String
  4.  final def ++[B >: A](xs: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]
  5.  final def ++[B >: A](xs: collection.IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
  6.  final def ++[B >: A](suffix: collection.IterableOnce[B]): collection.immutable.IndexedSeq[B]
  7.  final def ++:[B >: A](prefix: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]
  8.  final def ++:[B >: A](prefix: collection.IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
  9.  final def ++:[B >: A](prefix: collection.IterableOnce[B]): collection.immutable.IndexedSeq[B]
  10.  final def +:[B >: A](x: B)(implicit arg0: ClassTag[B]): Array[B]
  11.  final def +:[B >: A](elem: B): collection.immutable.IndexedSeq[B]
  12.  def ->[B](y: B): (Array[T], B)
  13.  final def :+[B >: A](x: B)(implicit arg0: ClassTag[B]): Array[B]
  14.  final def :+[B >: A](elem: B): collection.immutable.IndexedSeq[B]
  15.  final def :++[B >: A](suffix: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]
  16.  final def :++[B >: A](suffix: collection.IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
  17.  final def :++[B >: A](suffix: collection.IterableOnce[B]): collection.immutable.IndexedSeq[B]
  18.  final def ==(arg0: Any): Boolean
  19.  final def addString(b: collection.mutable.StringBuilder): collection.mutable.StringBuilder
  20.  final def addString(b: collection.mutable.StringBuilder, sep: String): collection.mutable.StringBuilder
  21.  def addString(b: collection.mutable.StringBuilder, start: String, sep: String, end: String): collection.mutable.StringBuilder
  22.  def andThen[C](k: PartialFunction[T, C]): PartialFunction[Int, C]
  23.  def andThen[C](k: (T) => C): PartialFunction[Int, C]
  24.  def appended[B >: A](x: B)(implicit arg0: ClassTag[B]): Array[B]
  25.  def appended[B >: A](elem: B): collection.immutable.IndexedSeq[B]
  26.  def appendedAll[B >: A](suffix: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]
  27.  def appendedAll[B >: A](suffix: collection.IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
  28.  def appendedAll[B >: A](suffix: collection.IterableOnce[B]): collection.immutable.IndexedSeq[B]
  29.  def apply(i: Int): T
  30.  def applyOrElse[A1 <: A, B1 >: B](x: A1, default: (A1) => B1): B1
  31.  final def asInstanceOf[T0]: T0
  32.  def canEqual(that: Any): Boolean
  33.  def clone(): Array[T]
  34.  def collect[B](pf: PartialFunction[T, B])(implicit arg0: ClassTag[B]): Array[B]
  35.  def collect[B](pf: PartialFunction[T, B]): collection.immutable.IndexedSeq[B]
  36.  def collectFirst[B](f: PartialFunction[T, B]): Option[B]
  37.  def collectFirst[B](pf: PartialFunction[T, B]): Option[B]
  38.  def compose[R](k: PartialFunction[R, Int]): PartialFunction[R, T]
  39.  def compose[A](g: (A) => Int): (A) => T
  40.  final def concat[B >: A](suffix: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]
  41.  final def concat[B >: A](suffix: collection.IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
  42.  final def concat[B >: A](suffix: collection.IterableOnce[B]): collection.immutable.IndexedSeq[B]
  43.  def containsSlice[B >: A](that: collection.Seq[B]): Boolean
  44.  def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Int
  45.  def copyToArray[B >: A](xs: Array[B], start: Int): Int
  46.  def copyToArray[B >: A](xs: Array[B]): Int
  47.  def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Int
  48.  def copyToArray[B >: A](xs: Array[B], start: Int): Int
  49.  def copyToArray[B >: A](xs: Array[B]): Int
  50.  def corresponds[B](that: collection.Seq[B])(p: (T, B) => Boolean): Boolean
  51.  def corresponds[B](that: collection.IterableOnce[B])(p: (T, B) => Boolean): Boolean
  52.  def diff[B >: A](that: collection.Seq[B]): Array[T]
  53.  def diff[B >: A](that: collection.Seq[B]): collection.immutable.IndexedSeq[T]
  54.  def distinctBy[B](f: (T) => B): Array[T]
  55.  def distinctBy[B](f: (T) => B): collection.immutable.IndexedSeq[T]
  56.  def elementWise: ElementWiseExtractor[Int, T]
  57.  def empty: collection.immutable.IndexedSeq[T]
  58.  def endsWith[B >: A](that: collection.Iterable[B]): Boolean
  59.  def endsWith[B >: A](that: Array[B]): Boolean
  60.  def endsWith[B >: A](that: collection.Iterable[B]): Boolean
  61.  def ensuring(cond: (Array[T]) => Boolean, msg: => Any): Array[T]
  62.  def ensuring(cond: (Array[T]) => Boolean): Array[T]
  63.  def ensuring(cond: Boolean, msg: => Any): Array[T]
  64.  def ensuring(cond: Boolean): Array[T]
  65.  final def eq(arg0: AnyRef): Boolean
  66.  def equals(arg0: AnyRef): Boolean
  67.  def finalize(): Unit
  68.  def findLast(p: (T) => Boolean): Option[T]
  69.  def flatMap[BS, B](f: (T) => BS)(implicit asIterable: (BS) => collection.Iterable[B], m: ClassTag[B]): Array[B]
  70.  def flatMap[B](f: (T) => collection.IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
  71.  def flatMap[B](f: (T) => collection.IterableOnce[B]): collection.immutable.IndexedSeq[B]
  72.  def flatten[B](implicit asIterable: (T) => collection.IterableOnce[B], m: ClassTag[B]): Array[B]
  73.  def flatten[B](implicit asIterable: (T) => collection.IterableOnce[B]): collection.immutable.IndexedSeq[B]
  74.  def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
  75.  def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
  76.  def foldLeft[B](z: B)(op: (B, T) => B): B
  77.  def foldLeft[B](z: B)(op: (B, T) => B): B
  78.  def foldRight[B](z: B)(op: (T, B) => B): B
  79.  def foldRight[B](z: B)(op: (T, B) => B): B
  80.  def foreach[U](f: (T) => U): Unit
  81.  def foreach[U](f: (T) => U): Unit
  82.  final def getClass(): Class[_ <: AnyRef]
  83.  def groupBy[K](f: (T) => K): Map[K, Array[T]]
  84.  def groupBy[K](f: (T) => K): Map[K, collection.immutable.IndexedSeq[T]]
  85.  def groupMap[K, B](key: (T) => K)(f: (T) => B)(implicit arg0: ClassTag[B]): Map[K, Array[B]]
  86.  def groupMap[K, B](key: (T) => K)(f: (T) => B): Map[K, collection.immutable.IndexedSeq[B]]
  87.  def groupMapReduce[K, B](key: (T) => K)(f: (T) => B)(reduce: (B, B) => B): Map[K, B]
  88.  def hashCode(): Int
  89.  def indexOf[B >: A](elem: B): Int
  90.  def indexOfSlice[B >: A](that: collection.Seq[B]): Int
  91.  def indexOfSlice[B >: A](that: collection.Seq[B], from: Int): Int
  92.  def indexWhere(p: (T) => Boolean): Int
  93.  def intersect[B >: A](that: collection.Seq[B]): Array[T]
  94.  def intersect[B >: A](that: collection.Seq[B]): collection.immutable.IndexedSeq[T]
  95.  def isDefinedAt(idx: Int): Boolean
  96.  final def isInstanceOf[T0]: Boolean
  97.  def isTraversableAgain: Boolean
  98.  def iterableFactory: SeqFactory[collection.immutable.IndexedSeq]
  99.  def lastIndexOfSlice[B >: A](that: collection.Seq[B]): Int
  100.  def lastIndexOfSlice[B >: A](that: collection.Seq[B], end: Int): Int
  101.  def lastIndexWhere(p: (T) => Boolean): Int
  102.  def lazyZip[B](that: collection.Iterable[B]): LazyZip2[T, B, Array[T]]
  103.  def lazyZip[B]: ([B](that: Iterable[B]): scala.collection.LazyZip2[T,B,_1.type]) forSome {val _1: collection.immutable.IndexedSeq[T]}
  104.  def length: Int
  105.  final def lengthCompare(that: collection.Iterable[_]): Int
  106.  def lift: (Int) => Option[T]
  107.  def map[B](f: (T) => B)(implicit ct: ClassTag[B]): Array[B]
  108.  def map[B](f: (T) => B): collection.immutable.IndexedSeq[B]
  109.  def mapInPlace(f: (T) => T): Array[T]
  110.  def max[B >: A](implicit ord: math.Ordering[B]): T
  111.  def maxBy[B](f: (T) => B)(implicit cmp: math.Ordering[B]): T
  112.  def maxByOption[B](f: (T) => B)(implicit cmp: math.Ordering[B]): Option[T]
  113.  def maxOption[B >: A](implicit ord: math.Ordering[B]): Option[T]
  114.  def min[B >: A](implicit ord: math.Ordering[B]): T
  115.  def minBy[B](f: (T) => B)(implicit cmp: math.Ordering[B]): T
  116.  def minByOption[B](f: (T) => B)(implicit cmp: math.Ordering[B]): Option[T]
  117.  def minOption[B >: A](implicit ord: math.Ordering[B]): Option[T]
  118.  final def mkString: String
  119.  final def mkString(sep: String): String
  120.  final def mkString(start: String, sep: String, end: String): String
  121.  final def ne(arg0: AnyRef): Boolean
  122.  final def notify(): Unit
  123.  final def notifyAll(): Unit
  124.  def orElse[A1 <: A, B1 >: B](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
  125.  def padTo[B >: A](len: Int, elem: B)(implicit arg0: ClassTag[B]): Array[B]
  126.  def padTo[B >: A](len: Int, elem: B): collection.immutable.IndexedSeq[B]
  127.  def partitionMap[A1, A2](f: (T) => Either[A1, A2])(implicit arg0: ClassTag[A1], arg1: ClassTag[A2]): (Array[A1], Array[A2])
  128.  def partitionMap[A1, A2](f: (T) => Either[A1, A2]): (collection.immutable.IndexedSeq[A1], collection.immutable.IndexedSeq[A2])
  129.  def patch[B >: A](from: Int, other: collection.IterableOnce[B], replaced: Int)(implicit arg0: ClassTag[B]): Array[B]
  130.  def patch[B >: A](from: Int, other: collection.IterableOnce[B], replaced: Int): collection.immutable.IndexedSeq[B]
  131.  def prepended[B >: A](x: B)(implicit arg0: ClassTag[B]): Array[B]
  132.  def prepended[B >: A](elem: B): collection.immutable.IndexedSeq[B]
  133.  def prependedAll[B >: A](prefix: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]
  134.  def prependedAll[B >: A](prefix: collection.IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
  135.  def prependedAll[B >: A](prefix: collection.IterableOnce[B]): collection.immutable.IndexedSeq[B]
  136.  def product[B >: A](implicit num: math.Numeric[B]): B
  137.  def reduce[B >: A](op: (B, B) => B): B
  138.  def reduceLeft[B >: A](op: (B, T) => B): B
  139.  def reduceLeftOption[B >: A](op: (B, T) => B): Option[B]
  140.  def reduceOption[B >: A](op: (B, B) => B): Option[B]
  141.  def reduceRight[B >: A](op: (T, B) => B): B
  142.  def reduceRightOption[B >: A](op: (T, B) => B): Option[B]
  143.  def runWith[U](action: (T) => U): (Int) => Boolean
  144.  def sameElements[B >: A](o: collection.IterableOnce[B]): Boolean
  145.  def scan[B >: A](z: B)(op: (B, B) => B)(implicit arg0: ClassTag[B]): Array[B]
  146.  def scan[B >: A](z: B)(op: (B, B) => B): collection.immutable.IndexedSeq[B]
  147.  def scanLeft[B](z: B)(op: (B, T) => B)(implicit arg0: ClassTag[B]): Array[B]
  148.  def scanLeft[B](z: B)(op: (B, T) => B): collection.immutable.IndexedSeq[B]
  149.  def scanRight[B](z: B)(op: (T, B) => B)(implicit arg0: ClassTag[B]): Array[B]
  150.  def scanRight[B](z: B)(op: (T, B) => B): collection.immutable.IndexedSeq[B]
  151.  def search[B >: A](elem: B, from: Int, to: Int)(implicit ord: math.Ordering[B]): SearchResult
  152.  def search[B >: A](elem: B)(implicit ord: math.Ordering[B]): SearchResult
  153.  def segmentLength(p: (T) => Boolean, from: Int): Int
  154.  final def segmentLength(p: (T) => Boolean): Int
  155.  final def sizeCompare(that: collection.Iterable[_]): Int
  156.  def sliding(size: Int): collection.Iterator[collection.immutable.IndexedSeq[T]]
  157.  def sortBy[B](f: (T) => B)(implicit ord: math.Ordering[B]): Array[T]
  158.  def sortBy[B](f: (T) => B)(implicit ord: Ordering[B]): collection.immutable.IndexedSeq[T]
  159.  def sorted[B >: A](implicit ord: math.Ordering[B]): Array[T]
  160.  def sorted[B >: A](implicit ord: Ordering[B]): collection.immutable.IndexedSeq[T]
  161.  def startsWith[B >: A](that: collection.IterableOnce[B], offset: Int = 0): Boolean
  162.  def startsWith[B >: A](that: Array[B], offset: Int): Boolean
  163.  def startsWith[B >: A](that: Array[B]): Boolean
  164.  def startsWith[B >: A](that: collection.IterableOnce[B], offset: Int = 0): Boolean
  165.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[T, S]): S with EfficientSplit
  166.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[T, S]): S with EfficientSplit
  167.  def sum[B >: A](implicit num: math.Numeric[B]): B
  168.  final def synchronized[T0](arg0: => T0): T0
  169.  def tapEach[U](f: (T) => U): collection.immutable.IndexedSeq[T]
  170.  def to[C1](factory: Factory[T, C1]): C1
  171.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
  172.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
  173.  final def toBuffer[B >: A]: Buffer[B]
  174.  def toList: collection.immutable.List[T]
  175.  def toMap[K, V](implicit ev: <:<[T, (K, V)]): Map[K, V]
  176.  def toSet[B >: A]: Set[B]
  177.  def toString(): String
  178.  def toVector: collection.immutable.Vector[T]
  179.  def transpose[B](implicit asArray: (T) => Array[B]): Array[Array[B]]
  180.  def transpose[B](implicit asIterable: (T) => collection.Iterable[B]): collection.immutable.IndexedSeq[collection.immutable.IndexedSeq[B]]
  181.  def unapply(a: Int): Option[T]
  182.  def unzip[A1, A2](implicit asPair: (T) => (A1, A2), ct1: ClassTag[A1], ct2: ClassTag[A2]): (Array[A1], Array[A2])
  183.  def unzip[A1, A2](implicit asPair: (T) => (A1, A2)): (collection.immutable.IndexedSeq[A1], collection.immutable.IndexedSeq[A2])
  184.  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])
  185.  def unzip3[A1, A2, A3](implicit asTriple: (T) => (A1, A2, A3)): (collection.immutable.IndexedSeq[A1], collection.immutable.IndexedSeq[A2], collection.immutable.IndexedSeq[A3])
  186.  def update(i: Int, x: T): Unit
  187.  def updated[B >: A](index: Int, elem: B)(implicit arg0: ClassTag[B]): Array[B]
  188.  def updated[B >: A](index: Int, elem: B): collection.immutable.IndexedSeq[B]
  189.  final def wait(): Unit
  190.  final def wait(arg0: Long, arg1: Int): Unit
  191.  final def wait(arg0: Long): Unit
  192.  def zip[B](that: collection.IterableOnce[B]): Array[(T, B)]
  193.  def zip[B](that: collection.IterableOnce[B]): collection.immutable.IndexedSeq[(T, B)]
  194.  def zipAll[A1 >: A, B](that: collection.Iterable[B], thisElem: A1, thatElem: B): Array[(A1, B)]
  195.  def zipAll[A1 >: A, B](that: collection.Iterable[B], thisElem: A1, thatElem: B): collection.immutable.IndexedSeq[(A1, B)]
Shadowed Implicit Value Members
  1.  def apply(i: Int): T
  2.  def combinations(n: Int): collection.Iterator[Array[T]]
  3.  def combinations(n: Int): collection.Iterator[collection.immutable.IndexedSeq[T]]
  4.  def contains(elem: T): Boolean
  5.  def contains[A1 >: A](elem: A1): Boolean
  6.  def count(p: (T) => Boolean): Int
  7.  def count(p: (T) => Boolean): Int
  8.  def distinct: Array[T]
  9.  def distinct: collection.immutable.IndexedSeq[T]
  10.  def drop(n: Int): Array[T]
  11.  def drop(n: Int): collection.immutable.IndexedSeq[T]
  12.  def dropRight(n: Int): Array[T]
  13.  def dropRight(n: Int): collection.immutable.IndexedSeq[T]
  14.  def dropWhile(p: (T) => Boolean): Array[T]
  15.  def dropWhile(p: (T) => Boolean): collection.immutable.IndexedSeq[T]
  16.  def equals(o: Any): Boolean
  17.  def exists(p: (T) => Boolean): Boolean
  18.  def exists(p: (T) => Boolean): Boolean
  19.  def filter(p: (T) => Boolean): Array[T]
  20.  def filter(pred: (T) => Boolean): collection.immutable.IndexedSeq[T]
  21.  def filterNot(p: (T) => Boolean): Array[T]
  22.  def filterNot(pred: (T) => Boolean): collection.immutable.IndexedSeq[T]
  23.  def find(p: (T) => Boolean): Option[T]
  24.  def find(p: (T) => Boolean): Option[T]
  25.  def forall(p: (T) => Boolean): Boolean
  26.  def forall(p: (T) => Boolean): Boolean
  27.  def grouped(size: Int): collection.Iterator[Array[T]]
  28.  def grouped(size: Int): collection.Iterator[collection.immutable.IndexedSeq[T]]
  29.  def hashCode(): Int
  30.  def head: T
  31.  def head: T
  32.  def headOption: Option[T]
  33.  def headOption: Option[T]
  34.  def indexOf(elem: T, from: Int = 0): Int
  35.  def indexOf[B >: A](elem: B, from: Int): Int
  36.  def indexWhere(p: (T) => Boolean, from: Int = 0): Int
  37.  def indexWhere(p: (T) => Boolean, from: Int): Int
  38.  def indices: collection.immutable.Range
  39.  def indices: collection.immutable.Range
  40.  def init: Array[T]
  41.  def init: collection.immutable.IndexedSeq[T]
  42.  def inits: collection.Iterator[Array[T]]
  43.  def inits: collection.Iterator[collection.immutable.IndexedSeq[T]]
  44.  def isEmpty: Boolean
  45.  def isEmpty: Boolean
  46.  def iterator: collection.Iterator[T]
  47.  def iterator: collection.Iterator[T]
  48.  def knownSize: Int
  49.  def knownSize: Int
  50.  def last: T
  51.  def last: T
  52.  def lastIndexOf(elem: T, end: Int = xs.length - 1): Int
  53.  def lastIndexOf[B >: A](elem: B, end: Int = length - 1): Int
  54.  def lastIndexWhere(p: (T) => Boolean, end: Int = xs.length - 1): Int
  55.  def lastIndexWhere(p: (T) => Boolean, end: Int): Int
  56.  def lastOption: Option[T]
  57.  def lastOption: Option[T]
  58.  def length: Int
  59.  def lengthCompare(len: Int): Int
  60.  final def lengthCompare(len: Int): Int
  61.  def lengthIs: Int
  62.  final def lengthIs: SizeCompareOps
  63.  def nonEmpty: Boolean
  64.  def nonEmpty: Boolean
  65.  def partition(p: (T) => Boolean): (Array[T], Array[T])
  66.  def partition(p: (T) => Boolean): (collection.immutable.IndexedSeq[T], collection.immutable.IndexedSeq[T])
  67.  def permutations: collection.Iterator[Array[T]]
  68.  def permutations: collection.Iterator[collection.immutable.IndexedSeq[T]]
  69.  def reverse: Array[T]
  70.  def reverse: collection.immutable.IndexedSeq[T]
  71.  def reverseIterator: collection.Iterator[T]
  72.  def reverseIterator: collection.Iterator[T]
  73.  def size: Int
  74.  final def size: Int
  75.  def sizeCompare(otherSize: Int): Int
  76.  final def sizeCompare(otherSize: Int): Int
  77.  def sizeIs: Int
  78.  final def sizeIs: SizeCompareOps
  79.  def slice(from: Int, until: Int): Array[T]
  80.  def slice(from: Int, until: Int): collection.immutable.IndexedSeq[T]
  81.  def sliding(size: Int, step: Int = 1): collection.Iterator[Array[T]]
  82.  def sliding(size: Int, step: Int): collection.Iterator[collection.immutable.IndexedSeq[T]]
  83.  def sortWith(lt: (T, T) => Boolean): Array[T]
  84.  def sortWith(lt: (T, T) => Boolean): collection.immutable.IndexedSeq[T]
  85.  def span(p: (T) => Boolean): (Array[T], Array[T])
  86.  def span(p: (T) => Boolean): (collection.immutable.IndexedSeq[T], collection.immutable.IndexedSeq[T])
  87.  def splitAt(n: Int): (Array[T], Array[T])
  88.  def splitAt(n: Int): (collection.immutable.IndexedSeq[T], collection.immutable.IndexedSeq[T])
  89.  def tail: Array[T]
  90.  def tail: collection.immutable.IndexedSeq[T]
  91.  def tails: collection.Iterator[Array[T]]
  92.  def tails: collection.Iterator[collection.immutable.IndexedSeq[T]]
  93.  def take(n: Int): Array[T]
  94.  def take(n: Int): collection.immutable.IndexedSeq[T]
  95.  def takeRight(n: Int): Array[T]
  96.  def takeRight(n: Int): collection.immutable.IndexedSeq[T]
  97.  def takeWhile(p: (T) => Boolean): Array[T]
  98.  def takeWhile(p: (T) => Boolean): collection.immutable.IndexedSeq[T]
  99.  def toIndexedSeq: collection.immutable.IndexedSeq[T]
  100.  final def toIndexedSeq: collection.immutable.IndexedSeq[T]
  101.  final def toSeq: collection.immutable.Seq[T]
  102.  final def toSeq: collection.immutable.IndexedSeq[T]
  103.  def toString(): String
  104.  def view: IndexedSeqView[T]
  105.  def view: IndexedSeqView[T]
  106.  def withFilter(p: (T) => Boolean): WithFilter[T]
  107.  def withFilter(p: (T) => Boolean): WithFilter[T, [_]collection.immutable.IndexedSeq[_]]
  108.  def zipWithIndex: Array[(T, Int)]
  109.  def zipWithIndex: collection.immutable.IndexedSeq[(T, Int)]
Inherited by implicit conversion genericArrayOps fromArray[T] to ArrayOps[T] Inherited by implicit conversion copyArrayToImmutableIndexedSeq fromArray[T] to IndexedSeq[T]

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4