Abstract Value Members
-
abstract
def
apply(t: T): Int
-
abstract
def
iterator: Iterator[T]
-
abstract
def
pairs: Iterator[(T, Int)]
-
abstract
def
unapply(i: Int): Option[T]
Concrete Value Members
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
-
def
++:[B >: T, That](that: Traversable[B])(implicit bf: CanBuildFrom[Iterable[T], B, That]): That
-
-
def
/:[B](z: B)(op: (B, T) ⇒ B): B
-
def
:\[B](z: B)(op: (T, B) ⇒ B): B
-
final
def
==(arg0: Any): Boolean
-
def
addString(b: StringBuilder): StringBuilder
-
def
addString(b: StringBuilder, sep: String): StringBuilder
-
def
addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
-
def
aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B
-
def
andThen[A](g: (Int) ⇒ A): (T) ⇒ A
-
final
def
asInstanceOf[T0]: T0
-
def
canEqual(that: Any): Boolean
-
def
clone(): AnyRef
-
-
-
-
def
compose[A](g: (A) ⇒ T): (A) ⇒ Int
-
def
contains(t: T): Boolean
-
def
copyToArray[B >: T](xs: Array[B], start: Int, len: Int): Unit
-
def
copyToArray[B >: T](xs: Array[B]): Unit
-
def
copyToArray[B >: T](xs: Array[B], start: Int): Unit
-
def
copyToBuffer[B >: T](dest: Buffer[B]): Unit
-
def
count(p: (T) ⇒ Boolean): Int
-
lazy val
defaultHashCode: Int
-
-
def
dropRight(n: Int): Iterable[T]
-
-
-
def
equals(other: Any): Boolean
-
-
-
-
def
finalize(): Unit
-
-
-
def
flatten[B](implicit asTraversable: (T) ⇒ GenTraversableOnce[B]): Iterable[B]
-
def
fold[A1 >: T](z: A1)(op: (A1, A1) ⇒ A1): A1
-
def
foldLeft[B](z: B)(op: (B, T) ⇒ B): B
-
def
foldRight[B](z: B)(op: (T, B) ⇒ B): B
-
-
def
foreach[U](f: (T) ⇒ U): Unit
-
def
genericBuilder[B]: Builder[B, Iterable[B]]
-
def
get(i: Int): T
-
final
def
getClass(): Class[_]
-
def
groupBy[K](f: (T) ⇒ K): Map[K, Iterable[T]]
-
-
def
hasDefiniteSize: Boolean
-
def
hashCode(): Int
-
def
head: T
-
def
headOption: Option[T]
-
def
indexOf(t: T): Int
-
def
indexOpt(t: T): Option[Int]
-
-
-
-
final
def
isInstanceOf[T0]: Boolean
-
final
def
isTraversableAgain: Boolean
-
def
last: T
-
def
lastOption: Option[T]
-
def
map[B, That](f: (T) ⇒ B)(implicit bf: CanBuildFrom[Iterable[T], B, That]): That
-
def
max[B >: T](implicit cmp: Ordering[B]): T
-
def
maxBy[B](f: (T) ⇒ B)(implicit cmp: Ordering[B]): T
-
def
min[B >: T](implicit cmp: Ordering[B]): T
-
def
minBy[B](f: (T) ⇒ B)(implicit cmp: Ordering[B]): T
-
def
mkString: String
-
def
mkString(sep: String): String
-
def
mkString(start: String, sep: String, end: String): String
-
-
-
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
-
def
parCombiner: Combiner[T, ParIterable[T]]
-
-
def
product[B >: T](implicit num: Numeric[B]): B
-
def
reduce[A1 >: T](op: (A1, A1) ⇒ A1): A1
-
def
reduceLeft[B >: T](op: (B, T) ⇒ B): B
-
def
reduceLeftOption[B >: T](op: (B, T) ⇒ B): Option[B]
-
def
reduceOption[A1 >: T](op: (A1, A1) ⇒ A1): Option[A1]
-
def
reduceRight[B >: T](op: (T, B) ⇒ B): B
-
def
reduceRightOption[B >: T](op: (T, B) ⇒ B): Option[B]
-
-
def
reversed: List[T]
-
def
sameElements[B >: T](that: GenIterable[B]): Boolean
-
def
scan[B >: T, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Iterable[T], B, That]): That
-
def
scanLeft[B, That](z: B)(op: (B, T) ⇒ B)(implicit bf: CanBuildFrom[Iterable[T], B, That]): That
-
def
scanRight[B, That](z: B)(op: (T, B) ⇒ B)(implicit bf: CanBuildFrom[Iterable[T], B, That]): That
-
-
def
size: Int
-
def
slice(from: Int, until: Int): Iterable[T]
-
-
-
-
-
def
stringPrefix: String
-
def
sum[B >: T](implicit num: Numeric[B]): B
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
-
-
-
def
takeRight(n: Int): Iterable[T]
-
-
def
thisCollection: Iterable[T]
-
def
to[Col[_]](implicit cbf: CanBuildFrom[Nothing, T, Col[T]]): Col[T]
-
def
toArray[B >: T](implicit arg0: ClassTag[B]): Array[B]
-
def
toBuffer[B >: T]: Buffer[B]
-
-
def
toIndexedSeq: IndexedSeq[T]
-
def
toIterable: Iterable[T]
-
def
toIterator: Iterator[T]
-
def
toList: List[T]
-
def
toMap[T, U](implicit ev: <:<[T, (T, U)]): Map[T, U]
-
def
toSeq: Seq[T]
-
def
toSet[B >: T]: Set[B]
-
def
toStream: Stream[T]
-
def
toString(): String
-
-
def
toVector: Vector[T]
-
-
def
unzip[A1, A2](implicit asPair: (T) ⇒ (A1, A2)): (Iterable[A1], Iterable[A2])
-
def
unzip3[A1, A2, A3](implicit asTriple: (T) ⇒ (A1, A2, A3)): (Iterable[A1], Iterable[A2], Iterable[A3])
-
-
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
-
-
def
zip[A1 >: T, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[Iterable[T], (A1, B), That]): That
-
def
zipAll[B, A1 >: T, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[Iterable[T], (A1, B), That]): That
-
def
zipWithIndex[A1 >: T, That](implicit bf: CanBuildFrom[Iterable[T], (A1, Int), That]): That
-
Inherited from Serializable
Inherited from HasNewBuilder[T, Iterable[T] @scala.annotation.unchecked.uncheckedVariance]
Trait that marks an O(1) bidirectional map between Ints (increasing from 0) and T's. This class is used, for example, to efficiently build unique vector space mappings for strings. The methods in this trait do not mutate the underlying index. Use either a MutableIndex or one of the companion object constructor methods to build an index.