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

Showing content from http://www.scala-lang.org/api/2.12.15/scala/collection/immutable/Seq.html below:

Scala Standard Library 2.12.15 - scala.collection.immutable.Seq

 

1. Alphabetic
2. By Inheritance

1. Seq
2. Seq
3. SeqLike
4. GenSeq
5. GenSeqLike
6. PartialFunction
7. Function1
8. Iterable
9. Iterable
10. IterableLike
11. Equals
12. GenIterable
13. GenIterableLike
14. Traversable
15. Immutable
16. Traversable
17. GenTraversable
18. GenericTraversableTemplate
19. TraversableLike
20. GenTraversableLike
21. Parallelizable
22. TraversableOnce
23. GenTraversableOnce
24. FilterMonadic
25. HasNewBuilder
26. AnyRef
27. Any

1. by CollectionsHaveToParArray
2. by MonadOps
3. by any2stringadd
4. by StringFormat
5. by Ensuring
6. by ArrowAssoc
7. by alternateImplicit

1.  abstract def apply(idx: Int): A
2.  abstract def iterator: Iterator[A]
3.  abstract def length: Int

1.  final def !=(arg0: Any): Boolean
2.  final def ##(): Int
3.  def +(other: String): String
4.  def ++[B >: A, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Seq[A], B, That]): That
5.  def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Seq[A], B, That]): That
6.  def ++:[B](that: TraversableOnce[B]): Seq[B]
7.  def +:(elem: A): Seq[A]
8.  def ->[B](y: B): (Seq[A], B)
9.  def :+(elem: A): Seq[A]
10.  final def ==(arg0: Any): Boolean
11.  def addString(b: StringBuilder): StringBuilder
12.  def addString(b: StringBuilder, sep: String): StringBuilder
13.  def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
14.  def aggregate[B](z: ⇒ B)(seqop: (B, A) ⇒ B, combop: (B, B) ⇒ B): B
15.  def andThen[C](k: (A) ⇒ C): PartialFunction[Int, C]
16.  def applyOrElse[A1 <: Int, B1 >: A](x: A1, default: (A1) ⇒ B1): B1
17.  final def asInstanceOf[T0]: T0
18.  def canEqual(that: Any): Boolean
19.  def clone(): AnyRef
20.  def collect[B](pf: PartialFunction[A, B]): Seq[B]
21.  def collectFirst[B](pf: PartialFunction[A, B]): Option[B]
22.  def combinations(n: Int): Iterator[Seq[A]]
23.  def companion: GenericCompanion[Seq]
24.  def compose[A](g: (A) ⇒ Int): (A) ⇒ A
25.  def contains[A1 >: A](elem: A1): Boolean
26.  def containsSlice[B](that: GenSeq[B]): Boolean
27.  def copyToArray(xs: Array[A], start: Int, len: Int): Unit
28.  def copyToArray(xs: Array[A]): Unit
29.  def copyToArray(xs: Array[A], start: Int): Unit
30.  def copyToBuffer[B >: A](dest: Buffer[B]): Unit
31.  def corresponds[B](that: GenSeq[B])(p: (A, B) ⇒ Boolean): Boolean
32.  def count(p: (A) ⇒ Boolean): Int
33.  def diff(that: collection.Seq[A]): Seq[A]
34.  def distinct: Seq[A]
35.  def drop(n: Int): Seq[A]
36.  def dropRight(n: Int): Seq[A]
37.  def dropWhile(p: (A) ⇒ Boolean): Seq[A]
38.  def endsWith[B](that: GenSeq[B]): Boolean
39.  def ensuring(cond: (Seq[A]) ⇒ Boolean, msg: ⇒ Any): Seq[A]
40.  def ensuring(cond: (Seq[A]) ⇒ Boolean): Seq[A]
41.  def ensuring(cond: Boolean, msg: ⇒ Any): Seq[A]
42.  def ensuring(cond: Boolean): Seq[A]
43.  final def eq(arg0: AnyRef): Boolean
44.  def equals(that: Any): Boolean
45.  def exists(p: (A) ⇒ Boolean): Boolean
46.  def filter(p: (A) ⇒ Boolean): Seq[A]
47.  def filterNot(p: (A) ⇒ Boolean): Seq[A]
48.  def finalize(): Unit
49.  def find(p: (A) ⇒ Boolean): Option[A]
50.  def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Seq[B]
51.  def flatten[B]: Seq[B]
52.  def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1
53.  def foldLeft[B](z: B)(op: (B, A) ⇒ B): B
54.  def foldRight[B](z: B)(op: (A, B) ⇒ B): B
55.  def forall(p: (A) ⇒ Boolean): Boolean
56.  def foreach(f: (A) ⇒ Unit): Unit
57.  def formatted(fmtstr: String): String
58.  def genericBuilder[B]: Builder[B, Seq[B]]
59.  final def getClass(): Class[_]
60.  def groupBy[K](f: (A) ⇒ K): Map[K, Seq[A]]
61.  def grouped(size: Int): Iterator[Seq[A]]
62.  def hasDefiniteSize: Boolean
63.  def hashCode(): Int
64.  def head: A
65.  def headOption: Option[A]
66.  def indexOf(elem: A, from: Int): Int
67.  def indexOf(elem: A): Int
68.  def indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int
69.  def indexOfSlice[B >: A](that: GenSeq[B]): Int
70.  def indexWhere(p: (A) ⇒ Boolean, from: Int): Int
71.  def indexWhere(p: (A) ⇒ Boolean): Int
72.  def indices: Range
73.  def init: Seq[A]
74.  def inits: Iterator[Seq[A]]
75.  def intersect(that: collection.Seq[A]): Seq[A]
76.  def isDefinedAt(idx: Int): Boolean
77.  def isEmpty: Boolean
78.  final def isInstanceOf[T0]: Boolean
79.  final def isTraversableAgain: Boolean
80.  def last: A
81.  def lastIndexOf(elem: A, end: Int): Int
82.  def lastIndexOf(elem: A): Int
83.  def lastIndexOfSlice[B >: A](that: GenSeq[B], end: Int): Int
84.  def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int
85.  def lastIndexWhere(p: (A) ⇒ Boolean, end: Int): Int
86.  def lastIndexWhere(p: (A) ⇒ Boolean): Int
87.  def lastOption: Option[A]
88.  def lengthCompare(len: Int): Int
89.  def lift: (Int) ⇒ Option[A]
90.  def map[B](f: (A) ⇒ B): Seq[B]
91.  def max: A
92.  def maxBy[B](f: (A) ⇒ B): A
93.  def min: A
94.  def minBy[B](f: (A) ⇒ B): A
95.  def mkString: String
96.  def mkString(sep: String): String
97.  def mkString(start: String, sep: String, end: String): String
98.  final def ne(arg0: AnyRef): Boolean
99.  def newBuilder: Builder[A, Seq[A]]
100.  def nonEmpty: Boolean
101.  final def notify(): Unit
102.  final def notifyAll(): Unit
103.  def orElse[A1 <: Int, B1 >: A](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
104.  def padTo(len: Int, elem: A): Seq[A]
105.  def par: ParSeq[A]
106.  def parCombiner: Combiner[A, ParSeq[A]]
107.  def partition(p: (A) ⇒ Boolean): (Seq[A], Seq[A])
108.  def patch(from: Int, that: GenSeq[A], replaced: Int): Seq[A]
109.  def permutations: Iterator[Seq[A]]
110.  def prefixLength(p: (A) ⇒ Boolean): Int
111.  def product: A
112.  def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
113.  def reduceLeft[B >: A](op: (B, A) ⇒ B): B
114.  def reduceLeftOption[B >: A](op: (B, A) ⇒ B): Option[B]
115.  def reduceOption[A1 >: A](op: (A1, A1) ⇒ A1): Option[A1]
116.  def reduceRight[B >: A](op: (A, B) ⇒ B): B
117.  def reduceRightOption[B >: A](op: (A, B) ⇒ B): Option[B]
118.  def repr: Seq[A]
119.  def reverse: Seq[A]
120.  def reverseIterator: Iterator[A]
121.  def reverseMap[B](f: (A) ⇒ B): Seq[B]
122.  def reversed: scala.List[A]
123.  def runWith[U](action: (A) ⇒ U): (Int) ⇒ Boolean
124.  def sameElements(that: GenIterable[A]): Boolean
125.  def scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Seq[A], B, That]): That
126.  def scanLeft[B, That](z: B)(op: (B, A) ⇒ B)(implicit bf: CanBuildFrom[Seq[A], B, That]): That
127.  def scanRight[B, That](z: B)(op: (A, B) ⇒ B)(implicit bf: CanBuildFrom[Seq[A], B, That]): That
128.  def segmentLength(p: (A) ⇒ Boolean, from: Int): Int
129.  def seq: Seq[A]
130.  def size: Int
131.  def sizeHintIfCheap: Int
132.  def slice(from: Int, until: Int): Seq[A]
133.  def sliding(size: Int, step: Int): Iterator[Seq[A]]
134.  def sliding(size: Int): Iterator[Seq[A]]
135.  def sortBy[B](f: (A) ⇒ B)(implicit ord: math.Ordering[B]): Seq[A]
136.  def sortWith(lt: (A, A) ⇒ Boolean): Seq[A]
137.  def sorted[B >: A](implicit ord: math.Ordering[B]): Seq[A]
138.  def span(p: (A) ⇒ Boolean): (Seq[A], Seq[A])
139.  def splitAt(n: Int): (Seq[A], Seq[A])
140.  def startsWith[B](that: GenSeq[B], offset: Int): Boolean
141.  def startsWith[B](that: GenSeq[B]): Boolean
142.  def stringPrefix: String
143.  def sum: A
144.  final def synchronized[T0](arg0: ⇒ T0): T0
145.  def tail: Seq[A]
146.  def tails: Iterator[Seq[A]]
147.  def take(n: Int): Seq[A]
148.  def takeRight(n: Int): Seq[A]
149.  def takeWhile(p: (A) ⇒ Boolean): Seq[A]
150.  def thisCollection: collection.Seq[A]
151.  def to[Col[_]]: Col[A]
152.  def toArray: Array[A]
153.  def toBuffer[B >: A]: Buffer[B]
154.  def toCollection(repr: Seq[A]): collection.Seq[A]
155.  def toIndexedSeq: IndexedSeq[A]
156.  def toIterable: collection.Iterable[A]
157.  def toIterator: Iterator[A]
158.  def toList: scala.List[A]
159.  def toMap[T, U]: collection.Map[T, U]
160.  def toParArray: ParArray[T]
161.  def toSeq: Seq[A]
162.  def toSet[B >: A]: Set[B]
163.  def toStream: Stream[A]
164.  def toString(): String
165.  def toTraversable: collection.Traversable[A]
166.  def toVector: scala.Vector[A]
167.  def transpose[B](implicit asTraversable: (A) ⇒ GenTraversableOnce[B]): Seq[Seq[B]]
168.  def union(that: collection.Seq[A]): Seq[A]
169.  def unzip[A1, A2](implicit asPair: (A) ⇒ (A1, A2)): (Seq[A1], Seq[A2])
170.  def unzip3[A1, A2, A3](implicit asTriple: (A) ⇒ (A1, A2, A3)): (Seq[A1], Seq[A2], Seq[A3])
171.  def updated(index: Int, elem: A): Seq[A]
172.  def view(from: Int, until: Int): SeqView[A, Seq[A]]
173.  def view: SeqView[A, Seq[A]]
174.  final def wait(): Unit
175.  final def wait(arg0: Long, arg1: Int): Unit
176.  final def wait(arg0: Long): Unit
177.  def withFilter(p: (A) ⇒ Boolean): FilterMonadic[A, Seq[A]]
178.  def zip[B](that: GenIterable[B]): Seq[(A, B)]
179.  def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Seq[(A, B)]
180.  def zipWithIndex: Seq[(A, Int)]
181.  def →[B](y: B): (Seq[A], B)

1.  def /:[B](z: B)(op: (B, A) ⇒ B): B
2.  def :\[B](z: B)(op: (A, B) ⇒ B): B

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