Packages

p

scala

package scala

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

Source
package.scala
Linear Supertypes
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. Protected

Package Members

  1. package annotation
  2. package beans
  3. package collection
  4. package compat
  5. 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 https://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 Futures, 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 words = Files.readAllLines("/etc/dictionaries-common/words").asScala
      words.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")
    }
  6. package io
  7. package jdk

    The jdk package contains utilities to interact with JDK classes.

    The jdk package contains utilities to interact with JDK classes.

    This packages offers a number of converters, that are able to wrap or copy types from the scala library to equivalent types in the JDK class library and vice versa:

    By convention, converters that wrap an object to provide a different interface to the same underlying data structure use .asScala and .asJava extension methods, whereas converters that copy the underlying data structure use .toScala and .toJava.

    In the javaapi package, the same converters can be found with a java-friendly interface that don't rely on implicit enrichments.

    Additionally, this package offers Accumulators, capable of efficiently traversing JDK Streams.

  8. 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

  9. package ref
  10. package reflect
  11. 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.

  12. package util

Type Members

  1. type ::[+A] = scala.collection.immutable.::[A]
  2. sealed abstract class <:<[-From, +To] extends (From) => To with Serializable

    An instance of A <:< B witnesses that A is a subtype of B.

    An instance of A <:< B witnesses that A is a subtype of B. Requiring an implicit argument of the type A <:< B encodes the generalized constraint A <: B.

    To constrain any abstract type T that's in scope in a method's argument list (not just the method's own type parameters) simply add an implicit argument of type T <:< U, where U is the required upper bound; or for lower-bounds, use: L <:< T, where L is the required lower bound.

    In case of any confusion over which method goes in what direction, all the "Co" methods (including apply) go from left to right in the type ("with" the type), and all the "Contra" methods go from right to left ("against" the type). E.g., apply turns a From into a To, and substituteContra replaces the Tos in a type with Froms.

    In part contributed by Jason Zaugg.

    From

    a type which is proved a subtype of To

    To

    a type which is proved a supertype of From

    Annotations
    @implicitNotFound()
    Example:
    1. scala.Option#flatten

      sealed trait Option[+A] {
        // def flatten[B, A <: Option[B]]: Option[B] = ...
        // won't work, since the A in flatten shadows the class-scoped A.
        def flatten[B](implicit ev: A <:< Option[B]): Option[B]
          = if(isEmpty) None else ev(get)
        // Because (A <:< Option[B]) <: (A => Option[B]), ev can be called to turn the
        // A from get into an Option[B], and because ev is implicit, that call can be
        // left out and inserted automatically.
      }
    See also

    =:= for expressing equality constraints

  3. sealed abstract class =:=[From, To] extends <:<[From, To] with Serializable

    An instance of A =:= B witnesses that the types A and B are equal.

    An instance of A =:= B witnesses that the types A and B are equal. It also acts as a A <:< B, but not a B <:< A (directly) due to restrictions on subclassing.

    In case of any confusion over which method goes in what direction, all the "Co" methods (including apply) go from left to right in the type ("with" the type), and all the "Contra" methods go from right to left ("against" the type). E.g., apply turns a From into a To, and substituteContra replaces the Tos in a type with Froms.

    From

    a type which is proved equal to To

    To

    a type which is proved equal to From

    Annotations
    @implicitNotFound()
    Example:
    1. An in-place variant of scala.collection.mutable.ArrayBuffer#transpose

      implicit class BufOps[A](private val buf: ArrayBuffer[A]) extends AnyVal {
        def inPlaceTranspose[E]()(implicit ev: A =:= ArrayBuffer[E]) = ???
        // Because ArrayBuffer is invariant, we can't make do with just a A <:< ArrayBuffer[E]
        // Getting buffers *out* from buf would work, but adding them back *in* wouldn't.
      }
    See also

    <:< for expressing subtyping constraints

  4. type AbstractMethodError = java.lang.AbstractMethodError
  5. 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 defs 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.

  6. 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:

    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 defs, but no vals, vars, or nested traits, classes or objects.
    • 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.

  7. 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 ", "))
    }

    No explicit main method is needed. Instead, the whole class body becomes the “main method”.

    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.

    Future versions of this trait will no longer extend DelayedInit.

    In Scala 3, the DelayedInit feature was dropped. App exists only in a limited form that also does not support command line arguments and will be deprecated in the future.

    @main methods are the recommended scheme to generate programs that can be invoked from the command line in Scala 3.

    @main def runMyProgram(args: String*): Unit = {
      // your program here
    }

    If programs need to cross-build between Scala 2 and Scala 3, it is recommended to use an explicit main method:

    object Main {
      def main(args: Array[String]): Unit = {
        // your program here
      }
    }
    Annotations
    @nowarn()
  8. 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.ArrayOps (shown on line 4 of the example above) and a conversion to scala.collection.mutable.ArraySeq (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 ArraySeq is permanent as all operations return a ArraySeq.

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

    val arr = Array(1, 2, 3)
    val arrReversed = arr.reverse
    val seqReversed : collection.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 ArraySeq first and invoking the variant of reverse that returns another ArraySeq.

    See also

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

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

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

  9. type ArrayIndexOutOfBoundsException = java.lang.ArrayIndexOutOfBoundsException
  10. type BigDecimal = scala.math.BigDecimal
  11. type BigInt = scala.math.BigInt
  12. 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.

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

  14. 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.

  15. type ClassCastException = java.lang.ClassCastException
  16. type Cloneable = java.lang.Cloneable
  17. 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.

  18. final class DummyImplicit extends AnyRef

    A type for which there is always an implicit value.

  19. 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.

  20. type Either[+A, +B] = scala.util.Either[A, B]
  21. 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 enumeration.

    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).

    Values SHOULD NOT be added to an enumeration after its construction; doing so makes the enumeration thread-unsafe. If values are added to an enumeration from multiple threads (in a non-synchronized fashion) after construction, the behavior of the enumeration is undefined.

    Annotations
    @SerialVersionUID()
    Examples:
    1. // 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
    2. ,
    3. // Example of adding attributes to an enumeration by extending the Enumeration.Val class
      object Planet extends Enumeration {
        protected case class PlanetVal(mass: Double, radius: Double) extends super.Val {
          def surfaceGravity: Double = Planet.G * mass / (radius * radius)
          def surfaceWeight(otherMass: Double): Double = otherMass * surfaceGravity
        }
        import scala.language.implicitConversions
        implicit def valueToPlanetVal(x: Value): PlanetVal = x.asInstanceOf[PlanetVal]
      
        val G: Double = 6.67300E-11
        val Mercury = PlanetVal(3.303e+23, 2.4397e6)
        val Venus   = PlanetVal(4.869e+24, 6.0518e6)
        val Earth   = PlanetVal(5.976e+24, 6.37814e6)
        val Mars    = PlanetVal(6.421e+23, 3.3972e6)
        val Jupiter = PlanetVal(1.9e+27, 7.1492e7)
        val Saturn  = PlanetVal(5.688e+26, 6.0268e7)
        val Uranus  = PlanetVal(8.686e+25, 2.5559e7)
        val Neptune = PlanetVal(1.024e+26, 2.4746e7)
      }
      
      println(Planet.values.filter(_.radius > 7.0e6))
      // output:
      // Planet.ValueSet(Jupiter, Saturn, Uranus, Neptune)
  22. 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.

  23. type Equiv[T] = scala.math.Equiv[T]
  24. type Error = java.lang.Error
  25. type Exception = java.lang.Exception
  26. 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.

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

    A function of 0 parameters.

    A function of 0 parameters.

    In the following example, the definition of greeting is shorthand, conceptually, for the anonymous class definition anonfun0, although the implementation details of how the function value is constructed may differ:

     object Main extends App {
       val name = "world"
       val greeting = () => s"hello, $name"
    
       val anonfun0 = new Function0[String] {
         def apply(): String = s"hello, $name"
       }
       assert(greeting() == anonfun0())
    }
  29. 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 shorthand, conceptually, for the anonymous class definition anonfun1, although the implementation details of how the function value is constructed may differ:

     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()
  30. trait Function10[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, +R] extends AnyRef

    A function of 10 parameters.

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

    A function of 11 parameters.

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

    A function of 12 parameters.

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

    A function of 13 parameters.

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

    A function of 14 parameters.

  35. 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.

  36. 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.

  37. 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.

  38. 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.

  39. 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.

  40. 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 shorthand, conceptually, for the anonymous class definition anonfun2, although the implementation details of how the function value is constructed may differ:

     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))
    }
  41. 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.

  42. 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.

  43. 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.

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

    A function of 3 parameters.

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

    A function of 4 parameters.

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

    A function of 5 parameters.

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

    A function of 6 parameters.

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

    A function of 7 parameters.

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

    A function of 8 parameters.

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

    A function of 9 parameters.

  51. type IllegalArgumentException = java.lang.IllegalArgumentException
  52. type IndexOutOfBoundsException = java.lang.IndexOutOfBoundsException
  53. type IndexedSeq[+A] = scala.collection.immutable.IndexedSeq[A]
    Annotations
    @migration
    Migration

    (Changed in version 2.13.0) scala.IndexedSeq is now scala.collection.immutable.IndexedSeq instead of scala.collection.IndexedSeq

  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 IterableOnce[+A] = scala.collection.IterableOnce[A]
  59. type Iterator[+A] = scala.collection.Iterator[A]
  60. type LazyList[+A] = scala.collection.immutable.LazyList[A]
  61. type Left[+A, +B] = scala.util.Left[A, B]
  62. type List[+A] = scala.collection.immutable.List[A]
  63. 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.

  64. 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.

  65. type NoSuchElementException = java.util.NoSuchElementException
  66. 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.???.

  67. 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.

  68. 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 the type of the null literal. It is a subtype of every type except those of value classes. Value classes are subclasses of AnyVal, which includes primitive types such as Int, Boolean, and user-defined value classes.

    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.

  69. type NullPointerException = java.lang.NullPointerException
  70. type NumberFormatException = java.lang.NumberFormatException
  71. type Numeric[T] = scala.math.Numeric[T]
  72. sealed abstract class Option[+A] extends IterableOnce[A] with 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.

    These are useful methods that exist for both scala.Some and None.

    • isDefined — True if not empty
    • isEmpty — True if empty
    • nonEmpty — True if not empty
    • orElse — Evaluate and return alternate optional value if empty
    • getOrElse — Evaluate and return alternate value if empty
    • get — Return value, throw exception if empty
    • fold — Apply function on optional value, return default if empty
    • map — Apply a function on the optional value
    • flatMap — Same as map but function must return an optional value
    • foreach — Apply a procedure on option value
    • collect — Apply partial pattern match on optional value
    • filter — An optional value satisfies predicate
    • filterNot — An optional value doesn't satisfy predicate
    • exists — Apply predicate on optional value, or false if empty
    • forall — Apply predicate on optional value, or true if empty
    • contains — Checks if value equals optional value, or false if empty
    • zip — Combine two optional values to make a paired optional value
    • unzip — Split an optional pair to two optional values
    • unzip3 — Split an optional triple to three optional values
    • toList — Unary list of optional value, otherwise the empty list

    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")
    }

    Interacting with code that can occasionally return null can be safely wrapped in scala.Option to become None and scala.Some otherwise.

    val abc = new java.util.HashMap[Int, String]
    abc.put(1, "A")
    bMaybe = Option(abc.get(2))
    bMaybe match {
      case Some(b) =>
        println(s"Found $b")
      case None =>
        println("Not found")
    }
    Annotations
    @SerialVersionUID()
    Note

    Many of the methods in here are duplicative with those in the Iterable 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.

  73. type Ordered[T] = scala.math.Ordered[T]
  74. type Ordering[T] = scala.math.Ordering[T]
  75. 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 x => x / 0 }   // ArithmeticException: / by zero

    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 usual way to respect this contract is to call applyOrElse, which is expected to be more efficient than calling both isDefinedAt and apply.

    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
    def isEven(n: Int) = n % 2 == 0
    val eveningNews: PartialFunction[Int, String] = {
      case x if isEven(x) => s"$x is even"
    }
    
    // The method collect is described as "filter + map"
    // because it uses a PartialFunction to select elements
    // to which the function is applied.
    val evenNumbers = sample.collect(eveningNews)
    
    val oddlyEnough: PartialFunction[Int, String] = {
      case x if !isEven(x) => s"$x is odd"
    }
    
    // The method orElse allows chaining another PartialFunction
    // to handle input outside the declared domain.
    val numbers = sample.map(eveningNews orElse oddlyEnough)
    
    // same as
    val numbers = sample.map(n => eveningNews.applyOrElse(n, oddlyEnough))
    
    val half: PartialFunction[Int, Int] = {
      case x if isEven(x) => x / 2
    }
    
    // Calculating the domain of a composition can be expensive.
    val oddByHalf = half.andThen(oddlyEnough)
    
    // Invokes `half.apply` on even elements!
    val oddBalls = sample.filter(oddByHalf.isDefinedAt)
    
    // Better than filter(oddByHalf.isDefinedAt).map(oddByHalf)
    val oddBalls = sample.collect(oddByHalf)
    
    // Providing "default" values.
    val oddsAndEnds = sample.map(n => oddByHalf.applyOrElse(n, (i: Int) => s"[$i]"))
    Note

    Optional Functions, PartialFunctions and extractor objects can be converted to each other as shown in the following table.  

    How to convert ...

    to a PartialFunction

    to an optional Function

    to an extractor

    from a PartialFunction

    Predef.identity

    lift

    Predef.identity

    from optional Function

    Function1.UnliftOps#unlift or Function.unlift

    Predef.identity

    Function1.UnliftOps#unlift

    from an extractor

    { case extractor(x) => x }

    extractor.unapply _

    Predef.identity

     

  76. type PartialOrdering[T] = scala.math.PartialOrdering[T]
  77. type PartiallyOrdered[T] = scala.math.PartiallyOrdered[T]
  78. 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.

  79. trait Product1[+T1] extends Product

    Product1 is a Cartesian product of 1 component.

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

    Product10 is a Cartesian product of 10 components.

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

    Product11 is a Cartesian product of 11 components.

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

    Product12 is a Cartesian product of 12 components.

  83. 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.

  84. 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.

  85. 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.

  86. 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.

  87. 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.

  88. 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.

  89. 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.

  90. trait Product2[+T1, +T2] extends Product

    Product2 is a Cartesian product of 2 components.

  91. 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.

  92. 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.

  93. 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.

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

    Product3 is a Cartesian product of 3 components.

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

    Product4 is a Cartesian product of 4 components.

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

    Product5 is a Cartesian product of 5 components.

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

    Product6 is a Cartesian product of 6 components.

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

    Product7 is a Cartesian product of 7 components.

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

    Product8 is a Cartesian product of 8 components.

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

    Product9 is a Cartesian product of 9 components.

  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.immutable.Seq[A]
    Annotations
    @migration
    Migration

    (Changed in version 2.13.0) scala.Seq is now scala.collection.immutable.Seq instead of scala.collection.Seq

  106. class SerialVersionUID extends Annotation with ConstantAnnotation

    Annotation for specifying the serialVersionUID field of a (serializable) class.

    Annotation for specifying the serialVersionUID field of a (serializable) class.

    On the JVM, a class with this annotation will receive a private, static, and final field called serialVersionUID with the provided value, which the JVM's serialization mechanism uses to determine serialization compatibility between different versions of a class.

    Annotations
    @deprecatedInheritance()
    See also

    java.io.Serializable

    Serializable

  107. type Serializable = java.io.Serializable
  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 trait Singleton extends Any

    Singleton is used by the compiler as a supertype for singleton types.

    Singleton is used by the compiler as a supertype for singleton types. This includes literal types, as they are also singleton types.

    scala> object A { val x = 42 }
    defined object A
    
    scala> implicitly[A.type <:< Singleton]
    res12: A.type <:< Singleton = generalized constraint
    
    scala> implicitly[A.x.type <:< Singleton]
    res13: A.x.type <:< Singleton = generalized constraint
    
    scala> implicitly[42 <:< Singleton]
    res14: 42 <:< Singleton = generalized constraint
    
    scala> implicitly[Int <:< Singleton]
    ^
    error: Cannot prove that Int <:< Singleton.

    Singleton has a special meaning when it appears as an upper bound on a formal type parameter. Normally, type inference in Scala widens singleton types to the underlying non-singleton type. When a type parameter has an explicit upper bound of Singleton, the compiler infers a singleton type.

    scala> def check42[T](x: T)(implicit ev: T =:= 42): T = x
    check42: [T](x: T)(implicit ev: T =:= 42)T
    
    scala> val x1 = check42(42)
    ^
    error: Cannot prove that Int =:= 42.
    
    scala> def singleCheck42[T <: Singleton](x: T)(implicit ev: T =:= 42): T = x
    singleCheck42: [T <: Singleton](x: T)(implicit ev: T =:= 42)T
    
    scala> val x2 = singleCheck42(42)
    x2: Int = 42

    See also SIP-23 about Literal-based Singleton Types.

  110. 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()
  111. 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.

  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.

  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.

  116. type Throwable = java.lang.Throwable
  117. 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

  118. 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

  119. 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

  120. 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

  121. 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

  122. 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

  123. 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

  124. 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

  125. 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

  126. 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

  127. 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

  128. 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

  129. 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

  130. 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

  131. 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

  132. 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

  133. 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

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

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

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

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

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

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

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

  141. type UnsupportedOperationException = java.lang.UnsupportedOperationException
  142. final class ValueOf[T] extends AnyVal

    ValueOf[T] provides the unique value of the type T where T is a type which has a single inhabitant.

    ValueOf[T] provides the unique value of the type T where T is a type which has a single inhabitant. Eligible types are singleton types of the form stablePath.type, Unit and singleton types corresponding to value literals.

    The value itself can conveniently be retrieved with Predef#valueOf, which requires a ValueOf to be available in implicit scope.

    The compiler provides instances of ValueOf[T] for all eligible types. Typically an instance would be required where a runtime value corresponding to a type level computation is needed.

    For example, we might define a type Residue[M <: Int] corresponding to the group of integers modulo M. We could then mandate that residues can be summed only when they are parameterized by the same modulus,

    case class Residue[M <: Int](n: Int) extends AnyVal {
      def +(rhs: Residue[M])(implicit m: ValueOf[M]): Residue[M] =
        Residue((this.n + rhs.n) % valueOf[M])
    }
    
    val fiveModTen = Residue[10](5)
    val nineModTen = Residue[10](9)
    
    fiveModTen + nineModTen    // OK == Residue[10](4)
    
    val fourModEleven = Residue[11](4)
    
    fiveModTen + fourModEleven // compiler error: type mismatch;
                               //   found   : Residue[11]
                               //   required: Residue[10]

    Notice that here the modulus is encoded in the type of the values and so does not incur any additional per-value storage cost. When a runtime value of the modulus is required in the implementation of + it is provided at the call site via the implicit argument m of type ValueOf[M].

    Annotations
    @implicitNotFound()
  143. type Vector[+A] = scala.collection.immutable.Vector[A]
  144. class deprecated extends Annotation with ConstantAnnotation

    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.13.x release will be preserved in all 2.13.x releases, but may be removed in the future. (A deprecated element might be kept longer to ease migration, but developers should not rely on this.)

    Annotations
    @getter() @setter() @beanGetter() @beanSetter() @field() @deprecatedInheritance()
    See also

    The official documentation on binary compatibility.

    scala.deprecatedInheritance

    scala.deprecatedOverriding

    scala.deprecatedName

  145. final class deprecatedInheritance extends Annotation with ConstantAnnotation

    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 finalized.

    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()
    See also

    scala.deprecated

    scala.deprecatedOverriding

    scala.deprecatedName

  146. 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() @deprecatedInheritance()
    See also

    scala.deprecated

    scala.deprecatedInheritance

    scala.deprecatedOverriding

  147. class deprecatedOverriding extends Annotation with ConstantAnnotation

    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 finalized.

    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() @deprecatedInheritance()
    See also

    scala.deprecated

    scala.deprecatedInheritance

    scala.deprecatedName

  148. class inline extends Annotation with StaticAnnotation

    An annotation for methods that the optimizer should inline.

    An annotation for methods that the optimizer should inline.

    Note that by default, the Scala optimizer is disabled and no callsites are inlined. See -opt:help for information on how to enable the optimizer and inliner.

    When inlining is enabled, the inliner will always try to inline methods or callsites annotated @inline (under the condition that inlining from the defining class is allowed, see -opt-inline-from:help). If inlining is not possible, for example because the method is not final, an optimizer warning will be issued. See -opt-warnings:help for details.

    Examples:

    @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 (the inliner heuristics can select the callsite)
     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
    Annotations
    @deprecatedInheritance()
  149. 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).

    Annotations
    @deprecatedInheritance()
  150. final class noinline extends Annotation with StaticAnnotation

    An annotation for methods that the optimizer should not inline.

    An annotation for methods that the optimizer should not inline.

    Note that by default, the Scala optimizer is disabled and no callsites are inlined. See -opt:help for information how to enable the optimizer and inliner.

    When inlining is enabled, the inliner will never inline methods or callsites annotated @noinline.

    Examples:

    @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 (the inliner heuristics can select the callsite)
     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
  151. final 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] ..
  152. final 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()
    }
  153. final class transient extends Annotation with StaticAnnotation
    Annotations
    @field()
  154. final 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 and reachability 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 }
    }
  155. final class volatile extends Annotation with StaticAnnotation
    Annotations
    @field()

Deprecated Type Members

  1. type BufferedIterator[+A] = scala.collection.BufferedIterator[A]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.13.0) Use scala.collection.BufferedIterator instead of scala.BufferedIterator

  2. 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

    See also

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

  3. 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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.13.0) Explicitly override hashCode, equals and toString instead.

  4. type Stream[+A] = scala.collection.immutable.Stream[A]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.13.0) Use LazyList instead of Stream

  5. type Traversable[+A] = scala.collection.Iterable[A]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.13.0) Use Iterable instead of Traversable

  6. type TraversableOnce[+A] = scala.collection.IterableOnce[A]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.13.0) Use IterableOnce instead of TraversableOnce

  7. final class UninitializedError extends RuntimeException

    This class represents uninitialized variable/value errors.

    This class represents uninitialized variable/value errors.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.12.7) will be removed in a future release

Value Members

  1. val +:: scala.collection.+:.type
  2. val :+: scala.collection.:+.type
  3. val ::: scala.collection.immutable.::.type
  4. val AnyRef: Specializable
  5. val BigDecimal: scala.math.BigDecimal.type
  6. val BigInt: scala.math.BigInt.type
  7. val Either: scala.util.Either.type
  8. val Equiv: scala.math.Equiv.type
  9. val Fractional: scala.math.Fractional.type
  10. val IndexedSeq: scala.collection.immutable.IndexedSeq.type
  11. val Integral: scala.math.Integral.type
  12. val Iterable: scala.collection.Iterable.type
  13. val Iterator: scala.collection.Iterator.type
  14. val LazyList: scala.collection.immutable.LazyList.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.immutable.Seq.type
  24. val StringBuilder: scala.collection.mutable.StringBuilder.type
  25. val Vector: scala.collection.immutable.Vector.type
  26. object #::
  27. object <:< extends java.io.Serializable
  28. object Array extends java.io.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).

  29. object Boolean extends AnyValCompanion
  30. object Byte extends AnyValCompanion
  31. object Char extends AnyValCompanion
  32. object Console extends 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)

  33. object Double extends AnyValCompanion
  34. object DummyImplicit
  35. object Float extends AnyValCompanion
  36. object Function

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

  37. object Function1
  38. object Int extends AnyValCompanion
  39. object Long extends AnyValCompanion
  40. case 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()
  41. object Option extends java.io.Serializable
  42. 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 }
  43. object Predef extends LowPriorityImplicits

    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 and scala.collection.immutable.Set.

    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.

  44. object Product1
  45. object Product10
  46. object Product11
  47. object Product12
  48. object Product13
  49. object Product14
  50. object Product15
  51. object Product16
  52. object Product17
  53. object Product18
  54. object Product19
  55. object Product2
  56. object Product20
  57. object Product21
  58. object Product22
  59. object Product3
  60. object Product4
  61. object Product5
  62. object Product6
  63. object Product7
  64. object Product8
  65. object Product9
  66. object Short extends AnyValCompanion
  67. object Specializable
  68. object StringContext extends java.io.Serializable
  69. object Symbol extends UniquenessCache[String, Symbol] with java.io.Serializable
  70. object Unit extends AnyValCompanion
    Annotations
    @compileTimeOnly(message = "`Unit` companion object is not allowed in source; instead, use `()` for the unit value")
  71. 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:

  72. object languageFeature

Deprecated Value Members

  1. val Stream: scala.collection.immutable.Stream.type
    Annotations
    @deprecated
    Deprecated

    (Since version 2.13.0) Use LazyList instead of Stream

  2. val Traversable: scala.collection.Iterable.type
    Annotations
    @deprecated
    Deprecated

    (Since version 2.13.0) Use Iterable instead of Traversable

  3. object Proxy
    Annotations
    @deprecated
    Deprecated

    (Since version 2.13.0) All members of this object are deprecated.

Inherited from AnyRef

Inherited from Any

Ungrouped