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/Range.html below:

Scala Standard Library 2.12.19 - scala.collection.immutable.Range

 

1. Alphabetic
2. By Inheritance

1. Range
2. Serializable
3. Serializable
4. CustomParallelizable
5. IndexedSeq
6. IndexedSeq
7. IndexedSeqLike
8. Seq
9. Iterable
10. Traversable
11. Immutable
12. AbstractSeq
13. Seq
14. SeqLike
15. GenSeq
16. GenSeqLike
17. PartialFunction
18. Function1
19. AbstractIterable
20. Iterable
21. IterableLike
22. Equals
23. GenIterable
24. GenIterableLike
25. AbstractTraversable
26. Traversable
27. GenTraversable
28. GenericTraversableTemplate
29. TraversableLike
30. GenTraversableLike
31. Parallelizable
32. TraversableOnce
33. GenTraversableOnce
34. FilterMonadic
35. HasNewBuilder
36. AnyRef
37. Any

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

1.  new Range(start: Int, end: Int, step: Int)

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

1.  def /:[B](z: B)(op: (B, Int) ⇒ B): B
2.  def :\[B](z: B)(op: (Int, 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