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.5/scala/Array.html below:

Scala Standard Library 2.13.5 - 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.  def formatted(fmtstr: String): String
  83.  final def getClass(): Class[_ <: AnyRef]
  84.  def groupBy[K](f: (T) => K): Map[K, Array[T]]
  85.  def groupBy[K](f: (T) => K): Map[K, collection.immutable.IndexedSeq[T]]
  86.  def groupMap[K, B](key: (T) => K)(f: (T) => B)(implicit arg0: ClassTag[B]): Map[K, Array[B]]
  87.  def groupMap[K, B](key: (T) => K)(f: (T) => B): Map[K, collection.immutable.IndexedSeq[B]]
  88.  def groupMapReduce[K, B](key: (T) => K)(f: (T) => B)(reduce: (B, B) => B): Map[K, B]
  89.  def hashCode(): Int
  90.  def indexOf[B >: A](elem: B): Int
  91.  def indexOfSlice[B >: A](that: collection.Seq[B]): Int
  92.  def indexOfSlice[B >: A](that: collection.Seq[B], from: Int): Int
  93.  def indexWhere(p: (T) => Boolean): Int
  94.  def intersect[B >: A](that: collection.Seq[B]): Array[T]
  95.  def intersect[B >: A](that: collection.Seq[B]): collection.immutable.IndexedSeq[T]
  96.  def isDefinedAt(idx: Int): Boolean
  97.  final def isInstanceOf[T0]: Boolean
  98.  def isTraversableAgain: Boolean
  99.  def iterableFactory: SeqFactory[collection.immutable.IndexedSeq]
  100.  def lastIndexOfSlice[B >: A](that: collection.Seq[B]): Int
  101.  def lastIndexOfSlice[B >: A](that: collection.Seq[B], end: Int): Int
  102.  def lastIndexWhere(p: (T) => Boolean): Int
  103.  def lazyZip[B](that: collection.Iterable[B]): LazyZip2[T, B, Array[T]]
  104.  def lazyZip[B]: ([B](that: Iterable[B]): scala.collection.LazyZip2[T,B,_1.type]) forSome {val _1: collection.immutable.IndexedSeq[T]}
  105.  def length: Int
  106.  final def lengthCompare(that: collection.Iterable[_]): Int
  107.  def lift: (Int) => Option[T]
  108.  def map[B](f: (T) => B)(implicit ct: ClassTag[B]): Array[B]
  109.  def map[B](f: (T) => B): collection.immutable.IndexedSeq[B]
  110.  def mapInPlace(f: (T) => T): Array[T]
  111.  def max[B >: A](implicit ord: math.Ordering[B]): T
  112.  def maxBy[B](f: (T) => B)(implicit cmp: math.Ordering[B]): T
  113.  def maxByOption[B](f: (T) => B)(implicit cmp: math.Ordering[B]): Option[T]
  114.  def maxOption[B >: A](implicit ord: math.Ordering[B]): Option[T]
  115.  def min[B >: A](implicit ord: math.Ordering[B]): T
  116.  def minBy[B](f: (T) => B)(implicit cmp: math.Ordering[B]): T
  117.  def minByOption[B](f: (T) => B)(implicit cmp: math.Ordering[B]): Option[T]
  118.  def minOption[B >: A](implicit ord: math.Ordering[B]): Option[T]
  119.  final def mkString: String
  120.  final def mkString(sep: String): String
  121.  final def mkString(start: String, sep: String, end: String): String
  122.  final def ne(arg0: AnyRef): Boolean
  123.  final def notify(): Unit
  124.  final def notifyAll(): Unit
  125.  def orElse[A1 <: A, B1 >: B](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
  126.  def padTo[B >: A](len: Int, elem: B)(implicit arg0: ClassTag[B]): Array[B]
  127.  def padTo[B >: A](len: Int, elem: B): collection.immutable.IndexedSeq[B]
  128.  def partitionMap[A1, A2](f: (T) => Either[A1, A2])(implicit arg0: ClassTag[A1], arg1: ClassTag[A2]): (Array[A1], Array[A2])
  129.  def partitionMap[A1, A2](f: (T) => Either[A1, A2]): (collection.immutable.IndexedSeq[A1], collection.immutable.IndexedSeq[A2])
  130.  def patch[B >: A](from: Int, other: collection.IterableOnce[B], replaced: Int)(implicit arg0: ClassTag[B]): Array[B]
  131.  def patch[B >: A](from: Int, other: collection.IterableOnce[B], replaced: Int): collection.immutable.IndexedSeq[B]
  132.  def prepended[B >: A](x: B)(implicit arg0: ClassTag[B]): Array[B]
  133.  def prepended[B >: A](elem: B): collection.immutable.IndexedSeq[B]
  134.  def prependedAll[B >: A](prefix: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]
  135.  def prependedAll[B >: A](prefix: collection.IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
  136.  def prependedAll[B >: A](prefix: collection.IterableOnce[B]): collection.immutable.IndexedSeq[B]
  137.  def product[B >: A](implicit num: math.Numeric[B]): B
  138.  def reduce[B >: A](op: (B, B) => B): B
  139.  def reduceLeft[B >: A](op: (B, T) => B): B
  140.  def reduceLeftOption[B >: A](op: (B, T) => B): Option[B]
  141.  def reduceOption[B >: A](op: (B, B) => B): Option[B]
  142.  def reduceRight[B >: A](op: (T, B) => B): B
  143.  def reduceRightOption[B >: A](op: (T, B) => B): Option[B]
  144.  def runWith[U](action: (T) => U): (Int) => Boolean
  145.  def sameElements[B >: A](o: collection.IterableOnce[B]): Boolean
  146.  def scan[B >: A](z: B)(op: (B, B) => B)(implicit arg0: ClassTag[B]): Array[B]
  147.  def scan[B >: A](z: B)(op: (B, B) => B): collection.immutable.IndexedSeq[B]
  148.  def scanLeft[B](z: B)(op: (B, T) => B)(implicit arg0: ClassTag[B]): Array[B]
  149.  def scanLeft[B](z: B)(op: (B, T) => B): collection.immutable.IndexedSeq[B]
  150.  def scanRight[B](z: B)(op: (T, B) => B)(implicit arg0: ClassTag[B]): Array[B]
  151.  def scanRight[B](z: B)(op: (T, B) => B): collection.immutable.IndexedSeq[B]
  152.  def search[B >: A](elem: B, from: Int, to: Int)(implicit ord: math.Ordering[B]): SearchResult
  153.  def search[B >: A](elem: B)(implicit ord: math.Ordering[B]): SearchResult
  154.  def segmentLength(p: (T) => Boolean, from: Int): Int
  155.  final def segmentLength(p: (T) => Boolean): Int
  156.  final def sizeCompare(that: collection.Iterable[_]): Int
  157.  def sliding(size: Int): collection.Iterator[collection.immutable.IndexedSeq[T]]
  158.  def sortBy[B](f: (T) => B)(implicit ord: math.Ordering[B]): Array[T]
  159.  def sortBy[B](f: (T) => B)(implicit ord: Ordering[B]): collection.immutable.IndexedSeq[T]
  160.  def sorted[B >: A](implicit ord: math.Ordering[B]): Array[T]
  161.  def sorted[B >: A](implicit ord: Ordering[B]): collection.immutable.IndexedSeq[T]
  162.  def startsWith[B >: A](that: collection.IterableOnce[B], offset: Int = 0): Boolean
  163.  def startsWith[B >: A](that: Array[B], offset: Int): Boolean
  164.  def startsWith[B >: A](that: Array[B]): Boolean
  165.  def startsWith[B >: A](that: collection.IterableOnce[B], offset: Int = 0): Boolean
  166.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[T, S]): S with EfficientSplit
  167.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[T, S]): S with EfficientSplit
  168.  def sum[B >: A](implicit num: math.Numeric[B]): B
  169.  final def synchronized[T0](arg0: => T0): T0
  170.  def tapEach[U](f: (T) => U): collection.immutable.IndexedSeq[T]
  171.  def to[C1](factory: Factory[T, C1]): C1
  172.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
  173.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
  174.  final def toBuffer[B >: A]: Buffer[B]
  175.  final def toIterable: collection.immutable.IndexedSeq[T]
  176.  def toList: collection.immutable.List[T]
  177.  def toMap[K, V](implicit ev: <:<[T, (K, V)]): Map[K, V]
  178.  def toSet[B >: A]: Set[B]
  179.  def toString(): String
  180.  def toVector: collection.immutable.Vector[T]
  181.  def transpose[B](implicit asArray: (T) => Array[B]): Array[Array[B]]
  182.  def transpose[B](implicit asIterable: (T) => collection.Iterable[B]): collection.immutable.IndexedSeq[collection.immutable.IndexedSeq[B]]
  183.  def unapply(a: Int): Option[T]
  184.  def unzip[A1, A2](implicit asPair: (T) => (A1, A2), ct1: ClassTag[A1], ct2: ClassTag[A2]): (Array[A1], Array[A2])
  185.  def unzip[A1, A2](implicit asPair: (T) => (A1, A2)): (collection.immutable.IndexedSeq[A1], collection.immutable.IndexedSeq[A2])
  186.  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])
  187.  def unzip3[A1, A2, A3](implicit asTriple: (T) => (A1, A2, A3)): (collection.immutable.IndexedSeq[A1], collection.immutable.IndexedSeq[A2], collection.immutable.IndexedSeq[A3])
  188.  def update(i: Int, x: T): Unit
  189.  def updated[B >: A](index: Int, elem: B)(implicit arg0: ClassTag[B]): Array[B]
  190.  def updated[B >: A](index: Int, elem: B): collection.immutable.IndexedSeq[B]
  191.  final def wait(): Unit
  192.  final def wait(arg0: Long, arg1: Int): Unit
  193.  final def wait(arg0: Long): Unit
  194.  def zip[B](that: collection.IterableOnce[B]): Array[(T, B)]
  195.  def zip[B](that: collection.IterableOnce[B]): collection.immutable.IndexedSeq[(T, B)]
  196.  def zipAll[A1 >: A, B](that: collection.Iterable[B], thisElem: A1, thatElem: B): Array[(A1, B)]
  197.  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