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

Showing content from http://www.scala-lang.org/api/2.12.19/scala/collection/immutable/StreamViewLike$Transformed.html below:

Scala Standard Library 2.12.19 - scala.collection.immutable.StreamViewLike.Transformed

 

1. Alphabetic
2. By Inheritance

1. Transformed
2. Transformed
3. Transformed
4. Transformed
5. StreamView
6. StreamViewLike
7. SeqView
8. SeqViewLike
9. IterableView
10. IterableViewLike
11. TraversableView
12. TraversableViewLike
13. ViewMkString
14. Seq
15. SeqLike
16. GenSeq
17. GenSeqLike
18. Iterable
19. IterableLike
20. Equals
21. GenIterable
22. GenIterableLike
23. Traversable
24. GenTraversable
25. GenericTraversableTemplate
26. TraversableLike
27. GenTraversableLike
28. Parallelizable
29. TraversableOnce
30. GenTraversableOnce
31. FilterMonadic
32. HasNewBuilder
33. PartialFunction
34. Function1
35. AnyRef
36. 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): B
2.  abstract def iterator: Iterator[B]
3.  abstract def length: Int

1.  final def !=(arg0: Any): Boolean
2.  final def ##(): Int
3.  def +(other: String): String
4.  def ++[B >: B, That](xs: GenTraversableOnce[B])(implicit bf: CanBuildFrom[StreamView[B, Coll], B, That]): That
5.  def ++:[B >: B, That](xs: collection.Traversable[B])(implicit bf: CanBuildFrom[StreamView[B, Coll], B, That]): That
6.  def ++:[B](that: TraversableOnce[B]): Seq[B]
7.  def +:(elem: A): Seq[A]
8.  def ->[B](y: B): (Transformed[B], B)
9.  def :+(elem: A): Seq[A]
10.  final def ==(arg0: Any): Boolean
11.  def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
12.  def addString(b: StringBuilder): StringBuilder
13.  def addString(b: StringBuilder, sep: String): StringBuilder
14.  def aggregate[B](z: ⇒ B)(seqop: (B, B) ⇒ B, combop: (B, B) ⇒ B): B
15.  def andThen[C](k: (B) ⇒ C): PartialFunction[Int, C]
16.  def applyOrElse[A1 <: Int, B1 >: B](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[B, B]): Option[B]
22.  def combinations(n: Int): Iterator[StreamView[B, Coll]]
23.  def companion: GenericCompanion[collection.Seq]
24.  def compose[A](g: (A) ⇒ Int): (A) ⇒ B
25.  def contains[A1 >: B](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 >: B](dest: Buffer[B]): Unit
31.  def corresponds[B](that: GenSeq[B])(p: (B, B) ⇒ Boolean): Boolean
32.  def count(p: (B) ⇒ Boolean): Int
33.  def diff(that: collection.Seq[A]): Seq[A]
34.  def distinct: StreamView[B, Coll]
35.  def drop(n: Int): StreamView[B, Coll]
36.  def dropRight(n: Int): StreamView[B, Coll]
37.  def dropWhile(p: (B) ⇒ Boolean): StreamView[B, Coll]
38.  def endsWith[B](that: GenSeq[B]): Boolean
39.  def ensuring(cond: (Transformed[B]) ⇒ Boolean, msg: ⇒ Any): Transformed[B]
40.  def ensuring(cond: (Transformed[B]) ⇒ Boolean): Transformed[B]
41.  def ensuring(cond: Boolean, msg: ⇒ Any): Transformed[B]
42.  def ensuring(cond: Boolean): Transformed[B]
43.  final def eq(arg0: AnyRef): Boolean
44.  def equals(that: Any): Boolean
45.  def exists(p: (B) ⇒ Boolean): Boolean
46.  def filter(p: (B) ⇒ Boolean): StreamView[B, Coll]
47.  def filterNot(p: (B) ⇒ Boolean): StreamView[B, Coll]
48.  def finalize(): Unit
49.  def find(p: (B) ⇒ Boolean): Option[B]
50.  def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Seq[B]
51.  def flatten[B]: Seq[B]
52.  def fold[A1 >: B](z: A1)(op: (A1, A1) ⇒ A1): A1
53.  def foldLeft[B](z: B)(op: (B, B) ⇒ B): B
54.  def foldRight[B](z: B)(op: (B, B) ⇒ B): B
55.  def forall(p: (B) ⇒ Boolean): Boolean
56.  def force[B >: B, That](implicit bf: CanBuildFrom[Coll, B, That]): That
57.  def foreach(f: (A) ⇒ Unit): Unit
58.  def genericBuilder[B]: Builder[B, collection.Seq[B]]
59.  final def getClass(): Class[_]
60.  def groupBy[K](f: (B) ⇒ K): Map[K, StreamView[B, Coll]]
61.  def grouped(size: Int): Iterator[StreamView[B, Coll]]
62.  def hasDefiniteSize: Boolean
63.  def hashCode(): Int
64.  def head: B
65.  def headOption: Option[B]
66.  def indexOf(elem: B, from: Int): Int
67.  def indexOf(elem: B): Int
68.  def indexOfSlice[B >: B](that: GenSeq[B], from: Int): Int
69.  def indexOfSlice[B >: B](that: GenSeq[B]): Int
70.  def indexWhere(p: (B) ⇒ Boolean, from: Int): Int
71.  def indexWhere(p: (B) ⇒ Boolean): Int
72.  def indices: Range
73.  def init: StreamView[B, Coll]
74.  def inits: Iterator[StreamView[B, Coll]]
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: B
81.  def lastIndexOf(elem: B, end: Int): Int
82.  def lastIndexOf(elem: B): Int
83.  def lastIndexOfSlice[B >: B](that: GenSeq[B], end: Int): Int
84.  def lastIndexOfSlice[B >: B](that: GenSeq[B]): Int
85.  def lastIndexWhere(p: (B) ⇒ Boolean, end: Int): Int
86.  def lastIndexWhere(p: (B) ⇒ Boolean): Int
87.  def lastOption: Option[B]
88.  def lengthCompare(len: Int): Int
89.  def lift: (Int) ⇒ Option[B]
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(start: String, sep: String, end: String): String
96.  def mkString(sep: String): String
97.  def mkString: String
98.  final def ne(arg0: AnyRef): Boolean
99.  def newAppended[B >: B](that: GenTraversable[B]): Transformed[B]
100.  def newBuilder: Builder[B, StreamView[B, Coll]]
101.  def newDropped(n: Int): Transformed.Transformed[B]
102.  def newDroppedWhile(p: (B) ⇒ Boolean): Transformed[B]
103.  def newFiltered(p: (B) ⇒ Boolean): Transformed[B]
104.  def newFlatMapped[B](f: (B) ⇒ GenTraversableOnce[B]): Transformed[B]
105.  def newForced[B](xs: ⇒ GenSeq[B]): Transformed[B]
106.  def newMapped[B](f: (B) ⇒ B): Transformed[B]
107.  def newPatched[B >: B](_from: Int, _patch: GenSeq[B], _replaced: Int): Transformed[B]
108.  def newPrepended[B >: B](that: GenTraversable[B]): Transformed[B]
109.  def newReversed: Transformed[B]
110.  def newSliced(_endpoints: SliceInterval): Transformed[B]
111.  def newTaken(n: Int): Transformed.Transformed[B]
112.  def newTakenWhile(p: (B) ⇒ Boolean): Transformed[B]
113.  def newZipped[B](that: GenIterable[B]): Transformed[(B, B)]
114.  def newZippedAll[A1 >: B, B](that: GenIterable[B], _thisElem: A1, _thatElem: B): Transformed[(A1, B)]
115.  def nonEmpty: Boolean
116.  final def notify(): Unit
117.  final def notifyAll(): Unit
118.  def orElse[A1 <: Int, B1 >: B](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
119.  def padTo(len: Int, elem: A): Seq[A]
120.  def par: ParSeq[B]
121.  def parCombiner: Combiner[B, ParSeq[B]]
122.  def partition(p: (B) ⇒ Boolean): (StreamView[B, Coll], StreamView[B, Coll])
123.  def patch(from: Int, that: GenSeq[A], replaced: Int): Seq[A]
124.  def permutations: Iterator[StreamView[B, Coll]]
125.  def prefixLength(p: (B) ⇒ Boolean): Int
126.  def product: A
127.  def reduce[A1 >: B](op: (A1, A1) ⇒ A1): A1
128.  def reduceLeft[B >: B](op: (B, B) ⇒ B): B
129.  def reduceLeftOption[B >: B](op: (B, B) ⇒ B): Option[B]
130.  def reduceOption[A1 >: B](op: (A1, A1) ⇒ A1): Option[A1]
131.  def reduceRight[B >: B](op: (B, B) ⇒ B): B
132.  def reduceRightOption[B >: B](op: (B, B) ⇒ B): Option[B]
133.  def repr: StreamView[B, Coll]
134.  def reverse: StreamView[B, Coll]
135.  def reverseIterator: Iterator[B]
136.  def reverseMap[B](f: (A) ⇒ B): Seq[B]
137.  def reversed: scala.List[B]
138.  def runWith[U](action: (B) ⇒ U): (Int) ⇒ Boolean
139.  def sameElements(that: GenIterable[A]): Boolean
140.  def scan[B >: B, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[StreamView[B, Coll], B, That]): That
141.  def scanLeft[B, That](z: B)(op: (B, B) ⇒ B)(implicit bf: CanBuildFrom[StreamView[B, Coll], B, That]): That
142.  def scanRight[B, That](z: B)(op: (B, B) ⇒ B)(implicit bf: CanBuildFrom[StreamView[B, Coll], B, That]): That
143.  def segmentLength(p: (B) ⇒ Boolean, from: Int): Int
144.  def seq: collection.Seq[B]
145.  def size: Int
146.  def sizeHintIfCheap: Int
147.  def slice(from: Int, until: Int): StreamView[B, Coll]
148.  def sliding(size: Int): Iterator[StreamView[B, Coll]]
149.  def sliding(size: Int, step: Int): Iterator[StreamView[B, Coll]]
150.  def sortBy[B](f: (B) ⇒ B)(implicit ord: Ordering[B]): StreamView[B, Coll]
151.  def sortWith(lt: (B, B) ⇒ Boolean): StreamView[B, Coll]
152.  def sorted[B >: B](implicit ord: Ordering[B]): StreamView[B, Coll]
153.  def span(p: (B) ⇒ Boolean): (StreamView[B, Coll], StreamView[B, Coll])
154.  def splitAt(n: Int): (StreamView[B, Coll], StreamView[B, Coll])
155.  def startsWith[B](that: GenSeq[B], offset: Int): Boolean
156.  def startsWith[B](that: GenSeq[B]): Boolean
157.  def stringPrefix: String
158.  def sum: A
159.  final def synchronized[T0](arg0: ⇒ T0): T0
160.  def tail: StreamView[B, Coll]
161.  def tails: Iterator[StreamView[B, Coll]]
162.  def take(n: Int): StreamView[B, Coll]
163.  def takeRight(n: Int): StreamView[B, Coll]
164.  def takeWhile(p: (B) ⇒ Boolean): StreamView[B, Coll]
165.  def thisCollection: collection.Seq[B]
166.  def thisSeq: collection.Seq[B]
167.  def to[Col[_]]: Col[A]
168.  def toArray: Array[A]
169.  def toBuffer[B >: B]: Buffer[B]
170.  def toCollection(repr: StreamView[B, Coll]): collection.Seq[B]
171.  def toIndexedSeq: IndexedSeq[B]
172.  def toIterable: collection.Iterable[B]
173.  def toIterator: Iterator[B]
174.  def toList: scala.List[B]
175.  def toMap[T, U]: collection.Map[T, U]
176.  def toParArray: ParArray[T]
177.  def toSeq: collection.Seq[B]
178.  def toSet[B >: B]: Set[B]
179.  def toStream: Stream[B]
180.  def toString(): String
181.  def toTraversable: collection.Traversable[B]
182.  def toVector: scala.Vector[B]
183.  def transpose[B](implicit asTraversable: (B) ⇒ GenTraversableOnce[B]): collection.Seq[collection.Seq[B]]
184.  lazy val underlying: Coll
185.  def union(that: collection.Seq[A]): Seq[A]
186.  def unzip[A1, A2](implicit asPair: (B) ⇒ (A1, A2)): (Transformed.Transformed[A1], Transformed.Transformed[A2])
187.  def unzip3[A1, A2, A3](implicit asTriple: (B) ⇒ (A1, A2, A3)): (Transformed.Transformed[A1], Transformed.Transformed[A2], Transformed.Transformed[A3])
188.  def updated(index: Int, elem: A): Seq[A]
189.  def view(from: Int, until: Int): SeqView[B, StreamView[B, Coll]]
190.  def view: SeqView[B, StreamView[B, Coll]]
191.  final def viewIdString: String
192.  def viewIdentifier: String
193.  def viewToString: String
194.  final def wait(): Unit
195.  final def wait(arg0: Long, arg1: Int): Unit
196.  final def wait(arg0: Long): Unit
197.  def withFilter(p: (B) ⇒ Boolean): StreamView[B, Coll]
198.  def zip[B](that: GenIterable[B]): Seq[(A, B)]
199.  def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Seq[(A, B)]
200.  def zipWithIndex: Seq[(A, Int)]
201.  def →[B](y: B): (Transformed[B], B)

1.  def /:[B](z: B)(op: (B, B) ⇒ B): B
2.  def :\[B](z: B)(op: (B, B) ⇒ B): B
3.  def formatted(fmtstr: String): String

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