Scala Standard Library2.12.4 < Back
 

# Packages

-  package root

  This is the documentation for the Scala standard library.

  This is the documentation for the Scala standard library.

  #### Package structure

  The scala package contains core types like `Int`, `Float`, `Array` or `Option` which are accessible in all Scala compilation units without explicit qualification or imports.

  Notable packages include:

  - `scala.collection` and its sub-packages contain Scala's collections framework
    - `scala.collection.immutable` - Immutable, sequential data-structures such as `Vector`, `List`, `Range`, `HashMap` or `HashSet`
    - `scala.collection.mutable` - Mutable, sequential data-structures such as `ArrayBuffer`, `StringBuilder`, `HashMap` or `HashSet`
    - `scala.collection.concurrent` - Mutable, concurrent data-structures such as `TrieMap`
    - `scala.collection.parallel.immutable` - Immutable, parallel data-structures such as `ParVector`, `ParRange`, `ParHashMap` or `ParHashSet`
    - `scala.collection.parallel.mutable` - Mutable, parallel data-structures such as `ParArray`, `ParHashMap`, `ParTrieMap` or `ParHashSet`
  - `scala.concurrent` - Primitives for concurrent programming such as `Futures` and `Promises`
  - `scala.io` - Input and output operations
  - `scala.math` - Basic math functions and additional numeric types like `BigInt` and `BigDecimal`
  - `scala.sys` - Interaction with other processes and the operating system
  - `scala.util.matching` - Regular expressions

  Other packages exist. See the complete list on the right.

  Additional parts of the standard library are shipped as separate libraries. These include:

  - `scala.reflect` - Scala's reflection API (scala-reflect.jar)
  - `scala.xml` - XML parsing, manipulation, and serialization (scala-xml.jar)
  - `scala.swing` - A convenient wrapper around Java's GUI framework called Swing (scala-swing.jar)
  - `scala.util.parsing` - Parser combinators (scala-parser-combinators.jar)

  #### Automatic imports

  Identifiers in the scala package and the `scala.Predef` object are always in scope by default.

  Some of these identifiers are type aliases provided as shortcuts to commonly used classes. For example, `List` is an alias for `scala.collection.immutable.List`.

  Other aliases refer to classes provided by the underlying platform. For example, on the JVM, `String` is an alias for `java.lang.String`.

  Definition Classes
    root
-  package scala

  Core Scala types.

  Core Scala types. They are always available without an explicit import.

  Definition Classes
    root
-  package annotation
-  package beans
-  package collection

  Contains the base traits and objects needed to use and extend Scala's collection library.

  Contains the base traits and objects needed to use and extend Scala's collection library.

  #### Guide

  A detailed guide for using the collections library is available at http://docs.scala-lang.org/overviews/collections/introduction.html. Developers looking to extend the collections library can find a description of its architecture at http://docs.scala-lang.org/overviews/core/architecture-of-scala-collections.html.

  #### Using Collections

  It is convenient to treat all collections as either a scala.collection.Traversable or scala.collection.Iterable, as these traits define the vast majority of operations on a collection.

  Collections can, of course, be treated as specifically as needed, and the library is designed to ensure that the methods that transform collections will return a collection of the same type:

      scala> val array = Array(1,2,3,4,5,6)
      array: Array[Int] = Array(1, 2, 3, 4, 5, 6)

      scala> array map { _.toString }
      res0: Array[String] = Array(1, 2, 3, 4, 5, 6)

      scala> val list = List(1,2,3,4,5,6)
      list: List[Int] = List(1, 2, 3, 4, 5, 6)

      scala> list map { _.toString }
      res1: List[String] = List(1, 2, 3, 4, 5, 6)

  #### Creating Collections

  The most common way to create a collection is to use its companion object as a factory. The three most commonly used collections are scala.collection.Seq, scala.collection.immutable.Set, and scala.collection.immutable.Map. They can be used directly as shown below since their companion objects are all available as type aliases in either the scala package or in `scala.Predef`. New collections are created like this:

      scala> val seq = Seq(1,2,3,4,1)
      seq: Seq[Int] = List(1, 2, 3, 4, 1)

      scala> val set = Set(1,2,3,4,1)
      set: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)

      scala> val map = Map(1 -> "one", 2 -> "two", 3 -> "three", 2 -> "too")
      map: scala.collection.immutable.Map[Int,String] = Map(1 -> one, 2 -> too, 3 -> three)

  It is also typical to prefer the scala.collection.immutable collections over those in scala.collection.mutable; the types aliased in the `scala.Predef` object are the immutable versions.

  Also note that the collections library was carefully designed to include several implementations of each of the three basic collection types. These implementations have specific performance characteristics which are described in the guide.

  The concrete parallel collections also have specific performance characteristics which are described in the parallel collections guide

  ##### Converting to and from Java Collections

  The scala.collection.JavaConverters object provides a collection of decorators that allow converting between Scala and Java collections using `asScala` and `asJava` methods.

-  package compat
-  package concurrent

  This package object contains primitives for concurrent and parallel programming.

  This package object contains primitives for concurrent and parallel programming.

  #### Guide

  A more detailed guide to Futures and Promises, including discussion and examples can be found at http://docs.scala-lang.org/overviews/core/futures.html.

  #### Common Imports

  When working with Futures, you will often find that importing the whole concurrent package is convenient:

      import scala.concurrent._

  When using things like `Future`s, it is often required to have an implicit `ExecutionContext` in scope. The general advice for these implicits are as follows.

  If the code in question is a class or method definition, and no `ExecutionContext` is available, request one from the caller by adding an implicit parameter list:

      def myMethod(myParam: MyType)(implicit ec: ExecutionContext) = …
      //Or
      class MyClass(myParam: MyType)(implicit ec: ExecutionContext) { … }

  This allows the caller of the method, or creator of the instance of the class, to decide which `ExecutionContext` should be used.

  For typical REPL usage and experimentation, importing the global `ExecutionContext` is often desired.

      import scala.concurrent.ExcutionContext.Implicits.global

  #### Specifying Durations

  Operations often require a duration to be specified. A duration DSL is available to make defining these easier:

      import scala.concurrent.duration._
      val d: Duration = 10.seconds

  #### Using Futures For Non-blocking Computation

  Basic use of futures is easy with the factory method on Future, which executes a provided function asynchronously, handing you back a future result of that function without blocking the current thread. In order to create the Future you will need either an implicit or explicit ExecutionContext to be provided:

      import scala.concurrent._
      import ExecutionContext.Implicits.global  // implicit execution context

      val firstZebra: Future[Int] = Future {
        val source = scala.io.Source.fromFile("/etc/dictionaries-common/words")
        source.toSeq.indexOfSlice("zebra")
      }

  #### Avoid Blocking

  Although blocking is possible in order to await results (with a mandatory timeout duration):

      import scala.concurrent.duration._
      Await.result(firstZebra, 10.seconds)

  and although this is sometimes necessary to do, in particular for testing purposes, blocking in general is discouraged when working with Futures and concurrency in order to avoid potential deadlocks and improve performance. Instead, use callbacks or combinators to remain in the future domain:

      val animalRange: Future[Int] = for {
        aardvark <- firstAardvark
        zebra <- firstZebra
      } yield zebra - aardvark

      animalRange.onSuccess {
        case x if x > 500000 => println("It's a long way from Aardvark to Zebra")
      }

-  package io
-  package math

  The package object `scala.math` contains methods for performing basic numeric operations such as elementary exponential, logarithmic, root and trigonometric functions.

  The package object `scala.math` contains methods for performing basic numeric operations such as elementary exponential, logarithmic, root and trigonometric functions.

  All methods forward to java.lang.Math unless otherwise noted.

  See also

    java.lang.Math

-  package ref
-  package reflect
-  package runtime
-  package sys

  The package object `scala.sys` contains methods for reading and altering core aspects of the virtual machine as well as the world outside of it.

  The package object `scala.sys` contains methods for reading and altering core aspects of the virtual machine as well as the world outside of it.

  Version

    2.9

  Since

    2.9

-  package text
-  package util
- Any
- AnyVal
- App
- Array
- Boolean
- Byte
- Char
- Cloneable
- Console
- DelayedInit
- Double
- Dynamic
- Enumeration
- Equals
- FallbackArrayBuilding
- Float
- Function
- Function0
- Function1
- Function10
- Function11
- Function12
- Function13
- Function14
- Function15
- Function16
- Function17
- Function18
- Function19
- Function2
- Function20
- Function21
- Function22
- Function3
- Function4
- Function5
- Function6
- Function7
- Function8
- Function9
- Immutable
- Int
- Long
- MatchError
- Mutable
- None
- NotImplementedError
- NotNull
- Nothing
- Null
- Option
- PartialFunction
- Predef
- Product
- Product1
- Product10
- Product11
- Product12
- Product13
- Product14
- Product15
- Product16
- Product17
- Product18
- Product19
- Product2
- Product20
- Product21
- Product22
- Product3
- Product4
- Product5
- Product6
- Product7
- Product8
- Product9
- Proxy
- Responder
- ScalaReflectionException
- SerialVersionUID
- Serializable
- Short
- Some
- Specializable
- StringContext
- Symbol
- Tuple1
- Tuple10
- Tuple11
- Tuple12
- Tuple13
- Tuple14
- Tuple15
- Tuple16
- Tuple17
- Tuple18
- Tuple19
- Tuple2
- Tuple20
- Tuple21
- Tuple22
- Tuple3
- Tuple4
- Tuple5
- Tuple6
- Tuple7
- Tuple8
- Tuple9
- UninitializedError
- UninitializedFieldError
- Unit
- deprecated
- deprecatedInheritance
- deprecatedName
- deprecatedOverriding
- inline
- language
- languageFeature
- native
- noinline
- remote
- specialized
- throws
- transient
- unchecked
- volatile

p

# scala 

#### package scala

Core Scala types. They are always available without an explicit import.

Source
  package.scala

Linear Supertypes
AnyRef, Any
Content Hierarchy
 
Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. scala
2. AnyRef
3. Any

1. Hide All
2. Show All

Visibility

1. Public
2. All

### Type Members

1.  type ::[A] = scala.collection.immutable.::[A]
2.  type AbstractMethodError = java.lang.AbstractMethodError
3.  abstract class Any

   Class `Any` is the root of the Scala class hierarchy.

   Class `Any` is the root of the Scala class hierarchy. Every class in a Scala execution environment inherits directly or indirectly from this class.

   Starting with Scala 2.10 it is possible to directly extend `Any` using universal traits. A universal trait is a trait that extends `Any`, only has `def`s as members, and does no initialization.

   The main use case for universal traits is to allow basic inheritance of methods for value classes. For example,

       trait Printable extends Any {
         def print(): Unit = println(this)
       }
       class Wrapper(val underlying: Int) extends AnyVal with Printable

       val w = new Wrapper(3)
       w.print()

   See the Value Classes and Universal Traits for more details on the interplay of universal traits and value classes.

4.  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.

   `AnyVal` is the root class of all value types, which describe values not implemented as objects in the underlying host system. Value classes are specified in Scala Language Specification, section 12.2.

   The standard implementation includes nine `AnyVal` subtypes:

   scala.Double, scala.Float, scala.Long, scala.Int, scala.Char, scala.Short, and scala.Byte are the numeric value types.

   scala.Unit and scala.Boolean are the non-numeric value types.

   Other groupings:

   - The subrange types are scala.Byte, scala.Short, and scala.Char.
   - The integer types include the subrange types as well as scala.Int and scala.Long.
   - The floating point types are scala.Float and scala.Double.

   Prior to Scala 2.10, `AnyVal` was a sealed trait. Beginning with Scala 2.10, however, it is possible to define a subclass of `AnyVal` called a user-defined value class which is treated specially by the compiler. Properly-defined user value classes provide a way to improve performance on user-defined types by avoiding object allocation at runtime, and by replacing virtual method invocations with static method invocations.

   User-defined value classes which avoid object allocation...

   - must have a single `val` parameter that is the underlying runtime representation.
   - can define `def`s, but no `val`s, `var`s, or nested `traits`s, `class`es or `object`s.
   - typically extend no other trait apart from `AnyVal`.
   - cannot be used in type tests or pattern matching.
   - may not override `equals` or `hashCode` methods.

   A minimal example:

       class Wrapper(val underlying: Int) extends AnyVal {
         def foo: Wrapper = new Wrapper(underlying * 19)
       }

   It's important to note that user-defined value classes are limited, and in some circumstances, still must allocate a value class instance at runtime. These limitations and circumstances are explained in greater detail in the Value Classes and Universal Traits.

5.  trait App extends DelayedInit

   The `App` trait can be used to quickly turn objects into executable programs.

   The `App` trait can be used to quickly turn objects into executable programs. Here is an example:

       object Main extends App {
         Console.println("Hello World: " + (args mkString ", "))
       }

   Here, object `Main` inherits the `main` method of `App`.

   `args` returns the current command line arguments as an array.

   #### Caveats

   It should be noted that this trait is implemented using the DelayedInit functionality, which means that fields of the object will not have been initialized before the main method has been executed.

   It should also be noted that the `main` method should not be overridden: the whole class body becomes the “main method”.

   Future versions of this trait will no longer extend `DelayedInit`.

   Version

     2.1, 15/02/2011

6.  final class Array[T] extends java.io.Serializable with java.lang.Cloneable

   Arrays are mutable, indexed collections of values.

   Arrays are mutable, indexed collections of values. `Array[T]` is Scala's representation for Java's `T[]`.

       val numbers = Array(1, 2, 3, 4)
       val first = numbers(0) // read the first element
       numbers(3) = 100 // replace the 4th array element with 100
       val biggerNumbers = numbers.map(_ * 2) // multiply all numbers by two

   Arrays make use of two common pieces of Scala syntactic sugar, shown on lines 2 and 3 of the above example code. Line 2 is translated into a call to `apply(Int)`, while line 3 is translated into a call to `update(Int, T)`.

   Two implicit conversions exist in scala.Predef that are frequently applied to arrays: a conversion to scala.collection.mutable.ArrayOps (shown on line 4 of the example above) and a conversion to scala.collection.mutable.WrappedArray (a subtype of scala.collection.Seq). Both types make available many of the standard operations found in the Scala collections API. The conversion to `ArrayOps` is temporary, as all operations defined on `ArrayOps` return an `Array`, while the conversion to `WrappedArray` is permanent as all operations return a `WrappedArray`.

   The conversion to `ArrayOps` takes priority over the conversion to `WrappedArray`. For instance, consider the following code:

       val arr = Array(1, 2, 3)
       val arrReversed = arr.reverse
       val seqReversed : Seq[Int] = arr.reverse

   Value `arrReversed` will be of type `Array[Int]`, with an implicit conversion to `ArrayOps` occurring to perform the `reverse` operation. The value of `seqReversed`, on the other hand, will be computed by converting to `WrappedArray` first and invoking the variant of `reverse` that returns another `WrappedArray`.

   Version

     1.0

   See also

     "The Scala 2.8 Collections' API" section on `Array` by Martin Odersky for more information.

     "Scala 2.8 Arrays" the Scala Improvement Document detailing arrays since Scala 2.8.

     Scala Language Specification, for in-depth information on the transformations the Scala compiler makes on Arrays (Sections 6.6 and 6.15 respectively.)

7.  type ArrayIndexOutOfBoundsException = java.lang.ArrayIndexOutOfBoundsException
8.  type BigDecimal = scala.math.BigDecimal
9.  type BigInt = scala.math.BigInt
10.  abstract final class Boolean extends AnyVal

    `Boolean` (equivalent to Java's `boolean` primitive type) is a subtype of scala.AnyVal.

    `Boolean` (equivalent to Java's `boolean` primitive type) is a subtype of scala.AnyVal. Instances of `Boolean` are not represented by an object in the underlying runtime system.

    There is an implicit conversion from scala.Boolean => scala.runtime.RichBoolean which provides useful non-primitive operations.

11.  type BufferedIterator[+A] = scala.collection.BufferedIterator[A]
12.  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.

    `Byte`, a 8-bit signed integer (equivalent to Java's `byte` primitive type) is a subtype of scala.AnyVal. Instances of `Byte` are not represented by an object in the underlying runtime system.

    There is an implicit conversion from scala.Byte => scala.runtime.RichByte which provides useful non-primitive operations.

13.  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.

    `Char`, a 16-bit unsigned integer (equivalent to Java's `char` primitive type) is a subtype of scala.AnyVal. Instances of `Char` are not represented by an object in the underlying runtime system.

    There is an implicit conversion from scala.Char => scala.runtime.RichChar which provides useful non-primitive operations.

14.  type ClassCastException = java.lang.ClassCastException
15.  trait Cloneable extends java.lang.Cloneable

    Classes extending this trait are cloneable across platforms (Java, .NET).

16.  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.

    `Double`, a 64-bit IEEE-754 floating point number (equivalent to Java's `double` primitive type) is a subtype of scala.AnyVal. Instances of `Double` are not represented by an object in the underlying runtime system.

    There is an implicit conversion from scala.Double => scala.runtime.RichDouble which provides useful non-primitive operations.

17.  trait Dynamic extends Any

    A marker trait that enables dynamic invocations.

    A marker trait that enables dynamic invocations. Instances `x` of this trait allow method invocations `x.meth(args)` for arbitrary method names `meth` and argument lists `args` as well as field accesses `x.field` for arbitrary field names `field`.

    If a call is not natively supported by `x` (i.e. if type checking fails), it is rewritten according to the following rules:

        foo.method("blah")      ~~> foo.applyDynamic("method")("blah")
        foo.method(x = "blah")  ~~> foo.applyDynamicNamed("method")(("x", "blah"))
        foo.method(x = 1, 2)    ~~> foo.applyDynamicNamed("method")(("x", 1), ("", 2))
        foo.field           ~~> foo.selectDynamic("field")
        foo.varia = 10      ~~> foo.updateDynamic("varia")(10)
        foo.arr(10) = 13    ~~> foo.selectDynamic("arr").update(10, 13)
        foo.arr(10)         ~~> foo.applyDynamic("arr")(10)

    As of Scala 2.10, defining direct or indirect subclasses of this trait is only possible if the language feature `dynamics` is enabled.

18.  type Either[+A, +B] = scala.util.Either[A, B]
19.  abstract class Enumeration extends Serializable

    Defines a finite set of values specific to the enumeration.

    Defines a finite set of values specific to the enumeration. Typically these values enumerate all possible forms something can take and provide a lightweight alternative to case classes.

    Each call to a `Value` method adds a new unique value to the enumeration. To be accessible, these values are usually defined as `val` members of the evaluation.

    All values in an enumeration share a common, unique type defined as the `Value` type member of the enumeration (`Value` selected on the stable identifier path of the enumeration instance).

    Annotations
      @SerialVersionUID()
    Examples:

    1.     // Example of adding attributes to an enumeration by extending the Enumeration.Val class
           object Planet extends Enumeration {
             protected case class Val(mass: Double, radius: Double) extends super.Val {
               def surfaceGravity: Double = Planet.G * mass / (radius * radius)
               def surfaceWeight(otherMass: Double): Double = otherMass * surfaceGravity
             }
             implicit def valueToPlanetVal(x: Value): Val = x.asInstanceOf[Val]

             val G: Double = 6.67300E-11
             val Mercury = Val(3.303e+23, 2.4397e6)
             val Venus   = Val(4.869e+24, 6.0518e6)
             val Earth   = Val(5.976e+24, 6.37814e6)
             val Mars    = Val(6.421e+23, 3.3972e6)
             val Jupiter = Val(1.9e+27, 7.1492e7)
             val Saturn  = Val(5.688e+26, 6.0268e7)
             val Uranus  = Val(8.686e+25, 2.5559e7)
             val Neptune = Val(1.024e+26, 2.4746e7)
           }

           println(Planet.values.filter(_.radius > 7.0e6))
           // output:
           // Planet.ValueSet(Jupiter, Saturn, Uranus, Neptune)

    ,

    2.     // Define a new enumeration with a type alias and work with the full set of enumerated values
           object WeekDay extends Enumeration {
             type WeekDay = Value
             val Mon, Tue, Wed, Thu, Fri, Sat, Sun = Value
           }
           import WeekDay._

           def isWorkingDay(d: WeekDay) = ! (d == Sat || d == Sun)

           WeekDay.values filter isWorkingDay foreach println
           // output:
           // Mon
           // Tue
           // Wed
           // Thu
           // Fri

20.  trait Equals extends Any

    An interface containing operations for equality.

    An interface containing operations for equality. The only method not already present in class `AnyRef` is `canEqual`.

21.  type Equiv[T] = scala.math.Equiv[T]
22.  type Error = java.lang.Error
23.  type Exception = java.lang.Exception
24.  class FallbackArrayBuilding extends AnyRef

    Contains a fallback builder for arrays when the element type does not have a class tag.

    Contains a fallback builder for arrays when the element type does not have a class tag. In that case a generic array is built.

25.  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.

    `Float`, a 32-bit IEEE-754 floating point number (equivalent to Java's `float` primitive type) is a subtype of scala.AnyVal. Instances of `Float` are not represented by an object in the underlying runtime system.

    There is an implicit conversion from scala.Float => scala.runtime.RichFloat which provides useful non-primitive operations.

26.  type Fractional[T] = scala.math.Fractional[T]
27.  trait Function0[+R] extends AnyRef

    A function of 0 parameters.

    A function of 0 parameters.

    In the following example, the definition of javaVersion is a shorthand for the anonymous class definition anonfun0:

         object Main extends App {
           val javaVersion = () => sys.props("java.version")

           val anonfun0 = new Function0[String] {
             def apply(): String = sys.props("java.version")
           }
           assert(javaVersion() == anonfun0())
        }

28.  trait Function1[-T1, +R] extends AnyRef

    A function of 1 parameter.

    A function of 1 parameter.

    In the following example, the definition of succ is a shorthand for the anonymous class definition anonfun1:

         object Main extends App {
           val succ = (x: Int) => x + 1
           val anonfun1 = new Function1[Int, Int] {
             def apply(x: Int): Int = x + 1
           }
           assert(succ(0) == anonfun1(0))
        }

    Note that the difference between `Function1` and scala.PartialFunction is that the latter can specify inputs which it will not handle.

    Annotations
      @implicitNotFound( msg = ... )
29.  trait Function10[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, +R] extends AnyRef

    A function of 10 parameters.

30.  trait Function11[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, +R] extends AnyRef

    A function of 11 parameters.

31.  trait Function12[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, +R] extends AnyRef

    A function of 12 parameters.

32.  trait Function13[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, +R] extends AnyRef

    A function of 13 parameters.

33.  trait Function14[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, +R] extends AnyRef

    A function of 14 parameters.

34.  trait Function15[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, +R] extends AnyRef

    A function of 15 parameters.

35.  trait Function16[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, +R] extends AnyRef

    A function of 16 parameters.

36.  trait Function17[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, +R] extends AnyRef

    A function of 17 parameters.

37.  trait Function18[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, +R] extends AnyRef

    A function of 18 parameters.

38.  trait Function19[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, +R] extends AnyRef

    A function of 19 parameters.

39.  trait Function2[-T1, -T2, +R] extends AnyRef

    A function of 2 parameters.

    A function of 2 parameters.

    In the following example, the definition of max is a shorthand for the anonymous class definition anonfun2:

         object Main extends App {
           val max = (x: Int, y: Int) => if (x < y) y else x

           val anonfun2 = new Function2[Int, Int, Int] {
             def apply(x: Int, y: Int): Int = if (x < y) y else x
           }
           assert(max(0, 1) == anonfun2(0, 1))
        }

40.  trait Function20[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, +R] extends AnyRef

    A function of 20 parameters.

41.  trait Function21[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, +R] extends AnyRef

    A function of 21 parameters.

42.  trait Function22[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, -T22, +R] extends AnyRef

    A function of 22 parameters.

43.  trait Function3[-T1, -T2, -T3, +R] extends AnyRef

    A function of 3 parameters.

44.  trait Function4[-T1, -T2, -T3, -T4, +R] extends AnyRef

    A function of 4 parameters.

45.  trait Function5[-T1, -T2, -T3, -T4, -T5, +R] extends AnyRef

    A function of 5 parameters.

46.  trait Function6[-T1, -T2, -T3, -T4, -T5, -T6, +R] extends AnyRef

    A function of 6 parameters.

47.  trait Function7[-T1, -T2, -T3, -T4, -T5, -T6, -T7, +R] extends AnyRef

    A function of 7 parameters.

48.  trait Function8[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, +R] extends AnyRef

    A function of 8 parameters.

49.  trait Function9[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, +R] extends AnyRef

    A function of 9 parameters.

50.  type IllegalArgumentException = java.lang.IllegalArgumentException
51.  trait Immutable extends AnyRef

    A marker trait for all immutable data structures such as immutable collections.

    A marker trait for all immutable data structures such as immutable collections.

    Since

      2.8

52.  type IndexOutOfBoundsException = java.lang.IndexOutOfBoundsException
53.  type IndexedSeq[+A] = scala.collection.IndexedSeq[A]
54.  abstract final class Int extends AnyVal

    `Int`, a 32-bit signed integer (equivalent to Java's `int` primitive type) is a subtype of scala.AnyVal.

    `Int`, a 32-bit signed integer (equivalent to Java's `int` primitive type) is a subtype of scala.AnyVal. Instances of `Int` are not represented by an object in the underlying runtime system.

    There is an implicit conversion from scala.Int => scala.runtime.RichInt which provides useful non-primitive operations.

55.  type Integral[T] = scala.math.Integral[T]
56.  type InterruptedException = java.lang.InterruptedException
57.  type Iterable[+A] = scala.collection.Iterable[A]
58.  type Iterator[+A] = scala.collection.Iterator[A]
59.  type Left[+A, +B] = scala.util.Left[A, B]
60.  type List[+A] = scala.collection.immutable.List[A]
61.  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.

    `Long`, a 64-bit signed integer (equivalent to Java's `long` primitive type) is a subtype of scala.AnyVal. Instances of `Long` are not represented by an object in the underlying runtime system.

    There is an implicit conversion from scala.Long => scala.runtime.RichLong which provides useful non-primitive operations.

62.  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.

    This class implements errors which are thrown whenever an object doesn't match any pattern of a pattern matching expression.

    Version

      1.1, 05/03/2004

    Since

      2.0

63.  trait Mutable extends AnyRef

    A marker trait for mutable data structures such as mutable collections

    A marker trait for mutable data structures such as mutable collections

    Since

      2.8

64.  type NoSuchElementException = java.util.NoSuchElementException
65.  final class NotImplementedError extends Error

    Throwing this exception can be a temporary replacement for a method body that remains to be implemented.

    Throwing this exception can be a temporary replacement for a method body that remains to be implemented. For instance, the exception is thrown by `Predef.???`.

66.  abstract final class Nothing extends Any

    `Nothing` is - together with scala.Null - at the bottom of Scala's type hierarchy.

    `Nothing` is - together with scala.Null - at the bottom of Scala's type hierarchy.

    `Nothing` is a subtype of every other type (including scala.Null); there exist no instances of this type. Although type `Nothing` is uninhabited, it is nevertheless useful in several ways. For instance, the Scala library defines a value scala.collection.immutable.Nil of type `List[Nothing]`. Because lists are covariant in Scala, this makes scala.collection.immutable.Nil an instance of `List[T]`, for any element of type `T`.

    Another usage for Nothing is the return type for methods which never return normally. One example is method error in scala.sys, which always throws an exception.

67.  abstract final class Null extends AnyRef

    `Null` is - together with scala.Nothing - at the bottom of the Scala type hierarchy.

    `Null` is - together with scala.Nothing - at the bottom of the Scala type hierarchy.

    `Null` is a subtype of all reference types; its only instance is the `null` reference. Since `Null` is not a subtype of value types, `null` is not a member of any such type. For instance, it is not possible to assign `null` to a variable of type scala.Int.

68.  type NullPointerException = java.lang.NullPointerException
69.  type NumberFormatException = java.lang.NumberFormatException
70.  type Numeric[T] = scala.math.Numeric[T]
71.  sealed abstract class Option[+A] extends Product with Serializable

    Represents optional values.

    Represents optional values. Instances of `Option` are either an instance of scala.Some or the object `None`.

    The most idiomatic way to use an scala.Option instance is to treat it as a collection or monad and use `map`,`flatMap`, `filter`, or `foreach`:

        val name: Option[String] = request getParameter "name"
        val upper = name map { _.trim } filter { _.length != 0 } map { _.toUpperCase }
        println(upper getOrElse "")

    Note that this is equivalent to

        val upper = for {
          name <- request getParameter "name"
          trimmed <- Some(name.trim)
          upper <- Some(trimmed.toUpperCase) if trimmed.length != 0
        } yield upper
        println(upper getOrElse "")

    Because of how for comprehension works, if `None` is returned from `request.getParameter`, the entire expression results in `None`

    This allows for sophisticated chaining of scala.Option values without having to check for the existence of a value.

    A less-idiomatic way to use scala.Option values is via pattern matching:

        val nameMaybe = request getParameter "name"
        nameMaybe match {
          case Some(name) =>
            println(name.trim.toUppercase)
          case None =>
            println("No name value")
        }

    Annotations
      @SerialVersionUID()
    Version

      1.1, 16/01/2007

    Note

      Many of the methods in here are duplicative with those in the Traversable hierarchy, but they are duplicated for a reason: the implicit conversion tends to leave one with an Iterable in situations where one could have retained an Option.

72.  type Ordered[T] = scala.math.Ordered[T]
73.  type Ordering[T] = scala.math.Ordering[T]
74.  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`.

    A partial function of type `PartialFunction[A, B]` is a unary function where the domain does not necessarily include all values of type `A`. The function `isDefinedAt` allows to test dynamically if a value is in the domain of the function.

    Even if `isDefinedAt` returns true for an `a: A`, calling `apply(a)` may still throw an exception, so the following code is legal:

        val f: PartialFunction[Int, Any] = { case _ => 1/0 }

    It is the responsibility of the caller to call `isDefinedAt` before calling `apply`, because if `isDefinedAt` is false, it is not guaranteed `apply` will throw an exception to indicate an error condition. If an exception is not thrown, evaluation may result in an arbitrary value.

    The main distinction between `PartialFunction` and scala.Function1 is that the user of a `PartialFunction` may choose to do something different with input that is declared to be outside its domain. For example:

        val sample = 1 to 10
        val isEven: PartialFunction[Int, String] = {
          case x if x % 2 == 0 => x+" is even"
        }

        // the method collect can use isDefinedAt to select which members to collect
        val evenNumbers = sample collect isEven

        val isOdd: PartialFunction[Int, String] = {
          case x if x % 2 == 1 => x+" is odd"
        }

        // the method orElse allows chaining another partial function to handle
        // input outside the declared domain
        val numbers = sample map (isEven orElse isOdd)

    Version

      1.0, 16/07/2003

75.  type PartialOrdering[T] = scala.math.PartialOrdering[T]
76.  type PartiallyOrdered[T] = scala.math.PartiallyOrdered[T]
77.  trait Product extends Equals

    Base trait for all products, which in the standard library include at least scala.Product1 through scala.Product22 and therefore also their subclasses scala.Tuple1 through scala.Tuple22.

    Base trait for all products, which in the standard library include at least scala.Product1 through scala.Product22 and therefore also their subclasses scala.Tuple1 through scala.Tuple22. In addition, all case classes implement `Product` with synthetically generated methods.

    Version

      1.0

    Since

      2.3

78.  trait Product1[+T1] extends Product

    Product1 is a Cartesian product of 1 component.

    Product1 is a Cartesian product of 1 component.

    Since

      2.3

79.  trait Product10[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10] extends Product

    Product10 is a Cartesian product of 10 components.

    Product10 is a Cartesian product of 10 components.

    Since

      2.3

80.  trait Product11[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11] extends Product

    Product11 is a Cartesian product of 11 components.

    Product11 is a Cartesian product of 11 components.

    Since

      2.3

81.  trait Product12[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12] extends Product

    Product12 is a Cartesian product of 12 components.

    Product12 is a Cartesian product of 12 components.

    Since

      2.3

82.  trait Product13[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13] extends Product

    Product13 is a Cartesian product of 13 components.

    Product13 is a Cartesian product of 13 components.

    Since

      2.3

83.  trait Product14[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14] extends Product

    Product14 is a Cartesian product of 14 components.

    Product14 is a Cartesian product of 14 components.

    Since

      2.3

84.  trait Product15[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15] extends Product

    Product15 is a Cartesian product of 15 components.

    Product15 is a Cartesian product of 15 components.

    Since

      2.3

85.  trait Product16[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16] extends Product

    Product16 is a Cartesian product of 16 components.

    Product16 is a Cartesian product of 16 components.

    Since

      2.3

86.  trait Product17[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17] extends Product

    Product17 is a Cartesian product of 17 components.

    Product17 is a Cartesian product of 17 components.

    Since

      2.3

87.  trait Product18[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18] extends Product

    Product18 is a Cartesian product of 18 components.

    Product18 is a Cartesian product of 18 components.

    Since

      2.3

88.  trait Product19[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19] extends Product

    Product19 is a Cartesian product of 19 components.

    Product19 is a Cartesian product of 19 components.

    Since

      2.3

89.  trait Product2[+T1, +T2] extends Product

    Product2 is a Cartesian product of 2 components.

    Product2 is a Cartesian product of 2 components.

    Since

      2.3

90.  trait Product20[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20] extends Product

    Product20 is a Cartesian product of 20 components.

    Product20 is a Cartesian product of 20 components.

    Since

      2.3

91.  trait Product21[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21] extends Product

    Product21 is a Cartesian product of 21 components.

    Product21 is a Cartesian product of 21 components.

    Since

      2.3

92.  trait Product22[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21, +T22] extends Product

    Product22 is a Cartesian product of 22 components.

    Product22 is a Cartesian product of 22 components.

    Since

      2.3

93.  trait Product3[+T1, +T2, +T3] extends Product

    Product3 is a Cartesian product of 3 components.

    Product3 is a Cartesian product of 3 components.

    Since

      2.3

94.  trait Product4[+T1, +T2, +T3, +T4] extends Product

    Product4 is a Cartesian product of 4 components.

    Product4 is a Cartesian product of 4 components.

    Since

      2.3

95.  trait Product5[+T1, +T2, +T3, +T4, +T5] extends Product

    Product5 is a Cartesian product of 5 components.

    Product5 is a Cartesian product of 5 components.

    Since

      2.3

96.  trait Product6[+T1, +T2, +T3, +T4, +T5, +T6] extends Product

    Product6 is a Cartesian product of 6 components.

    Product6 is a Cartesian product of 6 components.

    Since

      2.3

97.  trait Product7[+T1, +T2, +T3, +T4, +T5, +T6, +T7] extends Product

    Product7 is a Cartesian product of 7 components.

    Product7 is a Cartesian product of 7 components.

    Since

      2.3

98.  trait Product8[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8] extends Product

    Product8 is a Cartesian product of 8 components.

    Product8 is a Cartesian product of 8 components.

    Since

      2.3

99.  trait Product9[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9] extends Product

    Product9 is a Cartesian product of 9 components.

    Product9 is a Cartesian product of 9 components.

    Since

      2.3

100.  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.

     This class implements a simple proxy that forwards all calls to the public, non-final methods defined in class `Any` to another object self. Those methods are:

         def hashCode(): Int
         def equals(other: Any): Boolean
         def toString(): String

     Note: forwarding methods in this way will most likely create an asymmetric equals method, which is not generally recommended.

     Version

       1.0, 26/04/2004

101.  type Range = scala.collection.immutable.Range
102.  type Right[+A, +B] = scala.util.Right[A, B]
103.  type RuntimeException = java.lang.RuntimeException
104.  case class ScalaReflectionException(msg: String) extends Exception with Product with Serializable

     An exception that indicates an error during Scala reflection

105.  type Seq[+A] = scala.collection.Seq[A]
106.  class SerialVersionUID extends Annotation with ClassfileAnnotation

     Annotation for specifying the `static SerialVersionUID` field of a serializable class.

107.  trait Serializable extends java.io.Serializable

     Classes extending this trait are serializable across platforms (Java, .NET).

108.  abstract final class Short extends AnyVal

     `Short`, a 16-bit signed integer (equivalent to Java's `short` primitive type) is a subtype of scala.AnyVal.

     `Short`, a 16-bit signed integer (equivalent to Java's `short` primitive type) is a subtype of scala.AnyVal. Instances of `Short` are not represented by an object in the underlying runtime system.

     There is an implicit conversion from scala.Short => scala.runtime.RichShort which provides useful non-primitive operations.

109.  final case class Some[+A](value: A) extends Option[A] with Product with Serializable

     Class `Some[A]` represents existing values of type `A`.

     Class `Some[A]` represents existing values of type `A`.

     Annotations
       @SerialVersionUID()
     Version

       1.0, 16/07/2003

110.  trait Specializable extends AnyRef

     A common supertype for companions of specializable types.

     A common supertype for companions of specializable types. Should not be extended in user code.

111.  type Stream[+A] = scala.collection.immutable.Stream[A]
112.  type StringBuilder = scala.collection.mutable.StringBuilder
113.  case class StringContext(parts: String*) extends Product with Serializable

     This class provides the basic mechanism to do String Interpolation.

     This class provides the basic mechanism to do String Interpolation. String Interpolation allows users to embed variable references directly in *processed* string literals. Here's an example:

         val name = "James"
         println(s"Hello, $name")  // Hello, James

     Any processed string literal is rewritten as an instantiation and method call against this class. For example:

         s"Hello, $name"

     is rewritten to be:

         StringContext("Hello, ", "").s(name)

     By default, this class provides the `raw`, `s` and `f` methods as available interpolators.

     To provide your own string interpolator, create an implicit class which adds a method to `StringContext`. Here's an example:

         implicit class JsonHelper(private val sc: StringContext) extends AnyVal {
           def json(args: Any*): JSONObject = ...
         }
         val x: JSONObject = json"{ a: $a }"

     Here the `JsonHelper` extension class implicitly adds the `json` method to `StringContext` which can be used for `json` string literals.

     parts

       The parts that make up the interpolated string, without the expressions that get inserted by interpolation.

     Since

       2.10.0

114.  type StringIndexOutOfBoundsException = java.lang.StringIndexOutOfBoundsException
115.  final class Symbol extends Serializable

     This class provides a simple way to get unique objects for equal strings.

     This class provides a simple way to get unique objects for equal strings. Since symbols are interned, they can be compared using reference equality. Instances of `Symbol` can be created easily with Scala's built-in quote mechanism.

     For instance, the Scala term `'mysym` will invoke the constructor of the `Symbol` class in the following way: `Symbol("mysym")`.

     Version

       1.8

116.  type Throwable = java.lang.Throwable
117.  type Traversable[+A] = scala.collection.Traversable[A]
118.  type TraversableOnce[+A] = scala.collection.TraversableOnce[A]
119.  final case class Tuple1[+T1](_1: T1) extends Product1[T1] with Product with Serializable

     A tuple of 1 elements; the canonical representation of a scala.Product1.

     A tuple of 1 elements; the canonical representation of a scala.Product1.

     _1

       Element 1 of this Tuple1

120.  final case class Tuple10[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10) extends Product10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] with Product with Serializable

     A tuple of 10 elements; the canonical representation of a scala.Product10.

     A tuple of 10 elements; the canonical representation of a scala.Product10.

     _1

       Element 1 of this Tuple10

     _2

       Element 2 of this Tuple10

     _3

       Element 3 of this Tuple10

     _4

       Element 4 of this Tuple10

     _5

       Element 5 of this Tuple10

     _6

       Element 6 of this Tuple10

     _7

       Element 7 of this Tuple10

     _8

       Element 8 of this Tuple10

     _9

       Element 9 of this Tuple10

     _10

       Element 10 of this Tuple10

121.  final case class Tuple11[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11) extends Product11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] with Product with Serializable

     A tuple of 11 elements; the canonical representation of a scala.Product11.

     A tuple of 11 elements; the canonical representation of a scala.Product11.

     _1

       Element 1 of this Tuple11

     _2

       Element 2 of this Tuple11

     _3

       Element 3 of this Tuple11

     _4

       Element 4 of this Tuple11

     _5

       Element 5 of this Tuple11

     _6

       Element 6 of this Tuple11

     _7

       Element 7 of this Tuple11

     _8

       Element 8 of this Tuple11

     _9

       Element 9 of this Tuple11

     _10

       Element 10 of this Tuple11

     _11

       Element 11 of this Tuple11

122.  final case class Tuple12[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12) extends Product12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] with Product with Serializable

     A tuple of 12 elements; the canonical representation of a scala.Product12.

     A tuple of 12 elements; the canonical representation of a scala.Product12.

     _1

       Element 1 of this Tuple12

     _2

       Element 2 of this Tuple12

     _3

       Element 3 of this Tuple12

     _4

       Element 4 of this Tuple12

     _5

       Element 5 of this Tuple12

     _6

       Element 6 of this Tuple12

     _7

       Element 7 of this Tuple12

     _8

       Element 8 of this Tuple12

     _9

       Element 9 of this Tuple12

     _10

       Element 10 of this Tuple12

     _11

       Element 11 of this Tuple12

     _12

       Element 12 of this Tuple12

123.  final case class Tuple13[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13) extends Product13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] with Product with Serializable

     A tuple of 13 elements; the canonical representation of a scala.Product13.

     A tuple of 13 elements; the canonical representation of a scala.Product13.

     _1

       Element 1 of this Tuple13

     _2

       Element 2 of this Tuple13

     _3

       Element 3 of this Tuple13

     _4

       Element 4 of this Tuple13

     _5

       Element 5 of this Tuple13

     _6

       Element 6 of this Tuple13

     _7

       Element 7 of this Tuple13

     _8

       Element 8 of this Tuple13

     _9

       Element 9 of this Tuple13

     _10

       Element 10 of this Tuple13

     _11

       Element 11 of this Tuple13

     _12

       Element 12 of this Tuple13

     _13

       Element 13 of this Tuple13

124.  final case class Tuple14[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14) extends Product14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] with Product with Serializable

     A tuple of 14 elements; the canonical representation of a scala.Product14.

     A tuple of 14 elements; the canonical representation of a scala.Product14.

     _1

       Element 1 of this Tuple14

     _2

       Element 2 of this Tuple14

     _3

       Element 3 of this Tuple14

     _4

       Element 4 of this Tuple14

     _5

       Element 5 of this Tuple14

     _6

       Element 6 of this Tuple14

     _7

       Element 7 of this Tuple14

     _8

       Element 8 of this Tuple14

     _9

       Element 9 of this Tuple14

     _10

       Element 10 of this Tuple14

     _11

       Element 11 of this Tuple14

     _12

       Element 12 of this Tuple14

     _13

       Element 13 of this Tuple14

     _14

       Element 14 of this Tuple14

125.  final case class Tuple15[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15) extends Product15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] with Product with Serializable

     A tuple of 15 elements; the canonical representation of a scala.Product15.

     A tuple of 15 elements; the canonical representation of a scala.Product15.

     _1

       Element 1 of this Tuple15

     _2

       Element 2 of this Tuple15

     _3

       Element 3 of this Tuple15

     _4

       Element 4 of this Tuple15

     _5

       Element 5 of this Tuple15

     _6

       Element 6 of this Tuple15

     _7

       Element 7 of this Tuple15

     _8

       Element 8 of this Tuple15

     _9

       Element 9 of this Tuple15

     _10

       Element 10 of this Tuple15

     _11

       Element 11 of this Tuple15

     _12

       Element 12 of this Tuple15

     _13

       Element 13 of this Tuple15

     _14

       Element 14 of this Tuple15

     _15

       Element 15 of this Tuple15

126.  final case class Tuple16[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16) extends Product16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16] with Product with Serializable

     A tuple of 16 elements; the canonical representation of a scala.Product16.

     A tuple of 16 elements; the canonical representation of a scala.Product16.

     _1

       Element 1 of this Tuple16

     _2

       Element 2 of this Tuple16

     _3

       Element 3 of this Tuple16

     _4

       Element 4 of this Tuple16

     _5

       Element 5 of this Tuple16

     _6

       Element 6 of this Tuple16

     _7

       Element 7 of this Tuple16

     _8

       Element 8 of this Tuple16

     _9

       Element 9 of this Tuple16

     _10

       Element 10 of this Tuple16

     _11

       Element 11 of this Tuple16

     _12

       Element 12 of this Tuple16

     _13

       Element 13 of this Tuple16

     _14

       Element 14 of this Tuple16

     _15

       Element 15 of this Tuple16

     _16

       Element 16 of this Tuple16

127.  final case class Tuple17[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17) extends Product17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17] with Product with Serializable

     A tuple of 17 elements; the canonical representation of a scala.Product17.

     A tuple of 17 elements; the canonical representation of a scala.Product17.

     _1

       Element 1 of this Tuple17

     _2

       Element 2 of this Tuple17

     _3

       Element 3 of this Tuple17

     _4

       Element 4 of this Tuple17

     _5

       Element 5 of this Tuple17

     _6

       Element 6 of this Tuple17

     _7

       Element 7 of this Tuple17

     _8

       Element 8 of this Tuple17

     _9

       Element 9 of this Tuple17

     _10

       Element 10 of this Tuple17

     _11

       Element 11 of this Tuple17

     _12

       Element 12 of this Tuple17

     _13

       Element 13 of this Tuple17

     _14

       Element 14 of this Tuple17

     _15

       Element 15 of this Tuple17

     _16

       Element 16 of this Tuple17

     _17

       Element 17 of this Tuple17

128.  final case class Tuple18[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17, _18: T18) extends Product18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18] with Product with Serializable

     A tuple of 18 elements; the canonical representation of a scala.Product18.

     A tuple of 18 elements; the canonical representation of a scala.Product18.

     _1

       Element 1 of this Tuple18

     _2

       Element 2 of this Tuple18

     _3

       Element 3 of this Tuple18

     _4

       Element 4 of this Tuple18

     _5

       Element 5 of this Tuple18

     _6

       Element 6 of this Tuple18

     _7

       Element 7 of this Tuple18

     _8

       Element 8 of this Tuple18

     _9

       Element 9 of this Tuple18

     _10

       Element 10 of this Tuple18

     _11

       Element 11 of this Tuple18

     _12

       Element 12 of this Tuple18

     _13

       Element 13 of this Tuple18

     _14

       Element 14 of this Tuple18

     _15

       Element 15 of this Tuple18

     _16

       Element 16 of this Tuple18

     _17

       Element 17 of this Tuple18

     _18

       Element 18 of this Tuple18

129.  final case class Tuple19[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17, _18: T18, _19: T19) extends Product19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19] with Product with Serializable

     A tuple of 19 elements; the canonical representation of a scala.Product19.

     A tuple of 19 elements; the canonical representation of a scala.Product19.

     _1

       Element 1 of this Tuple19

     _2

       Element 2 of this Tuple19

     _3

       Element 3 of this Tuple19

     _4

       Element 4 of this Tuple19

     _5

       Element 5 of this Tuple19

     _6

       Element 6 of this Tuple19

     _7

       Element 7 of this Tuple19

     _8

       Element 8 of this Tuple19

     _9

       Element 9 of this Tuple19

     _10

       Element 10 of this Tuple19

     _11

       Element 11 of this Tuple19

     _12

       Element 12 of this Tuple19

     _13

       Element 13 of this Tuple19

     _14

       Element 14 of this Tuple19

     _15

       Element 15 of this Tuple19

     _16

       Element 16 of this Tuple19

     _17

       Element 17 of this Tuple19

     _18

       Element 18 of this Tuple19

     _19

       Element 19 of this Tuple19

130.  final case class Tuple2[+T1, +T2](_1: T1, _2: T2) extends Product2[T1, T2] with Product with Serializable

     A tuple of 2 elements; the canonical representation of a scala.Product2.

     A tuple of 2 elements; the canonical representation of a scala.Product2.

     _1

       Element 1 of this Tuple2

     _2

       Element 2 of this Tuple2

131.  final case class Tuple20[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17, _18: T18, _19: T19, _20: T20) extends Product20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20] with Product with Serializable

     A tuple of 20 elements; the canonical representation of a scala.Product20.

     A tuple of 20 elements; the canonical representation of a scala.Product20.

     _1

       Element 1 of this Tuple20

     _2

       Element 2 of this Tuple20

     _3

       Element 3 of this Tuple20

     _4

       Element 4 of this Tuple20

     _5

       Element 5 of this Tuple20

     _6

       Element 6 of this Tuple20

     _7

       Element 7 of this Tuple20

     _8

       Element 8 of this Tuple20

     _9

       Element 9 of this Tuple20

     _10

       Element 10 of this Tuple20

     _11

       Element 11 of this Tuple20

     _12

       Element 12 of this Tuple20

     _13

       Element 13 of this Tuple20

     _14

       Element 14 of this Tuple20

     _15

       Element 15 of this Tuple20

     _16

       Element 16 of this Tuple20

     _17

       Element 17 of this Tuple20

     _18

       Element 18 of this Tuple20

     _19

       Element 19 of this Tuple20

     _20

       Element 20 of this Tuple20

132.  final case class Tuple21[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17, _18: T18, _19: T19, _20: T20, _21: T21) extends Product21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21] with Product with Serializable

     A tuple of 21 elements; the canonical representation of a scala.Product21.

     A tuple of 21 elements; the canonical representation of a scala.Product21.

     _1

       Element 1 of this Tuple21

     _2

       Element 2 of this Tuple21

     _3

       Element 3 of this Tuple21

     _4

       Element 4 of this Tuple21

     _5

       Element 5 of this Tuple21

     _6

       Element 6 of this Tuple21

     _7

       Element 7 of this Tuple21

     _8

       Element 8 of this Tuple21

     _9

       Element 9 of this Tuple21

     _10

       Element 10 of this Tuple21

     _11

       Element 11 of this Tuple21

     _12

       Element 12 of this Tuple21

     _13

       Element 13 of this Tuple21

     _14

       Element 14 of this Tuple21

     _15

       Element 15 of this Tuple21

     _16

       Element 16 of this Tuple21

     _17

       Element 17 of this Tuple21

     _18

       Element 18 of this Tuple21

     _19

       Element 19 of this Tuple21

     _20

       Element 20 of this Tuple21

     _21

       Element 21 of this Tuple21

133.  final case class Tuple22[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21, +T22](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17, _18: T18, _19: T19, _20: T20, _21: T21, _22: T22) extends Product22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22] with Product with Serializable

     A tuple of 22 elements; the canonical representation of a scala.Product22.

     A tuple of 22 elements; the canonical representation of a scala.Product22.

     _1

       Element 1 of this Tuple22

     _2

       Element 2 of this Tuple22

     _3

       Element 3 of this Tuple22

     _4

       Element 4 of this Tuple22

     _5

       Element 5 of this Tuple22

     _6

       Element 6 of this Tuple22

     _7

       Element 7 of this Tuple22

     _8

       Element 8 of this Tuple22

     _9

       Element 9 of this Tuple22

     _10

       Element 10 of this Tuple22

     _11

       Element 11 of this Tuple22

     _12

       Element 12 of this Tuple22

     _13

       Element 13 of this Tuple22

     _14

       Element 14 of this Tuple22

     _15

       Element 15 of this Tuple22

     _16

       Element 16 of this Tuple22

     _17

       Element 17 of this Tuple22

     _18

       Element 18 of this Tuple22

     _19

       Element 19 of this Tuple22

     _20

       Element 20 of this Tuple22

     _21

       Element 21 of this Tuple22

     _22

       Element 22 of this Tuple22

134.  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.

     A tuple of 3 elements; the canonical representation of a scala.Product3.

     _1

       Element 1 of this Tuple3

     _2

       Element 2 of this Tuple3

     _3

       Element 3 of this Tuple3

135.  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.

     A tuple of 4 elements; the canonical representation of a scala.Product4.

     _1

       Element 1 of this Tuple4

     _2

       Element 2 of this Tuple4

     _3

       Element 3 of this Tuple4

     _4

       Element 4 of this Tuple4

136.  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.

     A tuple of 5 elements; the canonical representation of a scala.Product5.

     _1

       Element 1 of this Tuple5

     _2

       Element 2 of this Tuple5

     _3

       Element 3 of this Tuple5

     _4

       Element 4 of this Tuple5

     _5

       Element 5 of this Tuple5

137.  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.

     A tuple of 6 elements; the canonical representation of a scala.Product6.

     _1

       Element 1 of this Tuple6

     _2

       Element 2 of this Tuple6

     _3

       Element 3 of this Tuple6

     _4

       Element 4 of this Tuple6

     _5

       Element 5 of this Tuple6

     _6

       Element 6 of this Tuple6

138.  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.

     A tuple of 7 elements; the canonical representation of a scala.Product7.

     _1

       Element 1 of this Tuple7

     _2

       Element 2 of this Tuple7

     _3

       Element 3 of this Tuple7

     _4

       Element 4 of this Tuple7

     _5

       Element 5 of this Tuple7

     _6

       Element 6 of this Tuple7

     _7

       Element 7 of this Tuple7

139.  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.

     A tuple of 8 elements; the canonical representation of a scala.Product8.

     _1

       Element 1 of this Tuple8

     _2

       Element 2 of this Tuple8

     _3

       Element 3 of this Tuple8

     _4

       Element 4 of this Tuple8

     _5

       Element 5 of this Tuple8

     _6

       Element 6 of this Tuple8

     _7

       Element 7 of this Tuple8

     _8

       Element 8 of this Tuple8

140.  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.

     A tuple of 9 elements; the canonical representation of a scala.Product9.

     _1

       Element 1 of this Tuple9

     _2

       Element 2 of this Tuple9

     _3

       Element 3 of this Tuple9

     _4

       Element 4 of this Tuple9

     _5

       Element 5 of this Tuple9

     _6

       Element 6 of this Tuple9

     _7

       Element 7 of this Tuple9

     _8

       Element 8 of this Tuple9

     _9

       Element 9 of this Tuple9

141.  final class UninitializedError extends RuntimeException

     This class represents uninitialized variable/value errors.

     This class represents uninitialized variable/value errors.

     Since

       2.5

142.  final case class UninitializedFieldError(msg: String) extends RuntimeException with Product with Serializable

     This class implements errors which are thrown whenever a field is used before it has been initialized.

     This class implements errors which are thrown whenever a field is used before it has been initialized.

     Such runtime checks are not emitted by default. They can be enabled by the `-Xcheckinit` compiler option.

     Since

       2.7

143.  abstract final class Unit extends AnyVal

     `Unit` is a subtype of scala.AnyVal.

     `Unit` is a subtype of scala.AnyVal. There is only one value of type `Unit`, `()`, and it is not represented by any object in the underlying runtime system. A method with return type `Unit` is analogous to a Java method which is declared `void`.

144.  type UnsupportedOperationException = java.lang.UnsupportedOperationException
145.  type Vector[+A] = scala.collection.immutable.Vector[A]
146.  class deprecated extends Annotation with StaticAnnotation

     An annotation that designates that a definition is deprecated.

     An annotation that designates that a definition is deprecated. A deprecation warning is issued upon usage of the annotated definition.

     Library authors should state the library's deprecation policy in their documentation to give developers guidance on how long a deprecated definition will be preserved.

     Library authors should prepend the name of their library to the version number to help developers distinguish deprecations coming from different libraries:

         @deprecated("this method will be removed", "FooLib 12.0")
         def oldMethod(x: Int) = ...

     The compiler will emit deprecation warnings grouped by library and version:

         oldMethod(1)
         oldMethod(2)
         aDeprecatedMethodFromLibraryBar(3, 4)

         // warning: there was one deprecation warning (since BarLib 3.2)
         // warning: there were two deprecation warnings (since FooLib 12.0)
         // warning: there were three deprecation warnings in total; re-run with -deprecation for details

     `@deprecated` in the Scala language and its standard library

     A deprecated element of the Scala language or a definition in the Scala standard library will be preserved at least for the current major version.

     This means that an element deprecated in some 2.12.x release will be preserved in all 2.12.x releases, but may be removed in 2.13. (A deprecated element might be kept longer to ease migration. Developers should not rely on this.)

     Special deprecation policy for Scala 2.12
     The Scala team has decided to enact a special deprecation policy for Scala 2.12:

     As an upgrade from 2.11 to 2.12 also requires upgrading from Java 6 to Java 8, deprecated elements will not normally be removed in this release, to ease migration and cross-building.

     Annotations
       @getter() @setter() @beanGetter() @beanSetter()
     Since

       2.3

     See also

       scala.deprecatedName

       scala.deprecatedOverriding

       scala.deprecatedInheritance

       The official documentation on binary compatibility.

147.  class deprecatedInheritance extends Annotation with StaticAnnotation

     An annotation that designates that inheriting from a class is deprecated.

     An annotation that designates that inheriting from a class is deprecated.

     This is usually done to warn about a non-final class being made final in a future version. Sub-classing such a class then generates a warning.

     No warnings are generated if the subclass is in the same compilation unit.

     Library authors should state the library's deprecation policy in their documentation to give developers guidance on when a type annotated with `@deprecatedInheritance` will be `final`ized.

     Library authors should prepend the name of their library to the version number to help developers distinguish deprecations coming from different libraries:

         @deprecatedInheritance("this class will be made final", "FooLib 12.0")
         class Foo

         val foo = new Foo     // no deprecation warning
         class Bar extends Foo
         // warning: inheritance from class Foo is deprecated (since FooLib 12.0): this class will be made final
         // class Bar extends Foo
         //                   ^

     Annotations
       @getter() @setter() @beanGetter() @beanSetter()
     Since

       2.10

     See also

       scala.deprecatedName

       scala.deprecatedOverriding

       scala.deprecated

148.  class deprecatedName extends Annotation with StaticAnnotation

     An annotation that designates that the name of a parameter is deprecated.

     An annotation that designates that the name of a parameter is deprecated.

     Using this name in a named argument generates a deprecation warning.

     Library authors should state the library's deprecation policy in their documentation to give developers guidance on how long a deprecated name will be preserved.

     Library authors should prepend the name of their library to the version number to help developers distinguish deprecations coming from different libraries:

         def inc(x: Int, @deprecatedName('y, "FooLib 12.0") n: Int): Int = x + n
         inc(1, y = 2)

     will produce the following warning:

         warning: the parameter name y is deprecated (since FooLib 12.0): use n instead
         inc(1, y = 2)
                  ^

     Annotations
       @param()
     Since

       2.8.1

     See also

       scala.deprecatedOverriding

       scala.deprecatedInheritance

       scala.deprecated

149.  class deprecatedOverriding extends Annotation with StaticAnnotation

     An annotation that designates that overriding a member is deprecated.

     An annotation that designates that overriding a member is deprecated.

     Overriding such a member in a sub-class then generates a warning.

     Library authors should state the library's deprecation policy in their documentation to give developers guidance on when a method annotated with `@deprecatedOverriding` will be `final`ized.

     Library authors should prepend the name of their library to the version number to help developers distinguish deprecations coming from different libraries:

         class Foo {
           @deprecatedOverriding("this method will be made final", "FooLib 12.0")
           def add(x: Int, y: Int) = x + y
         }

         class Bar extends Foo // no deprecation warning
         class Baz extends Foo {
           override def add(x: Int, y: Int) = x - y
         }
         // warning: overriding method add in class Foo is deprecated (since FooLib 12.0): this method will be made final
         // override def add(x: Int, y: Int) = x - y
         //              ^

     Annotations
       @getter() @setter() @beanGetter() @beanSetter()
     Since

       2.10

     See also

       scala.deprecatedName

       scala.deprecatedInheritance

       scala.deprecated

150.  class inline extends Annotation with StaticAnnotation

     An annotation on methods that requests that the compiler should try especially hard to inline the annotated method.

     An annotation on methods that requests that the compiler should try especially hard to inline the annotated method. The annotation can be used at definition site or at callsite.

         @inline   final def f1(x: Int) = x
         @noinline final def f2(x: Int) = x
                   final def f3(x: Int) = x

          def t1 = f1(1)              // inlined if possible
          def t2 = f2(1)              // not inlined
          def t3 = f3(1)              // may be inlined (heuristics)
          def t4 = f1(1): @noinline   // not inlined (override at callsite)
          def t5 = f2(1): @inline     // inlined if possible (override at callsite)
          def t6 = f3(1): @inline     // inlined if possible
          def t7 = f3(1): @noinline   // not inlined
         }

     Note: parentheses are required when annotating a callsite within a larger expression.

         def t1 = f1(1) + f1(1): @noinline   // equivalent to (f1(1) + f1(1)): @noinline
         def t2 = f1(1) + (f1(1): @noinline) // the second call to f1 is not inlined

     Version

       1.0, 2007-5-21

151.  class native extends Annotation with StaticAnnotation

     Marker for native methods.

     Marker for native methods.

         @native def f(x: Int, y: List[Long]): String = ...

     A `@native` method is compiled to the platform's native method, while discarding the method's body (if any). The body will be type checked if present.

     A method marked @native must be a member of a class, not a trait (since 2.12).

     Since

       2.6

152.  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.

     An annotation on methods that forbids the compiler to inline the method, no matter how safe the inlining appears to be. The annotation can be used at definition site or at callsite.

         @inline   final def f1(x: Int) = x
         @noinline final def f2(x: Int) = x
                   final def f3(x: Int) = x

          def t1 = f1(1)              // inlined if possible
          def t2 = f2(1)              // not inlined
          def t3 = f3(1)              // may be inlined (heuristics)
          def t4 = f1(1): @noinline   // not inlined (override at callsite)
          def t5 = f2(1): @inline     // inlined if possible (override at callsite)
          def t6 = f3(1): @inline     // inlined if possible
          def t7 = f3(1): @noinline   // not inlined
         }

     Note: parentheses are required when annotating a callsite within a larger expression.

         def t1 = f1(1) + f1(1): @noinline   // equivalent to (f1(1) + f1(1)): @noinline
         def t2 = f1(1) + (f1(1): @noinline) // the second call to f1 is not inlined

     Version

       1.0, 2007-5-21

     Since

       2.5

153.  class specialized extends Annotation with StaticAnnotation

     Annotate type parameters on which code should be automatically specialized.

     Annotate type parameters on which code should be automatically specialized. For example:

         class MyList[@specialized T] ...

     Type T can be specialized on a subset of the primitive types by specifying a list of primitive types to specialize at:

         class MyList[@specialized(Int, Double, Boolean) T] ..

     Since

       2.8

154.  class throws[T <: Throwable] extends Annotation with StaticAnnotation

     Annotation for specifying the exceptions thrown by a method.

     Annotation for specifying the exceptions thrown by a method. For example:

         class Reader(fname: String) {
           private val in = new BufferedReader(new FileReader(fname))
           @throws[IOException]("if the file doesn't exist")
           def read() = in.read()
         }

     Version

       1.0, 19/05/2006

     Since

       2.1

155.  class transient extends Annotation with StaticAnnotation
     Annotations
       @field()
156.  class unchecked extends Annotation

     An annotation to designate that the annotated entity should not be considered for additional compiler checks.

     An annotation to designate that the annotated entity should not be considered for additional compiler checks. Specific applications include annotating the subject of a match expression to suppress exhaustiveness warnings, and annotating a type argument in a match case to suppress unchecked warnings.

     Such suppression should be used with caution, without which one may encounter scala.MatchError or java.lang.ClassCastException at runtime. In most cases one can and should address the warning instead of suppressing it.

         object Test extends App {
           // This would normally warn "match is not exhaustive"
           // because `None` is not covered.
           def f(x: Option[String]) = (x: @unchecked) match { case Some(y) => y }
           // This would normally warn "type pattern is unchecked"
           // but here will blindly cast the head element to String.
           def g(xs: Any) = xs match { case x: List[String @unchecked] => x.head }
         }

     Since

       2.4

157.  class volatile extends Annotation with StaticAnnotation
     Annotations
       @field()
158.  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)`.

     Classes and objects (but note, not traits) inheriting the `DelayedInit` marker trait will have their initialization code rewritten as follows: `code` becomes `delayedInit(code)`.

     Initialization code comprises all statements and all value definitions that are executed during initialization.

     Example:

         trait Helper extends DelayedInit {
           def delayedInit(body: => Unit) = {
             println("dummy text, printed before initialization of C")
             body // evaluates the initialization code of C
           }
         }

         class C extends Helper {
           println("this is the initialization code of C")
         }

         object Test extends App {
           val c = new C
         }

     Should result in the following being printed:

         dummy text, printed before initialization of C
         this is the initialization code of C

     Annotations
       @deprecated
     Deprecated

       (Since version 2.11.0) DelayedInit semantics can be surprising. Support for `App` will continue. See the release notes for more details: https://github.com/scala/scala/releases/tag/v2.11.0-RC1

     See also

       "Delayed Initialization" subsection of the Scala Language Specification (section 5.1)

159.  trait NotNull extends Any

     A marker trait for things that are not allowed to be null

     A marker trait for things that are not allowed to be null

     Annotations
       @deprecated
     Deprecated

       (Since version 2.11.0) this trait will be removed

     Since

       2.5

160.  abstract class Responder[+A] extends Serializable

     Instances of responder are the building blocks of small programs written in continuation passing style.

     Instances of responder are the building blocks of small programs written in continuation passing style. By using responder classes in for comprehensions, one can embed domain-specific languages in Scala while giving the impression that programs in these DSLs are written in direct style.

     Annotations
       @deprecated
     Deprecated

       (Since version 2.11.0) this class will be removed

     Version

       1.0

     Since

       2.1

161.  class remote extends Annotation with StaticAnnotation

     An annotation that designates the class to which it is applied as remotable.

     An annotation that designates the class to which it is applied as remotable.

     For instance, the Scala code

         @remote trait Hello {
           def sayHello(): String
         }

     is equivalent to the following Java code:

         public interface Hello extends java.rmi.Remote {
             String sayHello() throws java.rmi.RemoteException;
         }

     Annotations
       @deprecated
     Deprecated

       (Since version 2.12.0) extend java.rmi.Remote instead and add @throws[java.rmi.RemoteException] to public methods

### Value Members

1.  val #::: scala.collection.immutable.Stream.#::.type
2.  val +:: scala.collection.+:.type
3.  val :+: scala.collection.:+.type
4.  val ::: scala.collection.immutable.::.type
5.  val AnyRef: Specializable
6.  val BigDecimal: scala.math.BigDecimal.type
7.  val BigInt: scala.math.BigInt.type
8.  val Either: scala.util.Either.type
9.  val Equiv: scala.math.Equiv.type
10.  val Fractional: scala.math.Fractional.type
11.  val IndexedSeq: scala.collection.IndexedSeq.type
12.  val Integral: scala.math.Integral.type
13.  val Iterable: scala.collection.Iterable.type
14.  val Iterator: scala.collection.Iterator.type
15.  val Left: scala.util.Left.type
16.  val List: scala.collection.immutable.List.type
17.  val Nil: scala.collection.immutable.Nil.type
18.  val Numeric: scala.math.Numeric.type
19.  val Ordered: scala.math.Ordered.type
20.  val Ordering: scala.math.Ordering.type
21.  val Range: scala.collection.immutable.Range.type
22.  val Right: scala.util.Right.type
23.  val Seq: scala.collection.Seq.type
24.  val Stream: scala.collection.immutable.Stream.type
25.  val StringBuilder: scala.collection.mutable.StringBuilder.type
26.  val Traversable: scala.collection.Traversable.type
27.  val Vector: scala.collection.immutable.Vector.type
28.  object Array extends FallbackArrayBuilding with Serializable

    Utility methods for operating on arrays.

    Utility methods for operating on arrays. For example:

        val a = Array(1, 2)
        val b = Array.ofDim[Int](2)
        val c = Array.concat(a, b)

    where the array objects `a`, `b` and `c` have respectively the values `Array(1, 2)`, `Array(0, 0)` and `Array(1, 2, 0, 0)`.

    Version

      1.0

29.  object Boolean extends AnyValCompanion
30.  object Byte extends AnyValCompanion
31.  object Char extends AnyValCompanion
32.  object Console extends DeprecatedConsole with AnsiColor

    Implements functionality for printing Scala values on the terminal.

    Implements functionality for printing Scala values on the terminal. For reading values use StdIn. Also defines constants for marking up text on ANSI terminals.

    #### Console Output

    Use the print methods to output text.

        scala> Console.printf(
          "Today the outside temperature is a balmy %.1f°C. %<.1f°C beats the previous record of %.1f°C.\n",
          -137.0,
          -135.05)
        Today the outside temperature is a balmy -137.0°C. -137.0°C beats the previous record of -135.1°C.

    #### ANSI escape codes

    Use the ANSI escape codes for colorizing console output either to STDOUT or STDERR.

        import Console.{GREEN, RED, RESET, YELLOW_B, UNDERLINED}

        object PrimeTest {

          def isPrime(): Unit = {

            val candidate = io.StdIn.readInt().ensuring(_ > 1)

            val prime = (2 to candidate - 1).forall(candidate % _ != 0)

            if (prime)
              Console.println(s"${RESET}${GREEN}yes${RESET}")
            else
              Console.err.println(s"${RESET}${YELLOW_B}${RED}${UNDERLINED}NO!${RESET}")
          }

          def main(args: Array[String]): Unit = isPrime()

        }

    $ scala PrimeTest
    1234567891
    yes
    $ scala PrimeTest
    56474
    NO!

    #### IO redefinition

    Use IO redefinition to temporarily swap in a different set of input and/or output streams. In this example the stream based method above is wrapped into a function.

        import java.io.{ByteArrayOutputStream, StringReader}

        object FunctionalPrimeTest {

          def isPrime(candidate: Int): Boolean = {

            val input = new StringReader(s"$candidate\n")
            val outCapture = new ByteArrayOutputStream
            val errCapture = new ByteArrayOutputStream

            Console.withIn(input) {
              Console.withOut(outCapture) {
                Console.withErr(errCapture) {
                  PrimeTest.isPrime()
                }
              }
            }

            if (outCapture.toByteArray.nonEmpty) // "yes"
              true
            else if (errCapture.toByteArray.nonEmpty) // "NO!"
              false
            else throw new IllegalArgumentException(candidate.toString)
          }

          def main(args: Array[String]): Unit = {
            val primes = (2 to 50) filter (isPrime)
            println(s"First primes: $primes")
          }

        }

    $ scala FunctionalPrimeTest
    First primes: Vector(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47)

    Version

      1.0, 03/09/2003

33.  object Double extends AnyValCompanion
34.  object Float extends AnyValCompanion
35.  object Function

    A module defining utility methods for higher-order functional programming.

    A module defining utility methods for higher-order functional programming.

    Version

      1.0, 29/11/2006

36.  object Int extends AnyValCompanion
37.  object Long extends AnyValCompanion
38.  object None extends Option[Nothing] with Product with Serializable

    This case object represents non-existent values.

    This case object represents non-existent values.

    Annotations
      @SerialVersionUID()
    Version

      1.0, 16/07/2003

39.  object Option extends Serializable
40.  object PartialFunction

    A few handy operations which leverage the extra bit of information available in partial functions.

    A few handy operations which leverage the extra bit of information available in partial functions. Examples:

        import PartialFunction._

        def strangeConditional(other: Any): Boolean = cond(other) {
          case x: String if x == "abc" || x == "def"  => true
          case x: Int => true
        }
        def onlyInt(v: Any): Option[Int] = condOpt(v) { case x: Int => x }

    Since

      2.8

41.  object Predef extends LowPriorityImplicits with DeprecatedPredef

    The `Predef` object provides definitions that are accessible in all Scala compilation units without explicit qualification.

    The `Predef` object provides definitions that are accessible in all Scala compilation units without explicit qualification.

    ##### Commonly Used Types

    Predef provides type aliases for types which are commonly used, such as the immutable collection types scala.collection.immutable.Map, scala.collection.immutable.Set, and the scala.collection.immutable.List constructors (scala.collection.immutable.:: and scala.collection.immutable.Nil).

    ##### Console Output

    For basic console output, `Predef` provides convenience methods print and println, which are aliases of the methods in the object scala.Console.

    ##### Assertions

    A set of `assert` functions are provided for use as a way to document and dynamically check invariants in code. Invocations of `assert` can be elided at compile time by providing the command line option `-Xdisable-assertions`, which raises `-Xelide-below` above `elidable.ASSERTION`, to the `scalac` command.

    Variants of `assert` intended for use with static analysis tools are also provided: `assume`, `require` and `ensuring`. `require` and `ensuring` are intended for use as a means of design-by-contract style specification of pre- and post-conditions on functions, with the intention that these specifications could be consumed by a static analysis tool. For instance,

        def addNaturals(nats: List[Int]): Int = {
          require(nats forall (_ >= 0), "List contains negative numbers")
          nats.foldLeft(0)(_ + _)
        } ensuring(_ >= 0)

    The declaration of `addNaturals` states that the list of integers passed should only contain natural numbers (i.e. non-negative), and that the result returned will also be natural. `require` is distinct from `assert` in that if the condition fails, then the caller of the function is to blame rather than a logical error having been made within `addNaturals` itself. `ensuring` is a form of `assert` that declares the guarantee the function is providing with regards to its return value.

    ##### Implicit Conversions

    A number of commonly applied implicit conversions are also defined here, and in the parent type scala.LowPriorityImplicits. Implicit conversions are provided for the "widening" of numeric values, for instance, converting a Short value to a Long value as required, and to add additional higher-order functions to Array values. These are described in more detail in the documentation of scala.Array.

42.  object Product1
43.  object Product10
44.  object Product11
45.  object Product12
46.  object Product13
47.  object Product14
48.  object Product15
49.  object Product16
50.  object Product17
51.  object Product18
52.  object Product19
53.  object Product2
54.  object Product20
55.  object Product21
56.  object Product22
57.  object Product3
58.  object Product4
59.  object Product5
60.  object Product6
61.  object Product7
62.  object Product8
63.  object Product9
64.  object Proxy
65.  object Short extends AnyValCompanion
66.  object Specializable
67.  object StringContext extends Serializable
68.  object Symbol extends UniquenessCache[String, Symbol] with Serializable
69.  object Unit extends AnyValCompanion
70.  object language

    The `scala.language` object controls the language features available to the programmer, as proposed in the SIP-18 document.

    The `scala.language` object controls the language features available to the programmer, as proposed in the SIP-18 document.

    Each of these features has to be explicitly imported into the current scope to become available:

        import language.postfixOps // or language._
        List(1, 2, 3) reverse

    The language features are:

    - `dynamics` enables defining calls rewriting using the `Dynamic` trait
    - `postfixOps` enables postfix operators
    - `reflectiveCalls` enables using structural types
    - `implicitConversions` enables defining implicit methods and members
    - `higherKinds` enables writing higher-kinded types
    - `existentials` enables writing existential types
    - `experimental` contains newer features that have not yet been tested in production
71.  object languageFeature

### Deprecated Value Members

1.  object Responder extends Serializable

   This object contains utility methods to build responders.

   This object contains utility methods to build responders.

   Annotations
     @deprecated
   Deprecated

     (Since version 2.11.0) this object will be removed

   Version

     1.0

   Since

     2.1

   See also

     class Responder

### Inherited from AnyRef

### Inherited from Any

### Ungrouped