scala

package scala

Type members

Classlikes

object #::
Source
(source)
sealed abstract class *:[+H, +T <: Tuple] extends NonEmptyTuple
Companion
object
Source
(source)
object *:
Companion
class
Source
(source)
@implicitNotFound(msg = "Cannot prove that ${From} <:< ${To}.")
sealed abstract class <:<[-From, +To] extends From => To with Serializable
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.
Type Params
From
a type which is proved a subtype of To
To
a type which is proved a supertype of From
See also
=:= for expressing equality constraints
Example
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.
}
Companion
object
Source
(source)
object <:<
Companion
class
Source
(source)
@implicitNotFound(msg = "Cannot prove that ${From} =:= ${To}.")
sealed abstract class =:=[From, To] extends From <:< To with Serializable
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.
Type Params
From
a type which is proved equal to To
To
a type which is proved equal to From
See also
<:< for expressing subtyping constraints
Example
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.
}
Source
(source)
@nowarn("cat=deprecation&origin=scala\\.DelayedInit")
trait App extends DelayedInit
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.
Source
(source)
object Array
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).
Companion
class
Source
(source)
final class Array[T](_length: Int) extends Serializable with Cloneable
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 Predef that are frequently applied to arrays: a conversion to collection.ArrayOps (shown on line 4 of the example above) and a conversion to collection.mutable.ArraySeq (a subtype of 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.
Companion
object
Source
(source)
final abstract class Boolean extends AnyVal
Boolean (equivalent to Java's boolean primitive type) is a subtype of AnyVal. Instances of Boolean are not represented by an object in the underlying runtime system.
There is an implicit conversion from Boolean => runtime.RichBoolean which provides useful non-primitive operations.
Companion
object
Source
(source)
object Boolean extends AnyValCompanion
Companion
class
Source
(source)
final abstract class Byte extends AnyVal
Byte, a 8-bit signed integer (equivalent to Java's byte primitive type) is a subtype of AnyVal. Instances of Byte are not represented by an object in the underlying runtime system.
There is an implicit conversion from Byte => runtime.RichByte which provides useful non-primitive operations.
Companion
object
Source
(source)
object Byte extends AnyValCompanion
Companion
class
Source
(source)
@implicitNotFound("Values of types ${L} and ${R} cannot be compared with == or !=")
sealed trait CanEqual[-L, -R]
A marker trait indicating that values of type L can be compared to values of type R.
Companion
object
Source
(source)
object CanEqual
Companion object containing a few universally known CanEqual instances. CanEqual instances involving primitive types or the Null type are handled directly in the compiler (see Implicits.synthesizedCanEqual), so they are not included here.
Companion
class
Source
(source)
final abstract class Char extends AnyVal
Char, a 16-bit unsigned integer (equivalent to Java's char primitive type) is a subtype of AnyVal. Instances of Char are not represented by an object in the underlying runtime system.
There is an implicit conversion from Char => runtime.RichChar which provides useful non-primitive operations.
Companion
object
Source
(source)
object Char extends AnyValCompanion
Companion
class
Source
(source)
object Console extends AnsiColor
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)
Source
(source)
abstract class Conversion[-T, +U] extends T => U
A class for implicit values that can serve as implicit conversions The implicit resolution algorithm will act as if there existed the additional implicit definition:
def $implicitConversion[T, U](x: T)(c: Conversion[T, U]): U = c(x)
However, the presence of this definition would slow down implicit search since its outermost type matches any pair of types. Therefore, implicit search contains a special case in Implicits#discardForView which emulates the conversion in a more efficient way.
Note that this is a SAM class - function literals are automatically converted to the Conversion values.
Also note that in bootstrapped dotty, Predef.<:< should inherit from Conversion. This would cut the number of special cases in discardForView from two to one.
Source
(source)
@deprecated("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", "2.11.0")
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
See also
"Delayed Initialization" subsection of the Scala Language Specification (section 5.1)
Source
(source)
final abstract class Double extends AnyVal
Double, a 64-bit IEEE-754 floating point number (equivalent to Java's double primitive type) is a subtype of AnyVal. Instances of Double are not represented by an object in the underlying runtime system.
There is an implicit conversion from Double => runtime.RichDouble which provides useful non-primitive operations.
Companion
object
Source
(source)
object Double extends AnyValCompanion
Companion
class
Source
(source)
final class DummyImplicit
A type for which there is always an implicit value.
Companion
object
Source
(source)
Companion
class
Source
(source)
trait Dynamic
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.
Source
(source)
object EmptyTuple extends Tuple
A tuple of 0 elements.
Source
(source)
@SerialVersionUID(8476000850333817230L)
abstract class Enumeration(initial: Int) extends Serializable
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.
Value Params
initial
The initial value from which to count the integers that identifies values at run-time.
Example
// 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
// Example of adding attributes to an enumeration by extending the Enumeration.Val class
object Planet extends Enumeration {
 protected case class Val(mass: Double, radius: Double) extends super.Val {
   def surfaceGravity: Double = Planet.G * mass / (radius * radius)
   def surfaceWeight(otherMass: Double): Double = otherMass * surfaceGravity
 }
 import scala.language.implicitConversions
 implicit def valueToPlanetVal(x: Value): Val = x.asInstanceOf[Val]
 val G: Double = 6.67300E-11
 val Mercury = Val(3.303e+23, 2.4397e6)
 val Venus   = Val(4.869e+24, 6.0518e6)
 val Earth   = Val(5.976e+24, 6.37814e6)
 val Mars    = Val(6.421e+23, 3.3972e6)
 val Jupiter = Val(1.9e+27, 7.1492e7)
 val Saturn  = Val(5.688e+26, 6.0268e7)
 val Uranus  = Val(8.686e+25, 2.5559e7)
 val Neptune = Val(1.024e+26, 2.4746e7)
}
println(Planet.values.filter(_.radius > 7.0e6))
// output:
// Planet.ValueSet(Jupiter, Saturn, Uranus, Neptune)
Source
(source)
trait Equals
An interface containing operations for equality. The only method not already present in class AnyRef is canEqual.
Source
(source)
final abstract class Float extends AnyVal
Float, a 32-bit IEEE-754 floating point number (equivalent to Java's float primitive type) is a subtype of AnyVal. Instances of Float are not represented by an object in the underlying runtime system.
There is an implicit conversion from Float => runtime.RichFloat which provides useful non-primitive operations.
Companion
object
Source
(source)
object Float extends AnyValCompanion
Companion
class
Source
(source)
object Function
A module defining utility methods for higher-order functional programming.
Source
(source)
trait Function0[@specialized +R] extends AnyRef
A function of 0 parameters.
In the following example, the definition of javaVersion is a shorthand for the anonymous class definition anonfun0:
object Main extends App {
  val javaVersion = () => sys.props("java.version")

  val anonfun0 = new Function0[String] {
    def apply(): String = sys.props("java.version")
  }
  assert(javaVersion() == anonfun0())
}
Source
(source)
object Function1
Companion
class
Source
(source)
@implicitNotFound(msg = "No implicit view available from ${T1} => ${R}.")
trait Function1[@specialized -T1, @specialized +R] extends AnyRef
A function of 1 parameter.
In the following example, the definition of succ is a shorthand for the anonymous class definition anonfun1:
object Main extends App {
  val succ = (x: Int) => x + 1
  val anonfun1 = new Function1[Int, Int] {
    def apply(x: Int): Int = x + 1
  }
  assert(succ(0) == anonfun1(0))
}
Note that the difference between Function1 and PartialFunction is that the latter can specify inputs which it will not handle.
Companion
object
Source
(source)
trait Function10[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, +R] extends AnyRef
A function of 10 parameters.
Source
(source)
trait Function11[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, +R] extends AnyRef
A function of 11 parameters.
Source
(source)
trait Function12[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, +R] extends AnyRef
A function of 12 parameters.
Source
(source)
trait Function13[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, +R] extends AnyRef
A function of 13 parameters.
Source
(source)
trait Function14[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, +R] extends AnyRef
A function of 14 parameters.
Source
(source)
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.
Source
(source)
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.
Source
(source)
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.
Source
(source)
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.
Source
(source)
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.
Source
(source)
trait Function2[@specialized -T1, @specialized -T2, @specialized +R] extends AnyRef
A function of 2 parameters.
In the following example, the definition of max is a shorthand for the anonymous class definition anonfun2:
object Main extends App {
  val max = (x: Int, y: Int) => if (x < y) y else x

  val anonfun2 = new Function2[Int, Int, Int] {
    def apply(x: Int, y: Int): Int = if (x < y) y else x
  }
  assert(max(0, 1) == anonfun2(0, 1))
}
Source
(source)
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.
Source
(source)
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.
Source
(source)
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.
Source
(source)
trait Function3[-T1, -T2, -T3, +R] extends AnyRef
A function of 3 parameters.
Source
(source)
trait Function4[-T1, -T2, -T3, -T4, +R] extends AnyRef
A function of 4 parameters.
Source
(source)
trait Function5[-T1, -T2, -T3, -T4, -T5, +R] extends AnyRef
A function of 5 parameters.
Source
(source)
trait Function6[-T1, -T2, -T3, -T4, -T5, -T6, +R] extends AnyRef
A function of 6 parameters.
Source
(source)
trait Function7[-T1, -T2, -T3, -T4, -T5, -T6, -T7, +R] extends AnyRef
A function of 7 parameters.
Source
(source)
trait Function8[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, +R] extends AnyRef
A function of 8 parameters.
Source
(source)
trait Function9[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, +R] extends AnyRef
A function of 9 parameters.
Source
(source)
object IArray
Source
(source)
final abstract class Int extends AnyVal
Int, a 32-bit signed integer (equivalent to Java's int primitive type) is a subtype of AnyVal. Instances of Int are not represented by an object in the underlying runtime system.
There is an implicit conversion from Int => runtime.RichInt which provides useful non-primitive operations.
Companion
object
Source
(source)
object Int extends AnyValCompanion
Companion
class
Source
(source)
final abstract class Long extends AnyVal
Long, a 64-bit signed integer (equivalent to Java's long primitive type) is a subtype of AnyVal. Instances of Long are not represented by an object in the underlying runtime system.
There is an implicit conversion from Long => runtime.RichLong which provides useful non-primitive operations.
Companion
object
Source
(source)
object Long extends AnyValCompanion
Companion
class
Source
(source)
final class MatchError(obj: Any) extends RuntimeException
This class implements errors which are thrown whenever an object doesn't match any pattern of a pattern matching expression.
Source
(source)
sealed trait NonEmptyTuple extends Tuple
Tuple of arbitrary non-zero arity
Source
(source)
@SerialVersionUID(5066590221178148012L)
case object None extends Option[Nothing]
This case object represents non-existent values.
Source
(source)
final class NotImplementedError(msg: String) extends Error
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.???.
Source
(source)
object Option
Companion
class
Source
(source)
@SerialVersionUID(-114498752079829388L)
sealed abstract class Option[+A] extends IterableOnce[A] with Product with Serializable
Represents optional values. Instances of Option are either an instance of Some or the object None.
The most idiomatic way to use an 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 Option values without having to check for the existence of a value.
These are useful methods that exist for both 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 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 Option to become None and 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")
}
Note
Many of the methods in here are duplicative with those in the Traversable hierarchy, but they are duplicated for a reason: the implicit conversion tends to leave one with an Iterable in situations where one could have retained an Option.
Companion
object
Source
(source)
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. The function isDefinedAt allows to test dynamically if a value is in the domain of the function.
Even if isDefinedAt returns true for an a: A, calling apply(a) may still throw an exception, so the following code is legal:
val f: PartialFunction[Int, Any] = { case _ => 1/0 }
It is the responsibility of the caller to call isDefinedAt before calling apply, because if isDefinedAt is false, it is not guaranteed apply will throw an exception to indicate an error condition. If an exception is not thrown, evaluation may result in an arbitrary value.
The main distinction between PartialFunction and Function1 is that the user of a PartialFunction may choose to do something different with input that is declared to be outside its domain. For example:
val sample = 1 to 10
val isEven: PartialFunction[Int, String] = {
  case x if x % 2 == 0 => x+" is even"
}

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

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

// the method orElse allows chaining another partial function to handle
// input outside the declared domain
val numbers = sample map (isEven orElse isOdd)
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 |  
Companion
object
Source
(source)
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 }
Companion
class
Source
(source)
Marker trait for polymorphic function types.
This is the only trait that can be refined with a polymorphic method, as long as that method is called apply, e.g.: PolyFunction { def apply[T_1, ..., T_M](x_1: P_1, ..., x_N: P_N): R } This type will be erased to FunctionN.
Source
(source)
object Predef extends LowPriorityImplicits
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 collection.immutable.Map and 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 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 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 Array.
Source
(source)
trait Product extends Equals
Base trait for all products, which in the standard library include at least Product1 through Product22 and therefore also their subclasses Tuple1 through Tuple22. In addition, all case classes implement Product with synthetically generated methods.
Source
(source)
object Product1
Companion
class
Source
(source)
trait Product1[@specialized(Int, Long, Double) +T1] extends Product
Product1 is a Cartesian product of 1 component.
Companion
object
Source
(source)
object Product10
Companion
class
Source
(source)
trait Product10[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10] extends Product
Product10 is a Cartesian product of 10 components.
Companion
object
Source
(source)
object Product11
Companion
class
Source
(source)
trait Product11[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11] extends Product
Product11 is a Cartesian product of 11 components.
Companion
object
Source
(source)
object Product12
Companion
class
Source
(source)
trait Product12[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12] extends Product
Product12 is a Cartesian product of 12 components.
Companion
object
Source
(source)
object Product13
Companion
class
Source
(source)
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.
Companion
object
Source
(source)
object Product14
Companion
class
Source
(source)
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.
Companion
object
Source
(source)
object Product15
Companion
class
Source
(source)
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.
Companion
object
Source
(source)
object Product16
Companion
class
Source
(source)
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.
Companion
object
Source
(source)
object Product17
Companion
class
Source
(source)
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.
Companion
object
Source
(source)
object Product18
Companion
class
Source
(source)
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.
Companion
object
Source
(source)
object Product19
Companion
class
Source
(source)
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.
Companion
object
Source
(source)
object Product2
Companion
class
Source
(source)
trait Product2[@specialized(Int, Long, Double) +T1, @specialized(Int, Long, Double) +T2] extends Product
Product2 is a Cartesian product of 2 components.
Companion
object
Source
(source)
object Product20
Companion
class
Source
(source)
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.
Companion
object
Source
(source)
object Product21
Companion
class
Source
(source)
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.
Companion
object
Source
(source)
object Product22
Companion
class
Source
(source)
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.
Companion
object
Source
(source)
object Product3
Companion
class
Source
(source)
trait Product3[+T1, +T2, +T3] extends Product
Product3 is a Cartesian product of 3 components.
Companion
object
Source
(source)
object Product4
Companion
class
Source
(source)
trait Product4[+T1, +T2, +T3, +T4] extends Product
Product4 is a Cartesian product of 4 components.
Companion
object
Source
(source)
object Product5
Companion
class
Source
(source)
trait Product5[+T1, +T2, +T3, +T4, +T5] extends Product
Product5 is a Cartesian product of 5 components.
Companion
object
Source
(source)
object Product6
Companion
class
Source
(source)
trait Product6[+T1, +T2, +T3, +T4, +T5, +T6] extends Product
Product6 is a Cartesian product of 6 components.
Companion
object
Source
(source)
object Product7
Companion
class
Source
(source)
trait Product7[+T1, +T2, +T3, +T4, +T5, +T6, +T7] extends Product
Product7 is a Cartesian product of 7 components.
Companion
object
Source
(source)
object Product8
Companion
class
Source
(source)
trait Product8[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8] extends Product
Product8 is a Cartesian product of 8 components.
Companion
object
Source
(source)
object Product9
Companion
class
Source
(source)
trait Product9[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9] extends Product
Product9 is a Cartesian product of 9 components.
Companion
object
Source
(source)
@deprecated("Explicitly override hashCode, equals and toString instead.", "2.13.0")
trait Proxy
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.
Companion
object
Source
(source)
@deprecated("All members of this object are deprecated.", "2.13.0")
object Proxy
Companion
class
Source
(source)
case class ScalaReflectionException(msg: String) extends Exception
An exception that indicates an error during Scala reflection
Source
(source)
trait Selectable
A marker trait for objects that support structural selection via selectDynamic and applyDynamic
Implementation classes should define, or make available as extension methods, the following two method signatures:
def selectDynamic(name: String): Any def applyDynamic(name: String)(args: Any*): Any =
selectDynamic is invoked for simple selections v.m, whereas applyDynamic is invoked for selections with arguments v.m(...). If there's only one kind of selection, the method supporting the other may be omitted. The applyDynamic can also have a second parameter list of java.lang.Class arguments, i.e. it may alternatively have the signature
def applyDynamic(name: String, paramClasses: Class[_]*)(args: Any*): Any
In this case the call will synthesize Class arguments for the erasure of all formal parameter types of the method in the structural type.
Companion
object
Source
(source)
object Selectable
Companion
class
Source
(source)
@deprecatedInheritance("Scheduled for being final in the future", "2.13.0")
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.
See also
Source
(source)
final abstract class Short extends AnyVal
Short, a 16-bit signed integer (equivalent to Java's short primitive type) is a subtype of AnyVal. Instances of Short are not represented by an object in the underlying runtime system.
There is an implicit conversion from Short => runtime.RichShort which provides useful non-primitive operations.
Companion
object
Source
(source)
object Short extends AnyValCompanion
Companion
class
Source
(source)
@SerialVersionUID(1234815782226070388L)
final case class Some[+A](value: A) extends Option[A]
Class Some[A] represents existing values of type A.
Source
(source)
A common supertype for companions of specializable types. Should not be extended in user code.
Companion
object
Source
(source)
Companion
class
Source
(source)
case class StringContext(parts: String*)
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.
Value Params
parts
The parts that make up the interpolated string, without the expressions that get inserted by interpolation.
Companion
object
Source
(source)
Companion
class
Source
(source)
final class Symbol extends Serializable
This class provides a simple way to get unique objects for equal strings. Since symbols are interned, they can be compared using reference equality. Instances of Symbol can be created easily with Scala's built-in quote mechanism.
For instance, the Scala term 'mysym will invoke the constructor of the Symbol class in the following way: Symbol("mysym").
Companion
object
Source
(source)
object Symbol extends UniquenessCache[String, Symbol]
Companion
class
Source
(source)
sealed trait Tuple extends Product
Tuple of arbitrary arity
Companion
object
Source
(source)
object Tuple
Companion
class
Source
(source)
final case class Tuple1[@specialized(Int, Long, Double) +T1](_1: T1) extends Product1[T1]
A tuple of 1 elements; the canonical representation of a Product1.
Value Params
_1
Element 1 of this Tuple1
Constructor
Create a new tuple with 1 elements.
Source
(source)
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]
A tuple of 10 elements; the canonical representation of a Product10.
Value Params
_1
Element 1 of this Tuple10
_10
Element 10 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
Constructor
Create a new tuple with 10 elements. Note that it is more idiomatic to create a Tuple10 via (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
Source
(source)
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]
A tuple of 11 elements; the canonical representation of a Product11.
Value Params
_1
Element 1 of this Tuple11
_10
Element 10 of this Tuple11
_11
Element 11 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
Constructor
Create a new tuple with 11 elements. Note that it is more idiomatic to create a Tuple11 via (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11)
Source
(source)
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]
A tuple of 12 elements; the canonical representation of a Product12.
Value Params
_1
Element 1 of this Tuple12
_10
Element 10 of this Tuple12
_11
Element 11 of this Tuple12
_12
Element 12 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
Constructor
Create a new tuple with 12 elements. Note that it is more idiomatic to create a Tuple12 via (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12)
Source
(source)
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]
A tuple of 13 elements; the canonical representation of a Product13.
Value Params
_1
Element 1 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
_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
Constructor
Create a new tuple with 13 elements. Note that it is more idiomatic to create a Tuple13 via (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13)
Source
(source)
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]
A tuple of 14 elements; the canonical representation of a Product14.
Value Params
_1
Element 1 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
_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
Constructor
Create a new tuple with 14 elements. Note that it is more idiomatic to create a Tuple14 via (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14)
Source
(source)
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]
A tuple of 15 elements; the canonical representation of a Product15.
Value Params
_1
Element 1 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
_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
Constructor
Create a new tuple with 15 elements. Note that it is more idiomatic to create a Tuple15 via (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15)
Source
(source)
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]
A tuple of 16 elements; the canonical representation of a Product16.
Value Params
_1
Element 1 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
_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
Constructor
Create a new tuple with 16 elements. Note that it is more idiomatic to create a Tuple16 via (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16)
Source
(source)
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]
A tuple of 17 elements; the canonical representation of a Product17.
Value Params
_1
Element 1 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
_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
Constructor
Create a new tuple with 17 elements. Note that it is more idiomatic to create a Tuple17 via (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17)
Source
(source)
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]
A tuple of 18 elements; the canonical representation of a Product18.
Value Params
_1
Element 1 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
_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
Constructor
Create a new tuple with 18 elements. Note that it is more idiomatic to create a Tuple18 via (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18)
Source
(source)
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]
A tuple of 19 elements; the canonical representation of a Product19.
Value Params
_1
Element 1 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
_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
Constructor
Create a new tuple with 19 elements. Note that it is more idiomatic to create a Tuple19 via (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19)
Source
(source)
final case class Tuple2[@specialized(Int, Long, Double, Char, Boolean) +T1, @specialized(Int, Long, Double, Char, Boolean) +T2](_1: T1, _2: T2) extends Product2[T1, T2]
A tuple of 2 elements; the canonical representation of a Product2.
Value Params
_1
Element 1 of this Tuple2
_2
Element 2 of this Tuple2
Constructor
Create a new tuple with 2 elements. Note that it is more idiomatic to create a Tuple2 via (t1, t2)
Source
(source)
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]
A tuple of 20 elements; the canonical representation of a Product20.
Value Params
_1
Element 1 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
_2
Element 2 of this Tuple20
_20
Element 20 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
Constructor
Create a new tuple with 20 elements. Note that it is more idiomatic to create a Tuple20 via (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20)
Source
(source)
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]
A tuple of 21 elements; the canonical representation of a Product21.
Value Params
_1
Element 1 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
_2
Element 2 of this Tuple21
_20
Element 20 of this Tuple21
_21
Element 21 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
Constructor
Create a new tuple with 21 elements. Note that it is more idiomatic to create a Tuple21 via (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21)
Source
(source)
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]
A tuple of 22 elements; the canonical representation of a Product22.
Value Params
_1
Element 1 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
_2
Element 2 of this Tuple22
_20
Element 20 of this Tuple22
_21
Element 21 of this Tuple22
_22
Element 22 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
Constructor
Create a new tuple with 22 elements. Note that it is more idiomatic to create a Tuple22 via (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22)
Source
(source)
final case class Tuple3[+T1, +T2, +T3](_1: T1, _2: T2, _3: T3) extends Product3[T1, T2, T3]
A tuple of 3 elements; the canonical representation of a Product3.
Value Params
_1
Element 1 of this Tuple3
_2
Element 2 of this Tuple3
_3
Element 3 of this Tuple3
Constructor
Create a new tuple with 3 elements. Note that it is more idiomatic to create a Tuple3 via (t1, t2, t3)
Source
(source)
final case class Tuple4[+T1, +T2, +T3, +T4](_1: T1, _2: T2, _3: T3, _4: T4) extends Product4[T1, T2, T3, T4]
A tuple of 4 elements; the canonical representation of a Product4.
Value Params
_1
Element 1 of this Tuple4
_2
Element 2 of this Tuple4
_3
Element 3 of this Tuple4
_4
Element 4 of this Tuple4
Constructor
Create a new tuple with 4 elements. Note that it is more idiomatic to create a Tuple4 via (t1, t2, t3, t4)
Source
(source)
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]
A tuple of 5 elements; the canonical representation of a Product5.
Value Params
_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
Constructor
Create a new tuple with 5 elements. Note that it is more idiomatic to create a Tuple5 via (t1, t2, t3, t4, t5)
Source
(source)
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]
A tuple of 6 elements; the canonical representation of a Product6.
Value Params
_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
Constructor
Create a new tuple with 6 elements. Note that it is more idiomatic to create a Tuple6 via (t1, t2, t3, t4, t5, t6)
Source
(source)
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]
A tuple of 7 elements; the canonical representation of a Product7.
Value Params
_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
Constructor
Create a new tuple with 7 elements. Note that it is more idiomatic to create a Tuple7 via (t1, t2, t3, t4, t5, t6, t7)
Source
(source)
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]
A tuple of 8 elements; the canonical representation of a Product8.
Value Params
_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
Constructor
Create a new tuple with 8 elements. Note that it is more idiomatic to create a Tuple8 via (t1, t2, t3, t4, t5, t6, t7, t8)
Source
(source)
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]
A tuple of 9 elements; the canonical representation of a Product9.
Value Params
_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
Constructor
Create a new tuple with 9 elements. Note that it is more idiomatic to create a Tuple9 via (t1, t2, t3, t4, t5, t6, t7, t8, t9)
Source
(source)
@deprecated("will be removed in a future release", since = "2.12.7")
This class represents uninitialized variable/value errors.
Source
(source)
final case class UninitializedFieldError(msg: String) extends RuntimeException
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.
Source
(source)
final abstract class Unit extends AnyVal
Unit is a subtype of 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.
Companion
object
Source
(source)
@compileTimeOnly("`Unit` companion object is not allowed in source; instead, use `()` for the unit value")
object Unit extends AnyValCompanion
Companion
class
Source
(source)
@implicitNotFound(msg = "No singleton value available for ${T}.")
final class ValueOf[T](val value: T) extends AnyVal
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.
Instances of ValueOf[T] are provided implicitly 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].
Source
(source)
@getter @setter @beanGetter @beanSetter @field @deprecatedInheritance("Scheduled for being final in the future", "2.13.0")
class deprecated(message: String, since: String) extends StaticAnnotation
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.)
Value Params
message
the message to print during compilation if the definition is accessed
since
a string identifying the first version in which the definition was deprecated
See also
Source
(source)
final class deprecatedInheritance(message: String, since: String) extends StaticAnnotation
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
//                   ^
Value Params
message
the message to print during compilation if the class was sub-classed
since
a string identifying the first version in which inheritance was deprecated
See also
Source
(source)
@param @deprecatedInheritance("Scheduled for being final in the future", "2.13.0")
class deprecatedName(name: String, since: String) extends StaticAnnotation
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)
         ^
See also
Source
(source)
@getter @setter @beanGetter @beanSetter @deprecatedInheritance("Scheduled for being final in the future", "2.13.0")
class deprecatedOverriding(message: String, since: String) extends StaticAnnotation
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
//              ^
Value Params
message
the message to print during compilation if the member was overridden
since
a string identifying the first version in which overriding was deprecated
See also
Source
(source)
@deprecatedInheritance("Scheduled for being final in the future", "2.13.0")
class inline extends StaticAnnotation
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
Source
(source)
object language
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:
Source
(source)
class main extends Annotation
An annotation that designates a main function
Source
(source)
@deprecatedInheritance("Scheduled for being final in the future", "2.13.0")
class native extends StaticAnnotation
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).
Source
(source)
final class noinline extends StaticAnnotation
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
Source
(source)
object opaques
An immutable array. An IArray[T] has the same representation as an Array[T], but it cannot be updated. Unlike regular arrays, immutable arrays are covariant.
Source
(source)
final class specialized(group: SpecializedGroup) extends StaticAnnotation
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] ..
Source
(source)
final class throws[T <: Throwable](cause: String) extends StaticAnnotation
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()
}
Source
(source)
final class transient extends StaticAnnotation
Source
(source)
final class unchecked extends Annotation
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 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 }
}
Source
(source)
final class volatile extends StaticAnnotation
Source
(source)

Types

type ::[+A] = ::[A]
Source
(source)
type BigInt = BigInt
Source
(source)
@deprecated("Use scala.collection.BufferedIterator instead of scala.BufferedIterator", "2.13.0")
Source
(source)
type Either[+A, +B] = Either[A, B]
Source
(source)
type EmptyTuple = EmptyTuple
A tuple of 0 elements
Source
(source)
type Equiv[T] = Equiv[T]
Source
(source)
type Error = Error
Source
(source)
type Fractional[T] = Fractional[T]
Source
(source)
type IArray[+T] = IArray[T]
Source
(source)
@migration("scala.IndexedSeq is now scala.collection.immutable.IndexedSeq instead of scala.collection.IndexedSeq", "2.13.0")
type IndexedSeq[+A] = IndexedSeq[A]
Source
(source)
type Integral[T] = Integral[T]
Source
(source)
type Iterable[+A] = Iterable[A]
Source
(source)
type Iterator[+A] = Iterator[A]
Source
(source)
type LazyList[+A] = LazyList[A]
Source
(source)
type Left[+A, +B] = Left[A, B]
Source
(source)
type List[+A] = List[A]
Source
(source)
type Numeric[T] = Numeric[T]
Source
(source)
type Ordered[T] = Ordered[T]
Source
(source)
type Ordering[T] = Ordering[T]
Source
(source)
type Range = Range
Source
(source)
@migration("scala.Seq is now scala.collection.immutable.Seq instead of scala.collection.Seq", "2.13.0")
type Seq[+A] = Seq[A]
Source
(source)
@deprecated("Use LazyList instead of Stream", "2.13.0")
type Stream[+A] = Stream[A]
Source
(source)
@deprecated("Use Iterable instead of Traversable", "2.13.0")
type Traversable[+A] = Iterable[A]
Source
(source)
@deprecated("Use IterableOnce instead of TraversableOnce", "2.13.0")
Source
(source)
type Vector[+A] = Vector[A]
Source
(source)

Value members

Fields

val +:: +:
Source
(source)
val :+: :+
Source
(source)
val ::: ::
Source
(source)
val Equiv: Equiv
Source
(source)
val Left: Left
Source
(source)
val List: List
Source
(source)
val Nil: Nil
Source
(source)
val Range: Range
Source
(source)
val Seq: Seq
Source
(source)
@deprecated("Use LazyList instead of Stream", "2.13.0")
Source
(source)
@deprecated("Use Iterable instead of Traversable", "2.13.0")
Source
(source)