scala
Core Scala types. They are always available without an explicit import.
Attributes
Members list
Packages
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 Future
s, it is often required to have an implicit ExecutionContext
in scope. The general advice for these implicits are as follows.
If the code in question is a class or method definition, and no ExecutionContext
is available, request one from the caller by adding an implicit parameter list:
def myMethod(myParam: MyType)(implicit ec: ExecutionContext) = …
//Or
class MyClass(myParam: MyType)(implicit ec: ExecutionContext) { … }
This allows the caller of the method, or creator of the instance of the class, to decide which ExecutionContext
should be used.
For typical REPL usage and experimentation, importing the global ExecutionContext
is often desired.
import scala.concurrent.ExcutionContext.Implicits.global
Specifying Durations
Operations often require a duration to be specified. A duration DSL is available to make defining these easier:
import scala.concurrent.duration._
val d: Duration = 10.seconds
Using Futures For Non-blocking Computation
Basic use of futures is easy with the factory method on Future, which executes a provided function asynchronously, handing you back a future result of that function without blocking the current thread. In order to create the Future you will need either an implicit or explicit ExecutionContext to be provided:
import scala.concurrent._
import ExecutionContext.Implicits.global // implicit execution context
val firstZebra: Future[Int] = Future {
val 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")
}
Attributes
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:
- CollectionConverters, converting collections like scala.collection.Seq, scala.collection.Map, scala.collection.Set, scala.collection.mutable.Buffer, scala.collection.Iterator and scala.collection.Iterable to their JDK counterparts - OptionConverters, converting between Option and java.util.Optional and primitive variations - StreamConverters, to create JDK Streams from scala collections - DurationConverters, for conversions between scala scala.concurrent.duration.FiniteDuration and java.time.Duration - FunctionConverters, from scala Functions to java java.util.function.Function, java.util.function.UnaryOperator, java.util.function.Consumer and java.util.function.Predicate, as well as primitive variations and Bi-variations.
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.
Attributes
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.
Attributes
- See also
The package object scala.sys
contains methods for reading and altering core aspects of the virtual machine as well as the world outside of it.
The package object scala.sys
contains methods for reading and altering core aspects of the virtual machine as well as the world outside of it.
Attributes
Type members
Classlikes
Attributes
- Source
- package.scala
- Supertypes
- Self type
-
#::.type
Attributes
- Companion
- object
- Source
- Tuple.scala
- Supertypes
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 To
s in a type with From
s.
In part contributed by Jason Zaugg.
Type parameters
- From
-
a type which is proved a subtype of
To
- To
-
a type which is proved a supertype of
From
Attributes
- 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
- typeConstraints.scala
- Supertypes
- Known subtypes
-
Attributes
- Companion
- class
- Source
- typeConstraints.scala
- Supertypes
- Self type
-
<:<.type
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 To
s in a type with From
s.
Type parameters
- From
-
a type which is proved equal to
To
- To
-
a type which is proved equal to
From
Attributes
- See also
-
<:< for expressing subtyping constraints
- Example
-
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. }
- Source
- typeConstraints.scala
- Supertypes
Class Any
is the root of the Scala class hierarchy.
Class Any
is the root of the Scala class hierarchy. Every class in a Scala execution environment inherits directly or indirectly from this class.
Starting with Scala 2.10 it is possible to directly extend Any
using universal traits. A universal trait is a trait that extends Any
, only has def
s as members, and does no initialization.
The main use case for universal traits is to allow basic inheritance of methods for value classes. For example,
trait Printable extends Any {
def print(): Unit = println(this)
}
class Wrapper(val underlying: Int) extends AnyVal with Printable
val w = new Wrapper(3)
w.print()
See the Value Classes and Universal Traits for more details on the interplay of universal traits and value classes.
Attributes
The super-type of all types.
The super-type of all types.
See https://docs.scala-lang.org/scala3/reference/other-new-features/kind-polymorphism.html.
Attributes
Class AnyRef
is the root class of all reference types.
Class AnyRef
is the root class of all reference types. All types except the value types descend from this class.
Attributes
- Known subtypes
-
trait () => Rclass FromJavaBooleanSupplierclass FromJavaDoubleSupplierclass FromJavaIntSupplierclass FromJavaLongSupplierclass FromJavaSupplier[T]trait Reference[T]trait ReferenceWrapper[T]class PhantomReference[T]class SoftReference[T]class WeakReference[T]trait JFunction0$mcB$sptrait JFunction0$mcC$sptrait JFunction0$mcD$sptrait JFunction0$mcF$sptrait JFunction0$mcI$sptrait JFunction0$mcJ$sptrait JFunction0$mcS$sptrait JFunction0$mcV$sptrait JFunction0$mcZ$spclass AbstractFunction0[R]trait T1 => Rtrait Set[A]class AbstractSet[A]class BitSetclass BitSet1class BitSet2class BitSetNclass HashSet[A]class ListSet[A]class Set1[A]class Set2[A]class Set3[A]class Set4[A]class ImmutableKeySortedSetclass TreeSet[A]class ValueSettrait SortedSet[A]class HashSet[A]class LinkedHashSet[A]trait Set[A]class AbstractSet[A]class BitSetclass TreeSet[A]trait SortedSet[A]trait Set[A]class AbstractSet[A]trait SortedSet[A]trait BitSettrait BitSetOps[C]class FromJavaConsumer[T]class FromJavaDoubleConsumerclass FromJavaDoubleFunction[R]class FromJavaDoublePredicateclass FromJavaIntConsumerclass FromJavaIntFunction[R]class FromJavaIntPredicateclass FromJavaIntUnaryOperatorclass FromJavaLongConsumerclass FromJavaLongFunction[R]class FromJavaLongPredicateclass FromJavaPredicate[T]class FromJavaToDoubleFunction[T]class FromJavaToIntFunction[T]class FromJavaToLongFunction[T]class FromJavaUnaryOperator[T]trait JFunction1$mcDD$sptrait JFunction1$mcDF$sptrait JFunction1$mcDI$sptrait JFunction1$mcDJ$sptrait JFunction1$mcFD$sptrait JFunction1$mcFF$sptrait JFunction1$mcFI$sptrait JFunction1$mcFJ$sptrait JFunction1$mcID$sptrait JFunction1$mcIF$sptrait JFunction1$mcII$sptrait JFunction1$mcIJ$sptrait JFunction1$mcJD$sptrait JFunction1$mcJF$sptrait JFunction1$mcJI$sptrait JFunction1$mcJJ$sptrait JFunction1$mcVD$sptrait JFunction1$mcVF$sptrait JFunction1$mcVI$sptrait JFunction1$mcVJ$sptrait JFunction1$mcZD$sptrait JFunction1$mcZF$sptrait JFunction1$mcZI$sptrait JFunction1$mcZJ$spclass IntMap[T]class LongMap[T]class LongMap[V]class SystemPropertiestrait Seq[A]trait Seq[A]class AbstractSeq[A]class ArraySeq[A]class ofBooleanclass ofByteclass ofCharclass ofDoubleclass ofFloatclass ofIntclass ofLongclass ofRef[T]class ofShortclass ofUnitclass LazyList[A]class List[A]class ::[A]object Nilclass NumericRange[T]class Exclusive[T]class Inclusive[T]class Queue[A]class Rangeclass Exclusiveclass Inclusiveclass Stream[A]class Cons[A]object Emptyclass Vector[A]class WrappedStringtrait IndexedSeq[A]trait LinearSeq[A]trait Seq[A]class AbstractSeq[A]class AbstractBuffer[A]class ArrayBuffer[A]class ArrayDeque[A]class Queue[A]class Stack[A]class ListBuffer[A]class UnrolledBuffer[T]class ArraySeq[T]class ofBooleanclass ofByteclass ofCharclass ofDoubleclass ofFloatclass ofIntclass ofLongclass ofRef[T]class ofShortclass ofUnitclass StringBuildertrait Buffer[A]trait IndexedBuffer[A]trait IndexedSeq[T]class AnyAccumulator[A]class DoubleAccumulatorclass IntAccumulatorclass LongAccumulatorclass AbstractSeq[A]trait IndexedSeq[A]trait LinearSeq[A]trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) => Rtrait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) => Rtrait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) => Rtrait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) => Rtrait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) => Rtrait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) => Rtrait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) => Rtrait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) => Rclass AbstractFunction17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R]trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) => Rclass AbstractFunction18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) => Rclass AbstractFunction19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]trait (T1, T2) => Rclass FromJavaBinaryOperator[T]class FromJavaObjDoubleConsumer[T]class FromJavaObjIntConsumer[T]class FromJavaObjLongConsumer[T]trait JFunction2$mcDDD$sptrait JFunction2$mcDDI$sptrait JFunction2$mcDDJ$sptrait JFunction2$mcDID$sptrait JFunction2$mcDII$sptrait JFunction2$mcDIJ$sptrait JFunction2$mcDJD$sptrait JFunction2$mcDJI$sptrait JFunction2$mcDJJ$sptrait JFunction2$mcFDD$sptrait JFunction2$mcFDI$sptrait JFunction2$mcFDJ$sptrait JFunction2$mcFID$sptrait JFunction2$mcFII$sptrait JFunction2$mcFIJ$sptrait JFunction2$mcFJD$sptrait JFunction2$mcFJI$sptrait JFunction2$mcFJJ$sptrait JFunction2$mcIDD$sptrait JFunction2$mcIDI$sptrait JFunction2$mcIDJ$sptrait JFunction2$mcIID$sptrait JFunction2$mcIII$sptrait JFunction2$mcIIJ$sptrait JFunction2$mcIJD$sptrait JFunction2$mcIJI$sptrait JFunction2$mcIJJ$sptrait JFunction2$mcJDD$sptrait JFunction2$mcJDI$sptrait JFunction2$mcJDJ$sptrait JFunction2$mcJID$sptrait JFunction2$mcJII$sptrait JFunction2$mcJIJ$sptrait JFunction2$mcJJD$sptrait JFunction2$mcJJI$sptrait JFunction2$mcJJJ$sptrait JFunction2$mcVDD$sptrait JFunction2$mcVDI$sptrait JFunction2$mcVDJ$sptrait JFunction2$mcVID$sptrait JFunction2$mcVII$sptrait JFunction2$mcVIJ$sptrait JFunction2$mcVJD$sptrait JFunction2$mcVJI$sptrait JFunction2$mcVJJ$sptrait JFunction2$mcZDD$sptrait JFunction2$mcZDI$sptrait JFunction2$mcZDJ$sptrait JFunction2$mcZID$sptrait JFunction2$mcZII$sptrait JFunction2$mcZIJ$sptrait JFunction2$mcZJD$sptrait JFunction2$mcZJI$sptrait JFunction2$mcZJJ$sptrait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) => Rclass AbstractFunction20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) => Rclass AbstractFunction21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R]trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) => Rclass AbstractFunction22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R]trait (T1, T2, T3) => Rtrait (T1, T2, T3, T4) => Rtrait (T1, T2, T3, T4, T5) => Rtrait (T1, T2, T3, T4, T5, T6) => Rtrait (T1, T2, T3, T4, T5, T6, T7) => Rtrait (T1, T2, T3, T4, T5, T6, T7, T8) => Rtrait (T1, T2, T3, T4, T5, T6, T7, T8, T9) => RShow all
AnyVal
is the root class of all value types, which describe values not implemented as objects in the underlying host system.
AnyVal
is the root class of all value types, which describe values not implemented as objects in the underlying host system. Value classes are specified in Scala Language Specification, section 12.2.
The standard implementation includes nine AnyVal
subtypes:
scala.Double, scala.Float, scala.Long, scala.Int, scala.Char, scala.Short, and scala.Byte are the numeric value types.
scala.Unit and scala.Boolean are the non-numeric value types.
Other groupings:
-
The subrange types are scala.Byte, scala.Short, and scala.Char.
-
The integer types include the subrange types as well as scala.Int and scala.Long.
-
The floating point types are scala.Float and scala.Double.
Prior to Scala 2.10, AnyVal
was a sealed trait. Beginning with Scala 2.10, however, it is possible to define a subclass of AnyVal
called a user-defined value class which is treated specially by the compiler. Properly-defined user value classes provide a way to improve performance on user-defined types by avoiding object allocation at runtime, and by replacing virtual method invocations with static method invocations.
User-defined value classes which avoid object allocation...
-
must have a single
val
parameter that is the underlying runtime representation. -
can define
def
s, but noval
s,var
s, or nestedtraits
s,class
es orobject
s. -
typically extend no other trait apart from
AnyVal
. -
cannot be used in type tests or pattern matching.
-
may not override
equals
orhashCode
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.
Attributes
- Supertypes
- Known subtypes
-
class Deferrer[A]class Deferrer[A]class UnwrapOpclass ArrayOps[A]class IterableOnceExtensionMethods[A]class SizeCompareOpsclass UnapplySeqWrapper[A]class Shapeclass StringOpsclass DoubleMultclass DurationDoubleclass DurationIntclass DurationLongclass IntMultclass LongMultclass JavaDurationOpsclass ScalaDurationOpsclass RichBinaryOperatorAsFunction2[T]class RichConsumerAsFunction1[T]class RichDoubleFunctionAsFunction1[R]class RichFunction0AsSupplier[T]class RichFunction1AsConsumer[T]class RichFunction1AsDoubleFunction[R]class RichFunction1AsIntFunction[R]class RichFunction1AsLongFunction[R]class RichFunction1AsPredicate[T]class RichFunction1AsToDoubleFunction[T]class RichFunction1AsToIntFunction[T]class RichFunction1AsToLongFunction[T]class RichFunction1AsUnaryOperator[T]class RichFunction2AsBinaryOperator[T]class RichFunction2AsObjDoubleConsumer[T]class RichFunction2AsObjIntConsumer[T]class RichFunction2AsObjLongConsumer[T]class RichIntFunctionAsFunction1[R]class RichLongFunctionAsFunction1[R]class RichObjDoubleConsumerAsFunction2[T]class RichObjIntConsumerAsFunction2[T]class RichObjLongConsumerAsFunction2[T]class RichPredicateAsFunction1[T]class RichSupplierAsFunction0[T]class RichToDoubleFunctionAsFunction1[T]class RichToIntFunctionAsFunction1[T]class RichToLongFunctionAsFunction1[T]class RichUnaryOperatorAsFunction1[T]class CompletionStageOps[T]class FutureOps[T]class RichOption[A]class RichOptional[A]class RichOptionalDoubleclass RichOptionalIntclass RichOptionalLongclass RichBooleanclass RichByteclass RichCharclass RichDoubleclass RichFloatclass RichIntclass RichLongclass RichShortclass ChainingOps[A]class MergeableEither[A]class UnapplySeqWrapper[T]class Booleanclass Byteclass Charclass Doubleclass Floatclass Intclass Longclass ArrowAssoc[A]class Ensuring[A]class StringFormat[A]class any2stringadd[A]class Shortclass Unitclass ValueOf[T]Show all
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
}
}
Attributes
- Source
- App.scala
- Supertypes
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)
.
Attributes
- Companion
- class
- Source
- Array.scala
- Supertypes
- Self type
-
Array.type
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
.
Attributes
- 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
- Array.scala
- Supertypes
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.
Attributes
- Companion
- object
- Source
- Boolean.scala
- Supertypes
Attributes
- Companion
- class
- Source
- Boolean.scala
- Supertypes
- Self type
-
Boolean.type
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.
Attributes
- Companion
- object
- Source
- Byte.scala
- Supertypes
Attributes
- Companion
- class
- Source
- Byte.scala
- Supertypes
- Self type
-
Byte.type
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 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.
Attributes
- Companion
- trait
- Source
- CanEqual.scala
- Supertypes
- Self type
-
CanEqual.type
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.
Attributes
- Companion
- object
- Source
- Char.scala
- Supertypes
Attributes
- Companion
- class
- Source
- Char.scala
- Supertypes
- Self type
-
Char.type
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) |
Attributes
- Source
- Console.scala
- Supertypes
- Self type
-
Console.type
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:
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.
The Conversion
class can also be used to convert explicitly, using the convert
extension method.
Attributes
- Source
- Conversion.scala
- Supertypes
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.
Attributes
- Companion
- object
- Source
- Double.scala
- Supertypes
Attributes
- Companion
- class
- Source
- Double.scala
- Supertypes
- Self type
-
Double.type
A type for which there is always an implicit value.
A type for which there is always an implicit value.
Attributes
- Companion
- object
- Source
- DummyImplicit.scala
- Supertypes
Attributes
- Companion
- class
- Source
- DummyImplicit.scala
- Supertypes
- Self type
-
DummyImplicit.type
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.
Attributes
- Source
- Dynamic.scala
- Supertypes
-
class Any
A tuple of 0 elements.
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.
Value parameters
- initial
-
The initial value from which to count the integers that identifies values at run-time.
Attributes
- 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 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)
- Source
- Enumeration.scala
- Supertypes
- Known subtypes
-
object RoundingMode
- Self type
An interface containing operations for equality.
An interface containing operations for equality. The only method not already present in class AnyRef
is canEqual
.
Attributes
- Source
- Equals.scala
- Supertypes
-
class Any
- Known subtypes
-
class IntMap[T]class LongMap[T]class LongMap[V]class SystemPropertiestrait Seq[A]trait Seq[A]class AbstractSeq[A]class ArraySeq[A]class ofBooleanclass ofByteclass ofCharclass ofDoubleclass ofFloatclass ofIntclass ofLongclass ofRef[T]class ofShortclass ofUnitclass LazyList[A]class List[A]class ::[A]object Nilclass NumericRange[T]class Exclusive[T]class Inclusive[T]class Queue[A]class Rangeclass Exclusiveclass Inclusiveclass Stream[A]class Cons[A]object Emptyclass Vector[A]class WrappedStringtrait IndexedSeq[A]trait LinearSeq[A]trait Seq[A]class AbstractSeq[A]class AbstractBuffer[A]class ArrayBuffer[A]class ArrayDeque[A]class Queue[A]class Stack[A]class ListBuffer[A]class UnrolledBuffer[T]class ArraySeq[T]class ofBooleanclass ofByteclass ofCharclass ofDoubleclass ofFloatclass ofIntclass ofLongclass ofRef[T]class ofShortclass ofUnitclass StringBuildertrait Buffer[A]trait IndexedBuffer[A]trait IndexedSeq[T]class AnyAccumulator[A]class DoubleAccumulatorclass IntAccumulatorclass LongAccumulatorclass AbstractSeq[A]trait IndexedSeq[A]trait LinearSeq[A]trait Set[A]trait Set[A]class AbstractSet[A]class BitSetclass BitSet1class BitSet2class BitSetNclass HashSet[A]class ListSet[A]class Set1[A]class Set2[A]class Set3[A]class Set4[A]class ImmutableKeySortedSetclass TreeSet[A]class ValueSettrait SortedSet[A]trait Set[A]class AbstractSet[A]class BitSetclass HashSet[A]class LinkedHashSet[A]class TreeSet[A]trait SortedSet[A]class AbstractSet[A]trait SortedSet[A]trait BitSetclass AnyValManifest[T]trait ClassTag[T]trait Manifest[T]trait Producttrait Enumtrait EnumValueclass TupleXXLclass Try[T]class Failure[T]class Success[T]class Option[A]object Noneclass Some[A]trait Product1[T1]class Tuple1[T1]class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)trait Product19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)class (T1, T2)trait Product20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)trait Product21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)trait Product22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)class (T1, T2, T3)class (T1, T2, T3, T4)class (T1, T2, T3, T4, T5)class (T1, T2, T3, T4, T5, T6)class (T1, T2, T3, T4, T5, T6, T7)class (T1, T2, T3, T4, T5, T6, T7, T8)class (T1, T2, T3, T4, T5, T6, T7, T8, T9)trait Tupleobject EmptyTupletrait NonEmptyTupleShow all
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.
Attributes
- Companion
- object
- Source
- Float.scala
- Supertypes
Attributes
- Companion
- class
- Source
- Float.scala
- Supertypes
- Self type
-
Float.type
A module defining utility methods for higher-order functional programming.
A module defining utility methods for higher-order functional programming.
Attributes
- Source
- Function.scala
- Supertypes
- Self type
-
Function.type
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())
}
Attributes
- Source
- Function0.scala
- Supertypes
- Known subtypes
-
class FromJavaBooleanSupplierclass FromJavaDoubleSupplierclass FromJavaIntSupplierclass FromJavaLongSupplierclass FromJavaSupplier[T]trait Reference[T]trait ReferenceWrapper[T]class PhantomReference[T]class SoftReference[T]class WeakReference[T]trait JFunction0$mcB$sptrait JFunction0$mcC$sptrait JFunction0$mcD$sptrait JFunction0$mcF$sptrait JFunction0$mcI$sptrait JFunction0$mcJ$sptrait JFunction0$mcS$sptrait JFunction0$mcV$sptrait JFunction0$mcZ$spclass AbstractFunction0[R]Show all
- Self type
-
() => R
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.
Attributes
- Companion
- object
- Source
- Function1.scala
- Supertypes
- Known subtypes
-
trait Set[A]class AbstractSet[A]class BitSetclass BitSet1class BitSet2class BitSetNclass HashSet[A]class ListSet[A]class Set1[A]class Set2[A]class Set3[A]class Set4[A]class ImmutableKeySortedSetclass TreeSet[A]class ValueSettrait SortedSet[A]class HashSet[A]class LinkedHashSet[A]trait Set[A]class AbstractSet[A]class BitSetclass TreeSet[A]trait SortedSet[A]trait Set[A]class AbstractSet[A]trait SortedSet[A]trait BitSettrait BitSetOps[C]class FromJavaConsumer[T]class FromJavaDoubleConsumerclass FromJavaDoubleFunction[R]class FromJavaDoublePredicateclass FromJavaIntConsumerclass FromJavaIntFunction[R]class FromJavaIntPredicateclass FromJavaIntUnaryOperatorclass FromJavaLongConsumerclass FromJavaLongFunction[R]class FromJavaLongPredicateclass FromJavaPredicate[T]class FromJavaToDoubleFunction[T]class FromJavaToIntFunction[T]class FromJavaToLongFunction[T]class FromJavaUnaryOperator[T]trait JFunction1$mcDD$sptrait JFunction1$mcDF$sptrait JFunction1$mcDI$sptrait JFunction1$mcDJ$sptrait JFunction1$mcFD$sptrait JFunction1$mcFF$sptrait JFunction1$mcFI$sptrait JFunction1$mcFJ$sptrait JFunction1$mcID$sptrait JFunction1$mcIF$sptrait JFunction1$mcII$sptrait JFunction1$mcIJ$sptrait JFunction1$mcJD$sptrait JFunction1$mcJF$sptrait JFunction1$mcJI$sptrait JFunction1$mcJJ$sptrait JFunction1$mcVD$sptrait JFunction1$mcVF$sptrait JFunction1$mcVI$sptrait JFunction1$mcVJ$sptrait JFunction1$mcZD$sptrait JFunction1$mcZF$sptrait JFunction1$mcZI$sptrait JFunction1$mcZJ$spclass IntMap[T]class LongMap[T]class LongMap[V]class SystemPropertiestrait Seq[A]trait Seq[A]class AbstractSeq[A]class ArraySeq[A]class ofBooleanclass ofByteclass ofCharclass ofDoubleclass ofFloatclass ofIntclass ofLongclass ofRef[T]class ofShortclass ofUnitclass LazyList[A]class List[A]class ::[A]object Nilclass NumericRange[T]class Exclusive[T]class Inclusive[T]class Queue[A]class Rangeclass Exclusiveclass Inclusiveclass Stream[A]class Cons[A]object Emptyclass Vector[A]class WrappedStringtrait IndexedSeq[A]trait LinearSeq[A]trait Seq[A]class AbstractSeq[A]class AbstractBuffer[A]class ArrayBuffer[A]class ArrayDeque[A]class Queue[A]class Stack[A]class ListBuffer[A]class UnrolledBuffer[T]class ArraySeq[T]class ofBooleanclass ofByteclass ofCharclass ofDoubleclass ofFloatclass ofIntclass ofLongclass ofRef[T]class ofShortclass ofUnitclass StringBuildertrait Buffer[A]trait IndexedBuffer[A]trait IndexedSeq[T]class AnyAccumulator[A]class DoubleAccumulatorclass IntAccumulatorclass LongAccumulatorclass AbstractSeq[A]trait IndexedSeq[A]trait LinearSeq[A]Show all
- Self type
-
T1 => R
A function of 10 parameters.
A function of 10 parameters.
Attributes
- Source
- Function10.scala
- Supertypes
- Known subtypes
-
- Self type
-
(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) => R
A function of 11 parameters.
A function of 11 parameters.
Attributes
- Source
- Function11.scala
- Supertypes
- Known subtypes
-
- Self type
-
(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) => R
A function of 12 parameters.
A function of 12 parameters.
Attributes
- Source
- Function12.scala
- Supertypes
- Known subtypes
-
- Self type
-
(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) => R
A function of 13 parameters.
A function of 13 parameters.
Attributes
- Source
- Function13.scala
- Supertypes
- Known subtypes
-
- Self type
-
(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) => R
A function of 14 parameters.
A function of 14 parameters.
Attributes
- Source
- Function14.scala
- Supertypes
- Known subtypes
-
- Self type
-
(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) => R
A function of 15 parameters.
A function of 15 parameters.
Attributes
- Source
- Function15.scala
- Supertypes
- Known subtypes
-
- Self type
-
(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) => R
A function of 16 parameters.
A function of 16 parameters.
Attributes
- Source
- Function16.scala
- Supertypes
- Known subtypes
-
- Self type
-
(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) => R
A function of 17 parameters.
A function of 17 parameters.
Attributes
- Source
- Function17.scala
- Supertypes
- Known subtypes
-
class AbstractFunction17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R]
- Self type
-
(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) => R
A function of 18 parameters.
A function of 18 parameters.
Attributes
- Source
- Function18.scala
- Supertypes
- Known subtypes
-
class AbstractFunction18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]
- Self type
-
(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) => R
A function of 19 parameters.
A function of 19 parameters.
Attributes
- Source
- Function19.scala
- Supertypes
- Known subtypes
-
class AbstractFunction19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]
- Self type
-
(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) => R
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))
}
Attributes
- Source
- Function2.scala
- Supertypes
- Known subtypes
-
class FromJavaBinaryOperator[T]class FromJavaObjDoubleConsumer[T]class FromJavaObjIntConsumer[T]class FromJavaObjLongConsumer[T]trait JFunction2$mcDDD$sptrait JFunction2$mcDDI$sptrait JFunction2$mcDDJ$sptrait JFunction2$mcDID$sptrait JFunction2$mcDII$sptrait JFunction2$mcDIJ$sptrait JFunction2$mcDJD$sptrait JFunction2$mcDJI$sptrait JFunction2$mcDJJ$sptrait JFunction2$mcFDD$sptrait JFunction2$mcFDI$sptrait JFunction2$mcFDJ$sptrait JFunction2$mcFID$sptrait JFunction2$mcFII$sptrait JFunction2$mcFIJ$sptrait JFunction2$mcFJD$sptrait JFunction2$mcFJI$sptrait JFunction2$mcFJJ$sptrait JFunction2$mcIDD$sptrait JFunction2$mcIDI$sptrait JFunction2$mcIDJ$sptrait JFunction2$mcIID$sptrait JFunction2$mcIII$sptrait JFunction2$mcIIJ$sptrait JFunction2$mcIJD$sptrait JFunction2$mcIJI$sptrait JFunction2$mcIJJ$sptrait JFunction2$mcJDD$sptrait JFunction2$mcJDI$sptrait JFunction2$mcJDJ$sptrait JFunction2$mcJID$sptrait JFunction2$mcJII$sptrait JFunction2$mcJIJ$sptrait JFunction2$mcJJD$sptrait JFunction2$mcJJI$sptrait JFunction2$mcJJJ$sptrait JFunction2$mcVDD$sptrait JFunction2$mcVDI$sptrait JFunction2$mcVDJ$sptrait JFunction2$mcVID$sptrait JFunction2$mcVII$sptrait JFunction2$mcVIJ$sptrait JFunction2$mcVJD$sptrait JFunction2$mcVJI$sptrait JFunction2$mcVJJ$sptrait JFunction2$mcZDD$sptrait JFunction2$mcZDI$sptrait JFunction2$mcZDJ$sptrait JFunction2$mcZID$sptrait JFunction2$mcZII$sptrait JFunction2$mcZIJ$sptrait JFunction2$mcZJD$sptrait JFunction2$mcZJI$sptrait JFunction2$mcZJJ$spShow all
- Self type
-
(T1, T2) => R
A function of 20 parameters.
A function of 20 parameters.
Attributes
- Source
- Function20.scala
- Supertypes
- Known subtypes
-
class AbstractFunction20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]
- Self type
-
(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) => R
A function of 21 parameters.
A function of 21 parameters.
Attributes
- Source
- Function21.scala
- Supertypes
- Known subtypes
-
class AbstractFunction21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R]
- Self type
-
(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) => R
A function of 22 parameters.
A function of 22 parameters.
Attributes
- Source
- Function22.scala
- Supertypes
- Known subtypes
-
class AbstractFunction22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R]
- Self type
-
(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) => R
A function of 3 parameters.
A function of 3 parameters.
Attributes
- Source
- Function3.scala
- Supertypes
- Known subtypes
-
- Self type
-
(T1, T2, T3) => R
A function of 4 parameters.
A function of 4 parameters.
Attributes
- Source
- Function4.scala
- Supertypes
- Known subtypes
-
- Self type
-
(T1, T2, T3, T4) => R
A function of 5 parameters.
A function of 5 parameters.
Attributes
- Source
- Function5.scala
- Supertypes
- Known subtypes
-
- Self type
-
(T1, T2, T3, T4, T5) => R
A function of 6 parameters.
A function of 6 parameters.
Attributes
- Source
- Function6.scala
- Supertypes
- Known subtypes
-
- Self type
-
(T1, T2, T3, T4, T5, T6) => R
A function of 7 parameters.
A function of 7 parameters.
Attributes
- Source
- Function7.scala
- Supertypes
- Known subtypes
-
- Self type
-
(T1, T2, T3, T4, T5, T6, T7) => R
A function of 8 parameters.
A function of 8 parameters.
Attributes
- Source
- Function8.scala
- Supertypes
- Known subtypes
-
- Self type
-
(T1, T2, T3, T4, T5, T6, T7, T8) => R
A function of 9 parameters.
A function of 9 parameters.
Attributes
- Source
- Function9.scala
- Supertypes
- Known subtypes
-
- Self type
-
(T1, T2, T3, T4, T5, T6, T7, T8, T9) => R
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.
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.
Attributes
- Source
- IArray.scala
- Supertypes
- Self type
-
IArray.type
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.
Attributes
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.
Attributes
- Companion
- object
- Source
- Long.scala
- Supertypes
Attributes
- Companion
- class
- Source
- Long.scala
- Supertypes
- Self type
-
Long.type
This class implements errors which are thrown whenever an object doesn't match any pattern of a pattern matching expression.
This class implements errors which are thrown whenever an object doesn't match any pattern of a pattern matching expression.
Attributes
- Source
- MatchError.scala
- Supertypes
-
class RuntimeExceptionclass Exceptionclass Throwabletrait Serializableclass Objecttrait Matchableclass AnyShow all
The base trait of types that can be safely pattern matched against.
The base trait of types that can be safely pattern matched against.
See https://docs.scala-lang.org/scala3/reference/other-new-features/matchable.html.
Attributes
- Supertypes
-
class Any
This case object represents non-existent values.
This case object represents non-existent values.
Attributes
- Source
- Option.scala
- Supertypes
-
trait Serializabletrait Producttrait Equalstrait IterableOnce[Nothing]class Objecttrait Matchableclass AnyShow all
- Self type
-
None.type
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.???
.
Attributes
- Source
- NotImplementedError.scala
- Supertypes
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.
Attributes
- Supertypes
-
class Any
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.
Attributes
- Supertypes
Attributes
- Companion
- class
- Source
- Option.scala
- Supertypes
- Self type
-
Option.type
Represents optional values.
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")
}
Attributes
- 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.
- Companion
- object
- Source
- Option.scala
- Supertypes
-
trait Serializabletrait Producttrait Equalstrait IterableOnce[A]class Objecttrait Matchableclass AnyShow all
- Known subtypes
- Self type
-
Option[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
.
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]"))
Attributes
- 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
from optional Function
from an extractor
{ case extractor(x) => x }
extractor.unapply _
- Companion
- object
- Source
- PartialFunction.scala
- Supertypes
- Known subtypes
-
class IntMap[T]class LongMap[T]class LongMap[V]class SystemPropertiestrait Seq[A]trait Seq[A]class AbstractSeq[A]class ArraySeq[A]class ofBooleanclass ofByteclass ofCharclass ofDoubleclass ofFloatclass ofIntclass ofLongclass ofRef[T]class ofShortclass ofUnitclass LazyList[A]class List[A]class ::[A]object Nilclass NumericRange[T]class Exclusive[T]class Inclusive[T]class Queue[A]class Rangeclass Exclusiveclass Inclusiveclass Stream[A]class Cons[A]object Emptyclass Vector[A]class WrappedStringtrait IndexedSeq[A]trait LinearSeq[A]trait Seq[A]class AbstractSeq[A]class AbstractBuffer[A]class ArrayBuffer[A]class ArrayDeque[A]class Queue[A]class Stack[A]class ListBuffer[A]class UnrolledBuffer[T]class ArraySeq[T]class ofBooleanclass ofByteclass ofCharclass ofDoubleclass ofFloatclass ofIntclass ofLongclass ofRef[T]class ofShortclass ofUnitclass StringBuildertrait Buffer[A]trait IndexedBuffer[A]trait IndexedSeq[T]class AnyAccumulator[A]class DoubleAccumulatorclass IntAccumulatorclass LongAccumulatorclass AbstractSeq[A]trait IndexedSeq[A]trait LinearSeq[A]Show all
- Self type
-
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 }
Attributes
- Companion
- trait
- Source
- PartialFunction.scala
- Supertypes
- Self type
-
PartialFunction.type
Marker trait for polymorphic function types.
Marker trait for polymorphic function types.
This trait can only 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 } Exactly one term argument list is expected. The term argument list may be contextual.
This type will be erased to FunctionN or FunctionXXL.
Attributes
- Source
- PolyFunction.scala
- Supertypes
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.
Attributes
- Source
- Predef.scala
- Supertypes
- Self type
-
Predef.type
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.
Attributes
- Source
- Product.scala
- Supertypes
- Known subtypes
-
trait Enumtrait EnumValueclass TupleXXLclass Try[T]class Failure[T]class Success[T]class Option[A]object Noneclass Some[A]trait Product1[T1]class Tuple1[T1]class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)trait Product19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)class (T1, T2)trait Product20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)trait Product21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)trait Product22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)class (T1, T2, T3)class (T1, T2, T3, T4)class (T1, T2, T3, T4, T5)class (T1, T2, T3, T4, T5, T6)class (T1, T2, T3, T4, T5, T6, T7)class (T1, T2, T3, T4, T5, T6, T7, T8)class (T1, T2, T3, T4, T5, T6, T7, T8, T9)trait Tupleobject EmptyTupletrait NonEmptyTupleShow all
Product10 is a Cartesian product of 10 components.
Product10 is a Cartesian product of 10 components.
Attributes
- Companion
- object
- Source
- Product10.scala
- Supertypes
- Known subtypes
-
class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
Product11 is a Cartesian product of 11 components.
Product11 is a Cartesian product of 11 components.
Attributes
- Companion
- object
- Source
- Product11.scala
- Supertypes
- Known subtypes
-
class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
Product12 is a Cartesian product of 12 components.
Product12 is a Cartesian product of 12 components.
Attributes
- Companion
- object
- Source
- Product12.scala
- Supertypes
- Known subtypes
-
class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)
Product13 is a Cartesian product of 13 components.
Product13 is a Cartesian product of 13 components.
Attributes
- Companion
- object
- Source
- Product13.scala
- Supertypes
- Known subtypes
-
class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)
Product14 is a Cartesian product of 14 components.
Product14 is a Cartesian product of 14 components.
Attributes
- Companion
- object
- Source
- Product14.scala
- Supertypes
- Known subtypes
-
class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)
Product15 is a Cartesian product of 15 components.
Product15 is a Cartesian product of 15 components.
Attributes
- Companion
- object
- Source
- Product15.scala
- Supertypes
- Known subtypes
-
class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)
Product16 is a Cartesian product of 16 components.
Product16 is a Cartesian product of 16 components.
Attributes
- Companion
- object
- Source
- Product16.scala
- Supertypes
- Known subtypes
-
class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)
Product17 is a Cartesian product of 17 components.
Product17 is a Cartesian product of 17 components.
Attributes
- Companion
- object
- Source
- Product17.scala
- Supertypes
- Known subtypes
-
class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)
Product18 is a Cartesian product of 18 components.
Product18 is a Cartesian product of 18 components.
Attributes
- Companion
- object
- Source
- Product18.scala
- Supertypes
- Known subtypes
-
class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)
Product19 is a Cartesian product of 19 components.
Product19 is a Cartesian product of 19 components.
Attributes
- Companion
- object
- Source
- Product19.scala
- Supertypes
- Known subtypes
-
class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)
Product2 is a Cartesian product of 2 components.
Product2 is a Cartesian product of 2 components.
Attributes
- Companion
- object
- Source
- Product2.scala
- Supertypes
- Known subtypes
-
class (T1, T2)
Product20 is a Cartesian product of 20 components.
Product20 is a Cartesian product of 20 components.
Attributes
- Companion
- object
- Source
- Product20.scala
- Supertypes
- Known subtypes
-
class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)
Product21 is a Cartesian product of 21 components.
Product21 is a Cartesian product of 21 components.
Attributes
- Companion
- object
- Source
- Product21.scala
- Supertypes
- Known subtypes
-
class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)
Product22 is a Cartesian product of 22 components.
Product22 is a Cartesian product of 22 components.
Attributes
- Companion
- object
- Source
- Product22.scala
- Supertypes
- Known subtypes
-
class (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)
Product3 is a Cartesian product of 3 components.
Product3 is a Cartesian product of 3 components.
Attributes
- Companion
- object
- Source
- Product3.scala
- Supertypes
- Known subtypes
-
class (T1, T2, T3)
Product4 is a Cartesian product of 4 components.
Product4 is a Cartesian product of 4 components.
Attributes
- Companion
- object
- Source
- Product4.scala
- Supertypes
- Known subtypes
-
class (T1, T2, T3, T4)
Product5 is a Cartesian product of 5 components.
Product5 is a Cartesian product of 5 components.
Attributes
- Companion
- object
- Source
- Product5.scala
- Supertypes
- Known subtypes
-
class (T1, T2, T3, T4, T5)
Product6 is a Cartesian product of 6 components.
Product6 is a Cartesian product of 6 components.
Attributes
- Companion
- object
- Source
- Product6.scala
- Supertypes
- Known subtypes
-
class (T1, T2, T3, T4, T5, T6)
Product7 is a Cartesian product of 7 components.
Product7 is a Cartesian product of 7 components.
Attributes
- Companion
- object
- Source
- Product7.scala
- Supertypes
- Known subtypes
-
class (T1, T2, T3, T4, T5, T6, T7)
Product8 is a Cartesian product of 8 components.
Product8 is a Cartesian product of 8 components.
Attributes
- Companion
- object
- Source
- Product8.scala
- Supertypes
- Known subtypes
-
class (T1, T2, T3, T4, T5, T6, T7, T8)
Product9 is a Cartesian product of 9 components.
Product9 is a Cartesian product of 9 components.
Attributes
- Companion
- object
- Source
- Product9.scala
- Supertypes
- Known subtypes
-
class (T1, T2, T3, T4, T5, T6, T7, T8, T9)
An exception that indicates an error during Scala reflection
An exception that indicates an error during Scala reflection
Attributes
- Source
- package.scala
- Supertypes
A marker trait for objects that support structural selection via selectDynamic
and applyDynamic
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.
Attributes
- Companion
- object
- Source
- Selectable.scala
- Supertypes
-
class Any
- Known subtypes
-
trait Selectable
Attributes
- Companion
- trait
- Source
- Selectable.scala
- Supertypes
- Self type
-
Selectable.type
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.
Attributes
- See also
- Source
- SerialVersionUID.scala
- Supertypes
-
trait ConstantAnnotationtrait StaticAnnotationclass Annotationclass Objecttrait Matchableclass AnyShow all
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.
Attributes
- Companion
- object
- Source
- Short.scala
- Supertypes
Attributes
- Companion
- class
- Source
- Short.scala
- Supertypes
- Self type
-
Short.type
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
Attributes
- Supertypes
-
class Any
Class Some[A]
represents existing values of type A
.
Class Some[A]
represents existing values of type A
.
Attributes
- Source
- Option.scala
- Supertypes
-
class Option[A]trait Serializabletrait Producttrait Equalstrait IterableOnce[A]class Objecttrait Matchableclass AnyShow all
A common supertype for companions of specializable types.
A common supertype for companions of specializable types. Should not be extended in user code.
Attributes
- Companion
- object
- Source
- Specializable.scala
- Supertypes
Attributes
- Companion
- trait
- Source
- Specializable.scala
- Supertypes
- Self type
-
Specializable.type
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.
Value parameters
- parts
-
The parts that make up the interpolated string, without the expressions that get inserted by interpolation.
Attributes
- Companion
- object
- Source
- StringContext.scala
- Supertypes
Attributes
- Companion
- class
- Source
- StringContext.scala
- Supertypes
- Self type
-
StringContext.type
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.
Attributes
- Companion
- object
- Source
- Symbol.scala
- Supertypes
Attributes
- Companion
- class
- Source
- Symbol.scala
- Supertypes
- Self type
-
Symbol.type
Tuple of arbitrary arity
A tuple of 1 elements; the canonical representation of a scala.Product1.
A tuple of 1 elements; the canonical representation of a scala.Product1.
Value parameters
- _1
-
Element 1 of this Tuple1
Attributes
- Constructor
-
Create a new tuple with 1 elements.
- Source
- Tuple1.scala
- Supertypes
-
trait Serializabletrait Product1[T1]trait NonEmptyTupletrait Tupletrait Producttrait Equalsclass Objecttrait Matchableclass AnyShow all
A tuple of 10 elements; the canonical representation of a scala.Product10.
A tuple of 10 elements; the canonical representation of a scala.Product10.
Value parameters
- _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
Attributes
- 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
- Tuple10.scala
- Supertypes
A tuple of 11 elements; the canonical representation of a scala.Product11.
A tuple of 11 elements; the canonical representation of a scala.Product11.
Value parameters
- _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
Attributes
- 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
- Tuple11.scala
- Supertypes
A tuple of 12 elements; the canonical representation of a scala.Product12.
A tuple of 12 elements; the canonical representation of a scala.Product12.
Value parameters
- _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
Attributes
- 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
- Tuple12.scala
- Supertypes
A tuple of 13 elements; the canonical representation of a scala.Product13.
A tuple of 13 elements; the canonical representation of a scala.Product13.
Value parameters
- _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
Attributes
- 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
- Tuple13.scala
- Supertypes
A tuple of 14 elements; the canonical representation of a scala.Product14.
A tuple of 14 elements; the canonical representation of a scala.Product14.
Value parameters
- _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
Attributes
- 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
- Tuple14.scala
- Supertypes
A tuple of 15 elements; the canonical representation of a scala.Product15.
A tuple of 15 elements; the canonical representation of a scala.Product15.
Value parameters
- _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
Attributes
- 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
- Tuple15.scala
- Supertypes
A tuple of 16 elements; the canonical representation of a scala.Product16.
A tuple of 16 elements; the canonical representation of a scala.Product16.
Value parameters
- _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
Attributes
- 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
- Tuple16.scala
- Supertypes
A tuple of 17 elements; the canonical representation of a scala.Product17.
A tuple of 17 elements; the canonical representation of a scala.Product17.
Value parameters
- _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
Attributes
- 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
- Tuple17.scala
- Supertypes
A tuple of 18 elements; the canonical representation of a scala.Product18.
A tuple of 18 elements; the canonical representation of a scala.Product18.
Value parameters
- _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
Attributes
- 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
- Tuple18.scala
- Supertypes
A tuple of 19 elements; the canonical representation of a scala.Product19.
A tuple of 19 elements; the canonical representation of a scala.Product19.
Value parameters
- _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
Attributes
- 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
- Tuple19.scala
- Supertypes
-
trait Serializabletrait Product19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]class T1 *: T2 *: T3 *: T4 *: T5 *: T6 *: T7 *: T8 *: T9 *: T10 *: T11 *: T12 *: T13 *: T14 *: T15 *: T16 *: T17 *: T18 *: T19 *: EmptyTuple.typetrait NonEmptyTupletrait Tupletrait Producttrait Equalsclass Objecttrait Matchableclass AnyShow all
A tuple of 2 elements; the canonical representation of a scala.Product2.
A tuple of 2 elements; the canonical representation of a scala.Product2.
Value parameters
- _1
-
Element 1 of this Tuple2
- _2
-
Element 2 of this Tuple2
Attributes
- Constructor
-
Create a new tuple with 2 elements. Note that it is more idiomatic to create a Tuple2 via
(t1, t2)
- Source
- Tuple2.scala
- Supertypes
-
trait Serializabletrait NonEmptyTupletrait Tupletrait Producttrait Equalsclass Objecttrait Matchableclass AnyShow all
A tuple of 20 elements; the canonical representation of a scala.Product20.
A tuple of 20 elements; the canonical representation of a scala.Product20.
Value parameters
- _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
Attributes
- 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
- Tuple20.scala
- Supertypes
-
trait Serializabletrait Product20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]class T1 *: T2 *: T3 *: T4 *: T5 *: T6 *: T7 *: T8 *: T9 *: T10 *: T11 *: T12 *: T13 *: T14 *: T15 *: T16 *: T17 *: T18 *: T19 *: T20 *: EmptyTuple.typetrait NonEmptyTupletrait Tupletrait Producttrait Equalsclass Objecttrait Matchableclass AnyShow all
A tuple of 21 elements; the canonical representation of a scala.Product21.
A tuple of 21 elements; the canonical representation of a scala.Product21.
Value parameters
- _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
Attributes
- 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
- Tuple21.scala
- Supertypes
-
trait Serializabletrait Product21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]class T1 *: T2 *: T3 *: T4 *: T5 *: T6 *: T7 *: T8 *: T9 *: T10 *: T11 *: T12 *: T13 *: T14 *: T15 *: T16 *: T17 *: T18 *: T19 *: T20 *: T21 *: EmptyTuple.typetrait NonEmptyTupletrait Tupletrait Producttrait Equalsclass Objecttrait Matchableclass AnyShow all
A tuple of 22 elements; the canonical representation of a scala.Product22.
A tuple of 22 elements; the canonical representation of a scala.Product22.
Value parameters
- _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
Attributes
- 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
- Tuple22.scala
- Supertypes
-
trait Serializabletrait Product22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]class T1 *: T2 *: T3 *: T4 *: T5 *: T6 *: T7 *: T8 *: T9 *: T10 *: T11 *: T12 *: T13 *: T14 *: T15 *: T16 *: T17 *: T18 *: T19 *: T20 *: T21 *: T22 *: EmptyTuple.typetrait NonEmptyTupletrait Tupletrait Producttrait Equalsclass Objecttrait Matchableclass AnyShow all
A tuple of 3 elements; the canonical representation of a scala.Product3.
A tuple of 3 elements; the canonical representation of a scala.Product3.
Value parameters
- _1
-
Element 1 of this Tuple3
- _2
-
Element 2 of this Tuple3
- _3
-
Element 3 of this Tuple3
Attributes
- Constructor
-
Create a new tuple with 3 elements. Note that it is more idiomatic to create a Tuple3 via
(t1, t2, t3)
- Source
- Tuple3.scala
- Supertypes
-
trait Serializabletrait NonEmptyTupletrait Tupletrait Producttrait Equalsclass Objecttrait Matchableclass AnyShow all
A tuple of 4 elements; the canonical representation of a scala.Product4.
A tuple of 4 elements; the canonical representation of a scala.Product4.
Value parameters
- _1
-
Element 1 of this Tuple4
- _2
-
Element 2 of this Tuple4
- _3
-
Element 3 of this Tuple4
- _4
-
Element 4 of this Tuple4
Attributes
- Constructor
-
Create a new tuple with 4 elements. Note that it is more idiomatic to create a Tuple4 via
(t1, t2, t3, t4)
- Source
- Tuple4.scala
- Supertypes
-
trait Serializabletrait NonEmptyTupletrait Tupletrait Producttrait Equalsclass Objecttrait Matchableclass AnyShow all
A tuple of 5 elements; the canonical representation of a scala.Product5.
A tuple of 5 elements; the canonical representation of a scala.Product5.
Value parameters
- _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
Attributes
- 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
- Tuple5.scala
- Supertypes
-
trait Serializabletrait NonEmptyTupletrait Tupletrait Producttrait Equalsclass Objecttrait Matchableclass AnyShow all
A tuple of 6 elements; the canonical representation of a scala.Product6.
A tuple of 6 elements; the canonical representation of a scala.Product6.
Value parameters
- _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
Attributes
- 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
- Tuple6.scala
- Supertypes
A tuple of 7 elements; the canonical representation of a scala.Product7.
A tuple of 7 elements; the canonical representation of a scala.Product7.
Value parameters
- _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
Attributes
- 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
- Tuple7.scala
- Supertypes
A tuple of 8 elements; the canonical representation of a scala.Product8.
A tuple of 8 elements; the canonical representation of a scala.Product8.
Value parameters
- _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
Attributes
- 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
- Tuple8.scala
- Supertypes
A tuple of 9 elements; the canonical representation of a scala.Product9.
A tuple of 9 elements; the canonical representation of a scala.Product9.
Value parameters
- _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
Attributes
- 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
- Tuple9.scala
- Supertypes
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.
Attributes
- Source
- UninitializedFieldError.scala
- Supertypes
-
trait Producttrait Equalsclass RuntimeExceptionclass Exceptionclass Throwabletrait Serializableclass Objecttrait Matchableclass AnyShow all
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
.
Attributes
- Companion
- object
- Source
- Unit.scala
- Supertypes
Attributes
- Companion
- class
- Source
- Unit.scala
- Supertypes
- Self type
-
Unit.type
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]
.
Attributes
- Source
- ValueOf.scala
- Supertypes
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
The Scala compiler also warns about using definitions annotated with java.lang.Deprecated. However it is recommended to use the Scala @deprecated
annotation in Scala code because it allows providing a deprecation message.
@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 parameters
- 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
Attributes
- See also
-
The official documentation on binary compatibility.
- Source
- deprecated.scala
- Supertypes
-
trait ConstantAnnotationtrait StaticAnnotationclass Annotationclass Objecttrait Matchableclass AnyShow all
An annotation that designates that inheriting from a class is deprecated.
An annotation that designates that inheriting from a class is deprecated.
This is usually done to warn about a non-final class being made final in a future version. Sub-classing such a class then generates a warning.
No warnings are generated if the subclass is in the same compilation unit.
Library authors should state the library's deprecation policy in their documentation to give developers guidance on when a type annotated with @deprecatedInheritance
will be final
ized.
Library authors should prepend the name of their library to the version number to help developers distinguish deprecations coming from different libraries:
@deprecatedInheritance("this class will be made final", "FooLib 12.0")
class Foo
val foo = new Foo // no deprecation warning
class Bar extends Foo
// warning: inheritance from class Foo is deprecated (since FooLib 12.0): this class will be made final
// class Bar extends Foo
// ^
Value parameters
- 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
Attributes
- See also
- Source
- deprecatedInheritance.scala
- Supertypes
-
trait ConstantAnnotationtrait StaticAnnotationclass Annotationclass Objecttrait Matchableclass AnyShow all
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.
If the name
is omitted, then using the canonical name is deprecated. In that case, lints such as -Xlint:named-booleans
which encourage the use of a name will not warn.
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)
^
Attributes
- See also
- Source
- deprecatedName.scala
- Supertypes
An annotation that designates that overriding a member is deprecated.
An annotation that designates that overriding a member is deprecated.
Overriding such a member in a sub-class then generates a warning.
Library authors should state the library's deprecation policy in their documentation to give developers guidance on when a method annotated with @deprecatedOverriding
will be final
ized.
Library authors should prepend the name of their library to the version number to help developers distinguish deprecations coming from different libraries:
class Foo {
@deprecatedOverriding("this method will be made final", "FooLib 12.0")
def add(x: Int, y: Int) = x + y
}
class Bar extends Foo // no deprecation warning
class Baz extends Foo {
override def add(x: Int, y: Int) = x - y
}
// warning: overriding method add in class Foo is deprecated (since FooLib 12.0): this method will be made final
// override def add(x: Int, y: Int) = x - y
// ^
Value parameters
- message
-
the message to print during compilation if the member was overridden
- since
-
a string identifying the first version in which overriding was deprecated
Attributes
- See also
- Source
- deprecatedOverriding.scala
- Supertypes
-
trait ConstantAnnotationtrait StaticAnnotationclass Annotationclass Objecttrait Matchableclass AnyShow all
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
and the overview document 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). If inlining is not possible, for example because the method is not final, an optimizer warning will be issued. See -Wopt: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
Attributes
- Source
- inline.scala
- Supertypes
The scala.language
object controls the language features available to the programmer, as proposed in the SIP-18 document.
The scala.language
object controls the language features available to the programmer, as proposed in the SIP-18 document.
Each of these features has to be explicitly imported into the current scope to become available:
import language.postfixOps // or language._
List(1, 2, 3) reverse
The language features are:
-
dynamics
enables defining calls rewriting using theDynamic
trait -
existentials
enables writing existential types -
higherKinds
enables writing higher-kinded types -
implicitConversions
enables defining implicit methods and members -
postfixOps
enables postfix operators (not recommended) -
reflectiveCalls
enables using structural types -
experimental
contains newer features that have not yet been tested in production
Attributes
- Source
- language.scala
- Supertypes
- Self type
-
language.type
Attributes
- Source
- languageFeature.scala
- Supertypes
- Self type
-
languageFeature.type
An annotation that designates a main function
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).
Attributes
- Source
- native.scala
- Supertypes
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
Attributes
- Source
- noinline.scala
- Supertypes
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] ..
Attributes
- Source
- specialized.scala
- Supertypes
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()
}
Attributes
- Source
- throws.scala
- Supertypes
Attributes
- Source
- transient.scala
- Supertypes
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 }
}
Attributes
- Source
- unchecked.scala
- Supertypes
Attributes
- Source
- volatile.scala
- Supertypes
Deprecated classlikes
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
Attributes
- See also
-
"Delayed Initialization" subsection of the Scala Language Specification (section 5.1)
- Deprecated
- true
- Source
- DelayedInit.scala
- Supertypes
- Known subtypes
-
trait App
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.
Attributes
- Companion
- object
- Deprecated
- true
- Source
- Proxy.scala
- Supertypes
-
class Any
- Known subtypes
-
trait ReferenceWrapper[T]class PhantomReference[T]class SoftReference[T]class WeakReference[T]trait Typed[T]trait OrderedProxy[T]class RichBooleantrait ScalaNumberProxy[T]trait FractionalProxy[T]class RichDoubleclass RichFloatclass RichInttrait ScalaWholeNumberProxy[T]trait IntegralProxy[T]class RichCharclass RichLongclass RichByteclass RichShorttrait RangedProxy[T]Show all
This class represents uninitialized variable/value errors.
This class represents uninitialized variable/value errors.
Attributes
- Deprecated
-
[Since version 2.12.7]
- Source
- UninitializedError.scala
- Supertypes
-
class RuntimeExceptionclass Exceptionclass Throwabletrait Serializableclass Objecttrait Matchableclass AnyShow all
Experimental classlikes
A capability class that allows to throw exception E
. When used with the experimental.saferExceptions feature, a throw Ex()
expression will require a given of class CanThrow[Ex]
to be available.
A capability class that allows to throw exception E
. When used with the experimental.saferExceptions feature, a throw Ex()
expression will require a given of class CanThrow[Ex]
to be available.
Attributes
- Experimental
- true
- Source
- CanThrow.scala
- Supertypes
Attributes
- Experimental
- true
- Source
- NamedTuple.scala
- Supertypes
- Self type
-
NamedTuple.type
Separate from NamedTuple object so that we can match on the opaque type NamedTuple.
Separate from NamedTuple object so that we can match on the opaque type NamedTuple.
Attributes
- Experimental
- true
- Source
- NamedTuple.scala
- Supertypes
- Self type
A type class-like trait intended as a context bound for type variables. If we have [X: Precise]
, instances of the type variable X
are inferred in precise mode. This means that singleton types and union types are not widened.
A type class-like trait intended as a context bound for type variables. If we have [X: Precise]
, instances of the type variable X
are inferred in precise mode. This means that singleton types and union types are not widened.
Attributes
- Experimental
- true
- Source
- Precise.scala
- Supertypes
A marker trait that declares that all inheriting classes are "pure" in the sense that their values retain no capabilities including capabilities needed to perform effects. This has formal meaning only under capture checking.
A marker trait that declares that all inheriting classes are "pure" in the sense that their values retain no capabilities including capabilities needed to perform effects. This has formal meaning only under capture checking.
Attributes
- Experimental
- true
- Source
- Pure.scala
- Supertypes
- Self type
Attributes
- Experimental
- true
- Source
- caps.scala
- Supertypes
- Self type
-
caps.type
Attributes
- Experimental
- true
- Source
- CanThrow.scala
- Supertypes
- Self type
-
unsafeExceptions.type
Types
The intersection of two types.
The intersection of two types.
See https://docs.scala-lang.org/scala3/reference/new-types/intersection-types.html.
Attributes
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
A tuple of 0 elements
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- IArray.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
The union of two types.
The union of two types.
See https://docs.scala-lang.org/scala3/reference/new-types/union-types.html.
Attributes
Deprecated types
Attributes
- Deprecated
- true
- Source
- package.scala
Attributes
- Deprecated
- true
- Source
- package.scala
Attributes
- Deprecated
- true
- Source
- package.scala
Attributes
- Deprecated
- true
- Source
- package.scala
Value members
Concrete fields
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Attributes
- Source
- package.scala
Deprecated fields
Attributes
- Deprecated
- true
- Source
- package.scala
Attributes
- Deprecated
- true
- Source
- package.scala