type AbstractMethodError = java.lang.AbstractMethodError
abstract class Any Class Any is the root of the Scala class hierarchy.
abstract class AnyVal extends Any AnyVal is the root class of all value types, which describe values not implemented as objects in the underlying host system.
trait App extends DelayedInit The App trait can be used to quickly turn objects into executable programs.
final class Array[T] extends java.io.Serializable with java.lang.Cloneable Arrays are mutable, indexed collections of values.
type ArrayIndexOutOfBoundsException = java.lang.ArrayIndexOutOfBoundsException
abstract final class Byte extends AnyVal Byte, a 8-bit signed integer (equivalent to Java's byte primitive type) is a subtype of scala.AnyVal.
abstract final class Char extends AnyVal Char, a 16-bit unsigned integer (equivalent to Java's char primitive type) is a subtype of scala.AnyVal.
type ClassCastException = java.lang.ClassCastException
trait Cloneable extends java.lang.Cloneable Classes extending this trait are cloneable across platforms (Java, .NET).
abstract final class Double extends AnyVal Double, a 64-bit IEEE-754 floating point number (equivalent to Java's double primitive type) is a subtype of scala.AnyVal.
trait Dynamic extends Any A marker trait that enables dynamic invocations.
class FallbackArrayBuilding extends AnyRef Contains a fallback builder for arrays when the element type does not have a class tag.
abstract final class Float extends AnyVal Float, a 32-bit IEEE-754 floating point number (equivalent to Java's float primitive type) is a subtype of scala.AnyVal.
abstract final class Long extends AnyVal Long, a 64-bit signed integer (equivalent to Java's long primitive type) is a subtype of scala.AnyVal.
final class MatchError extends RuntimeException This class implements errors which are thrown whenever an object doesn't match any pattern of a pattern matching expression.
trait Mutable extends AnyRef A marker trait for mutable data structures such as mutable collections
type NoSuchElementException = java.util.NoSuchElementException
final class NotImplementedError extends Error Throwing this exception can be a temporary replacement for a method body that remains to be implemented.
abstract final class Nothing extends Any Nothing is - together with scala.Null - at the bottom of Scala's type hierarchy.
abstract final class Null extends AnyRef Null is - together with scala.Nothing - at the bottom of the Scala type hierarchy.
type NullPointerException = java.lang.NullPointerException
type NumberFormatException = java.lang.NumberFormatException
trait PartialFunction[-A, +B] extends (A) ⇒ B A partial function of type PartialFunction[A, B] is a unary function where the domain does not necessarily include all values of type A.
trait Product3[+T1, +T2, +T3] extends Product Product3 is a Cartesian product of 3 components.
trait Product4[+T1, +T2, +T3, +T4] extends Product Product4 is a Cartesian product of 4 components.
trait Product5[+T1, +T2, +T3, +T4, +T5] extends Product Product5 is a Cartesian product of 5 components.
trait Product6[+T1, +T2, +T3, +T4, +T5, +T6] extends Product Product6 is a Cartesian product of 6 components.
trait Product7[+T1, +T2, +T3, +T4, +T5, +T6, +T7] extends Product Product7 is a Cartesian product of 7 components.
trait Product8[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8] extends Product Product8 is a Cartesian product of 8 components.
trait Product9[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9] extends Product Product9 is a Cartesian product of 9 components.
trait Proxy extends Any This class implements a simple proxy that forwards all calls to the public, non-final methods defined in class Any to another object self.
final case class Tuple3[+T1, +T2, +T3](_1: T1, _2: T2, _3: T3) extends Product3[T1, T2, T3] with Product with Serializable A tuple of 3 elements; the canonical representation of a scala.Product3.
final case class Tuple4[+T1, +T2, +T3, +T4](_1: T1, _2: T2, _3: T3, _4: T4) extends Product4[T1, T2, T3, T4] with Product with Serializable A tuple of 4 elements; the canonical representation of a scala.Product4.
final case class Tuple5[+T1, +T2, +T3, +T4, +T5](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5) extends Product5[T1, T2, T3, T4, T5] with Product with Serializable A tuple of 5 elements; the canonical representation of a scala.Product5.
final case class Tuple6[+T1, +T2, +T3, +T4, +T5, +T6](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6) extends Product6[T1, T2, T3, T4, T5, T6] with Product with Serializable A tuple of 6 elements; the canonical representation of a scala.Product6.
final case class Tuple7[+T1, +T2, +T3, +T4, +T5, +T6, +T7](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7) extends Product7[T1, T2, T3, T4, T5, T6, T7] with Product with Serializable A tuple of 7 elements; the canonical representation of a scala.Product7.
final case class Tuple8[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8) extends Product8[T1, T2, T3, T4, T5, T6, T7, T8] with Product with Serializable A tuple of 8 elements; the canonical representation of a scala.Product8.
final case class Tuple9[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9) extends Product9[T1, T2, T3, T4, T5, T6, T7, T8, T9] with Product with Serializable A tuple of 9 elements; the canonical representation of a scala.Product9.
class inline extends Annotation with StaticAnnotation An annotation on methods that requests that the compiler should try especially hard to inline the annotated method.
class noinline extends Annotation with StaticAnnotation An annotation on methods that forbids the compiler to inline the method, no matter how safe the inlining appears to be.
trait DelayedInit extends AnyRef Classes and objects (but note, not traits) inheriting the DelayedInit marker trait will have their initialization code rewritten as follows:code becomes delayedInit(code).
trait NotNull extends Any A marker trait for things that are not allowed to be null
abstract class Responder[+A] extends Serializable Instances of responder are the building blocks of small programs written in continuation passing style.