Packages

•  package root

  This is the documentation for the Scala standard library.

  This is the documentation for the Scala standard library.

  Package structure

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

  Notable packages include:

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

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

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

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

  Automatic imports

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

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

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

  Definition Classes

  root

•  package scala

  Core Scala types.

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

  Definition Classes

  root

•  sealed abstract class Option[+A] extends IterableOnce[A] with Product with Serializable

  Represents optional values.

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

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

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

  Note that this is equivalent to

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

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

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

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

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

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

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

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

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

  Definition Classes

  scala

  Annotations

  @SerialVersionUID()

  Note

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

• WithFilter

scala.Option

WithFilter