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

Scala Standard Library 2.12.15 - 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 formatted(fmtstr: String): String
63.  def genericBuilder[B]: Builder[B, IndexedSeq[B]]
64.  final def getClass(): Class[_]
65.  def groupBy[K](f: (Int) ⇒ K): Map[K, IndexedSeq[Int]]
66.  def grouped(size: Int): Iterator[IndexedSeq[Int]]
67.  def hasDefiniteSize: Boolean
68.  def hashCode(): Int
69.  def head: Int
70.  def headOption: Option[Int]
71.  def inclusive: Range
72.  def indexOf(elem: Int, from: Int): Int
73.  def indexOf(elem: Int): Int
74.  def indexOfSlice[B >: Int](that: GenSeq[B], from: Int): Int
75.  def indexOfSlice[B >: Int](that: GenSeq[B]): Int
76.  def indexWhere(p: (Int) ⇒ Boolean, from: Int): Int
77.  def indexWhere(p: (Int) ⇒ Boolean): Int
78.  def indices: Range
79.  final def init: Range
80.  def inits: Iterator[IndexedSeq[Int]]
81.  def intersect(that: collection.Seq[Int]): IndexedSeq[Int]
82.  def isDefinedAt(idx: Int): Boolean
83.  final val isEmpty: Boolean
84.  def isInclusive: Boolean
85.  final def isInstanceOf[T0]: Boolean
86.  final def isTraversableAgain: Boolean
87.  def iterator: Iterator[Int]
88.  def last: Int
89.  def lastIndexOf(elem: Int, end: Int): Int
90.  def lastIndexOf(elem: Int): Int
91.  def lastIndexOfSlice[B >: Int](that: GenSeq[B], end: Int): Int
92.  def lastIndexOfSlice[B >: Int](that: GenSeq[B]): Int
93.  def lastIndexWhere(p: (Int) ⇒ Boolean, end: Int): Int
94.  def lastIndexWhere(p: (Int) ⇒ Boolean): Int
95.  def lastOption: Option[Int]
96.  def length: Int
97.  def lengthCompare(len: Int): Int
98.  def lift: (Int) ⇒ Option[Int]
99.  def map[B](f: (A) ⇒ B): IndexedSeq[B]
100.  def max: A
101.  def maxBy[B](f: (A) ⇒ B): A
102.  def min: A
103.  def minBy[B](f: (A) ⇒ B): A
104.  def mkString: String
105.  def mkString(sep: String): String
106.  def mkString(start: String, sep: String, end: String): String
107.  final def ne(arg0: AnyRef): Boolean
108.  def newBuilder: Builder[Int, IndexedSeq[Int]]
109.  def nonEmpty: Boolean
110.  final def notify(): Unit
111.  final def notifyAll(): Unit
112.  def orElse[A1 <: Int, B1 >: Int](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
113.  def padTo(len: Int, elem: A): IndexedSeq[A]
114.  def par: ParRange
115.  def parCombiner: Combiner[Int, ParRange]
116.  def partition(p: (Int) ⇒ Boolean): (IndexedSeq[Int], IndexedSeq[Int])
117.  def patch(from: Int, that: GenSeq[A], replaced: Int): IndexedSeq[A]
118.  def permutations: Iterator[IndexedSeq[Int]]
119.  def prefixLength(p: (Int) ⇒ Boolean): Int
120.  def product: A
121.  def reduce[A1 >: Int](op: (A1, A1) ⇒ A1): A1
122.  def reduceLeft[B >: Int](op: (B, Int) ⇒ B): B
123.  def reduceLeftOption[B >: Int](op: (B, Int) ⇒ B): Option[B]
124.  def reduceOption[A1 >: Int](op: (A1, A1) ⇒ A1): Option[A1]
125.  def reduceRight[B >: Int](op: (Int, B) ⇒ B): B
126.  def reduceRightOption[B >: Int](op: (Int, B) ⇒ B): Option[B]
127.  def repr: IndexedSeq[Int]
128.  final def reverse: Range
129.  def reverseIterator: Iterator[Int]
130.  def reverseMap[B](f: (A) ⇒ B): IndexedSeq[B]
131.  def reversed: scala.List[Int]
132.  def runWith[U](action: (Int) ⇒ U): (Int) ⇒ Boolean
133.  def sameElements(that: GenIterable[A]): Boolean
134.  def scan[B >: Int, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[IndexedSeq[Int], B, That]): That
135.  def scanLeft[B, That](z: B)(op: (B, Int) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeq[Int], B, That]): That
136.  def scanRight[B, That](z: B)(op: (Int, B) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeq[Int], B, That]): That
137.  def segmentLength(p: (Int) ⇒ Boolean, from: Int): Int
138.  def seq: IndexedSeq[Int]
139.  def size: Int
140.  def sizeHintIfCheap: Int
141.  def slice(from: Int, until: Int): Range
142.  def sliding(size: Int, step: Int): Iterator[IndexedSeq[Int]]
143.  def sliding(size: Int): Iterator[IndexedSeq[Int]]
144.  def sortBy[B](f: (Int) ⇒ B)(implicit ord: math.Ordering[B]): IndexedSeq[Int]
145.  def sortWith(lt: (Int, Int) ⇒ Boolean): IndexedSeq[Int]
146.  def sorted[B >: Int](implicit ord: math.Ordering[B]): IndexedSeq[Int]
147.  final def span(p: (Int) ⇒ Boolean): (Range, Range)
148.  final def splitAt(n: Int): (Range, Range)
149.  val start: Int
150.  def startsWith[B](that: GenSeq[B], offset: Int): Boolean
151.  def startsWith[B](that: GenSeq[B]): Boolean
152.  val step: Int
153.  def stringPrefix: String
154.  final def sum: A
155.  final def synchronized[T0](arg0: ⇒ T0): T0
156.  final def tail: Range
157.  def tails: Iterator[IndexedSeq[Int]]
158.  final def take(n: Int): Range
159.  final def takeRight(n: Int): Range
160.  final def takeWhile(p: (Int) ⇒ Boolean): Range
161.  def thisCollection: collection.IndexedSeq[Int]
162.  def to[Col[_]]: Col[A]
163.  def toArray: Array[A]
164.  def toBuffer[A1 >: Int]: Buffer[A1]
165.  def toCollection(repr: IndexedSeq[Int]): collection.IndexedSeq[Int]
166.  def toIndexedSeq: IndexedSeq[Int]
167.  def toIterable: Range
168.  def toIterator: Iterator[Int]
169.  def toList: scala.List[Int]
170.  def toMap[T, U]: collection.Map[T, U]
171.  def toParArray: ParArray[T]
172.  def toSeq: Range
173.  def toSet[B >: Int]: Set[B]
174.  def toStream: Stream[Int]
175.  def toString(): String
176.  def toTraversable: collection.Traversable[Int]
177.  def toVector: scala.Vector[Int]
178.  def transpose[B](implicit asTraversable: (Int) ⇒ GenTraversableOnce[B]): IndexedSeq[IndexedSeq[B]]
179.  def union(that: collection.Seq[Int]): IndexedSeq[Int]
180.  def unzip[A1, A2](implicit asPair: (Int) ⇒ (A1, A2)): (IndexedSeq[A1], IndexedSeq[A2])
181.  def unzip3[A1, A2, A3](implicit asTriple: (Int) ⇒ (A1, A2, A3)): (IndexedSeq[A1], IndexedSeq[A2], IndexedSeq[A3])
182.  def updated(index: Int, elem: A): IndexedSeq[A]
183.  def view(from: Int, until: Int): SeqView[Int, IndexedSeq[Int]]
184.  def view: SeqView[Int, IndexedSeq[Int]]
185.  final def wait(): Unit
186.  final def wait(arg0: Long, arg1: Int): Unit
187.  final def wait(arg0: Long): Unit
188.  def withFilter(p: (Int) ⇒ Boolean): FilterMonadic[Int, IndexedSeq[Int]]
189.  def zip[B](that: GenIterable[B]): IndexedSeq[(A, B)]
190.  def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): IndexedSeq[(A, B)]
191.  def zipWithIndex: IndexedSeq[(A, Int)]
192.  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

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