// SCALARS — LANGUAGE REFERENCE

>_LANGUAGE REFERENCE

Every name the current scalars build resolves, grouped by chapter: reserved keywords, declaration forms and modifiers, comprehensions and ranges, pattern forms, collection constructors, the sequence and map method surfaces, String / Int / Double / Boolean methods, tuples and records, function values, scala.math, the throwable hierarchy, the operators, and Predef with the string interpolators. Each entry carries a signature and a runnable example. This page is generated from the reference corpus (src/corpus.rs) by the gen-docs binary, which is also what editor completion and hover read, so the page never drifts from the runtime. Keywords mirror lexer.rs; declarations and patterns mirror parser.rs; the method surfaces, scala.math, throwables and operator lowering mirror src/host.rs and src/compiler.rs. Where behaviour diverges from Scala on the JVM, the entry says so.

object Name [extends App] { … }
object Counter { var n = 0; def bump(): Int = { n += 1; n } }
object T extends App { println(Counter.bump()) }   // => 1

def name([p: T, …])[: R] = expr
def sq(x: Int): Int = x * x
println(sq(7))   // => 49

val name[: T] = expr
val x = 41
println(x + 1)   // => 42

var name[: T] = expr
var n = 0
n += 5
println(n)   // => 5

if (cond) expr [else expr]
println(if (1 < 2) "yes" else "no")   // => yes

if (cond) expr else expr
println(if (false) 1 else 2)   // => 2

while (cond) { … }
var i = 0
while (i < 3) { i += 1 }
println(i)   // => 3

for (x <- gen [if guard]) [yield] body
for (i <- 1 to 3 if i > 1) print(i)   // => 23

class C(…) extends P(args) [with T …]
class A(val n: Int)
class B(m: Int) extends A(m)
println(new B(2).n)   // => 2

new Class(args)
class P(val n: Int)
println(new P(2).n)   // => 2

return expr
def f(x: Int): Int = { if (x < 0) return 0; x * 2 }
println(f(-1))   // => 0

expr match { case pat [if guard] => expr; … }
println(2 match { case 1 => "one"; case n => "n=" + n })   // => n=2

case pat [if guard] => expr
case class P(x: Int)
println(P(1))   // => P(1)

try { … } [catch { case … }] [finally { … }]
println(try { 1 / 0 } catch { case _: ArithmeticException => -1 })   // => -1

catch { case e: T [if guard] => expr; … }
try { "z".toInt } catch { case e: NumberFormatException => println(e.getMessage) }   // => For input string: "z"

try { … } finally { … }
try { println(1) } finally { println("done") }   // => 1 then done

throw expr
def pick(b: Boolean): Int = if (b) 7 else throw new RuntimeException("no")
println(pick(true))   // => 7

true
println(true && false)   // => false

false
println(false || true)   // => true

null
val x = null
println(x)   // => null

class Name(params) [extends P(args)] [with T …] { members }
class Box(val n: Int) { def twice = n * 2 }
println(new Box(3).twice)   // => 6

trait Name { members }
trait S { def area: Int; def show: String = "a=" + area }
class C(r: Int) extends S { def area = r * r }
println(new C(3).show)   // => a=9

case class Name(params)
case class P(x: Int, y: Int)
println(P(1, 2).copy(y = 9))   // => P(1,9)

case object Name [extends P]
sealed trait Shape
case object Origin extends Shape
println(Origin)   // => Origin

override def f = expr
class A { def f = 1 }
class B extends A { override def f = 2 }
val a: A = new B()
println(a.f)   // => 2

class C extends P with T1 with T2
trait L { def tag = "L" }
class R extends L
println(new R().tag)   // => L

super.member
class A { def f = "a" }
class B extends A { override def f = super.f + "b" }
println(new B().f)   // => ab

this[.member]
class Box(val n: Int) { def twice: Int = this.n * 2 }
println(new Box(3).twice)   // => 6

sealed trait Name
sealed trait Shape
case class Circle(r: Int) extends Shape
val s: Shape = Circle(2)
println(s match { case Circle(r) => r * r })   // => 4

abstract def f: T
abstract class Base { def name: String }

final def f = expr
class A { final def tag = "a" }

private val x = expr
class A { private val secret = 1; def peek = secret }

protected def f = expr
class A { protected def helper = 1 }

implicit val x = expr
class A { implicit val scale = 2 }

lazy val x = expr
def f = { lazy val z = 1; z }
println(f)   // => 1

package name[.name…]
package demo
object T extends App { println(1) }   // => 1

import path[._]
import scala.math._
object T extends App { println(math.sqrt(16.0)) }   // => 4.0

object Name extends App { … }
object T extends App { println("hi") }   // => hi

def main(args: Array[String]): Unit = { … }
object T { def main(args: Array[String]): Unit = { println(0) } }   // => 0

for (x <- gen) yield expr
println(for (x <- List(1, 2, 3) if x > 1) yield x * 10)   // => List(20, 30)

for (name <- generator) …
for (x <- List("a", "b")) print(x)   // => ab

a until b: Range
for (i <- 0 until 3) print(i)   // => 012

a to b: Range
println((1 to 3).sum)   // => 6

range by step: Range
for (i <- 10 to 1 by -3) print(i + " ")   // => 10 7 4 1

(a to b): Range
println(1 to 4)               // => Range 1 to 4
println((1 to 4).map(_ * 2))   // => Vector(2, 4, 6, 8)

case _ => expr
println(9 match { case 1 => "one"; case _ => "other" })   // => other

case name => expr
try { throw new RuntimeException("x") } catch { case e => println(e) }   // => java.lang.RuntimeException: x

case name: Type => expr
println(try { 1 / 0 } catch { case _: ArithmeticException => -1 })   // => -1

case Class(pat, …) => expr
case class P(x: Int, y: Int)
println(P(1, 2) match { case P(a, b) => a + b })   // => 3

case (pat, …) => expr
println(Map("a" -> 1).map { case (k, v) => k + v })   // => List(a1)

case literal => expr
println("b" match { case "a" => 1; case "b" => 2 })   // => 2

case pat if cond => expr
println(4 match { case n if n % 2 == 0 => "even"; case _ => "odd" })   // => even

x.isInstanceOf[T]: Boolean
trait S
class C extends S
println(new C().isInstanceOf[S])   // => true

x.asInstanceOf[T]: T
val x: Any = 5
println(x.asInstanceOf[Int])   // => 5

List(e, …): List[A]
println(List(3, 1, 2).sorted.map(_ * 2))   // => List(2, 4, 6)

Seq(e, …): List[A]
println(Seq(1, 2))   // => List(1, 2)

Vector(e, …): Vector[A]
println(Vector(1, 2, 3).map(_ + 1))   // => Vector(2, 3, 4)

IndexedSeq(e, …): Vector[A]
println(IndexedSeq(1, 2))   // => Vector(1, 2)

Set(e, …): Set[A]
println(Set(3, 1, 2))         // => Set(3, 1, 2)
println(Set(9, 3, 1, 2, 7))   // => HashSet(1, 9, 2, 7, 3)

new mutable.HashSet[T]()
val s = new mutable.HashSet[Int]()
s += 1
println(s)   // => HashSet(1)

Map(k -> v, …): Map[K, V]
val m = Map("a" -> 1, "b" -> 2)
println(m.getOrElse("z", 0))   // => 0

new mutable.HashMap[K, V]()
println(List(1, 2, 3).groupBy(_ % 2))   // => HashMap(0 -> List(2), 1 -> List(1, 3))

Array(e, …): Array[A]   |   new Array[T](n): Array[T]
val a = Array(1, 2, 3)
a(1) = 9
println(a.mkString(","))   // => 1,9,3

new Array[T](n: Int): Array[T]
val a = new Array[Int](3)
println(a.mkString(","))   // => 0,0,0

Nil: List[Nothing]
println(1 :: 2 :: Nil)   // => List(1, 2)

(a, b, …): TupleN
println((1, "x"))   // => (1,x)

Some(v): Some[A]
println(List(1, 2).find(_ > 1))          // => Some(2)
println(List(1, 2).find(_ > 1).value)   // => 2

None
println(List(1, 2).find(_ > 9))   // => None

mutable.Kind(e, …)
val s = mutable.Set(1, 2, 3)
s += 4
println(s)   // => HashSet(1, 2, 3, 4)

mutable.ListBuffer(e, …): ListBuffer[A]
val b = mutable.ListBuffer(1, 2)
b += 3
println(b)   // => ListBuffer(1, 2, 3)

mutable.ArrayBuffer(e, …): ArrayBuffer[A]
val a = mutable.ArrayBuffer(1, 2)
a ++= List(3, 4)
println(a)   // => ArrayBuffer(1, 2, 3, 4)

mutable.Buffer(e, …): ArrayBuffer[A]
println(mutable.Buffer(1, 2))   // => ArrayBuffer(1, 2)

mutable.Set(e, …): mutable.Set[A]
val s = mutable.Set(1, 2)
println(s.add(3))   // => true
println(s)          // => HashSet(1, 2, 3)

mutable.Map(k -> v, …): mutable.Map[K, V]
val m = mutable.Map("a" -> 1)
m("b") = 2
println(m)   // => HashMap(a -> 1, b -> 2)

mutable.Queue(e, …): Queue[A]
val q = mutable.Queue(1, 2)
q.enqueue(3)
println(q.dequeue())   // => 1
println(q)             // => Queue(2, 3)

mutable.PriorityQueue(e, …): PriorityQueue[A]
val q = mutable.PriorityQueue(3, 1, 4, 1, 5)
println(q)             // => PriorityQueue(5, 3, 4, 1, 1)
println(q.dequeue())   // => 5
println(q.dequeueAll)  // => ArraySeq(4, 3, 1, 1)

mutable.Stack(e, …): Stack[A]
val s = mutable.Stack(1, 2)
s.push(3)
println(s.pop())   // => 3
println(s)         // => Stack(1, 2)

mutable.ArrayDeque(e, …): ArrayDeque[A]
val d = mutable.ArrayDeque(1, 2)
d.prepend(0)
println(d.removeLast())   // => 2
println(d)                // => ArrayDeque(0, 1)

mutable.LinkedHashSet(e, …): LinkedHashSet[A]
val s = mutable.LinkedHashSet(3, 1, 2)
s += 9
println(s)   // => LinkedHashSet(3, 1, 2, 9)

mutable.LinkedHashMap(k -> v, …): LinkedHashMap[K, V]
val m = mutable.LinkedHashMap(3 -> "c", 1 -> "a")
m(2) = "b"
println(m)   // => LinkedHashMap(3 -> c, 1 -> a, 2 -> b)

new StringBuilder(s?): StringBuilder
val b = new StringBuilder("ab")
b += 'c'
b.append(7)
println(b)   // => abc7

Ordering.Int | Ordering.by(f) | ord.reverse
println(List(3, 1, 2).sorted(Ordering.Int.reverse))   // => List(3, 2, 1)

val pf: PartialFunction[A, B] = { case … => … }
val pf: PartialFunction[Int, String] = { case 1 => "one" }
println(pf.isDefinedAt(2))   // => false
println(pf.lift(1))          // => Some(one)

xs.length: Int
println(List(1, 2, 3).length)   // => 3

xs.size: Int
println(Set(1, 2).size)   // => 2

xs.isEmpty: Boolean
println(List().isEmpty)   // => true

xs.nonEmpty: Boolean
println(List(1).nonEmpty)   // => true

xs.head: A
println(List(1, 2).head)   // => 1

xs.last: A
println(List(1, 2).last)   // => 2

xs.headOption: Option[A]
println(List(1, 2).headOption)   // => Some(1)
println(List().headOption)      // => None

xs.lastOption: Option[A]
println(List(1, 2).lastOption)   // => Some(2)

xs.tail: Repr
println(List(1, 2, 3).tail)   // => List(2, 3)

xs.init: Repr
println(List(1, 2, 3).init)   // => List(1, 2)

xs.apply(i: Int): A
println(List(10, 20, 30)(1))   // => 20

xs.contains(v: Any): Boolean
println(List(1, 2, 3).contains(2))   // => true

xs.indexOf(v: Any): Int
println(List(1, 2, 1).indexOf(1))   // => 0

xs.lastIndexOf(v: Any): Int
println(List(1, 2, 1).lastIndexOf(1))   // => 2

xs.indexWhere(p: A => Boolean): Int
println(List(1, 2, 3).indexWhere(_ > 1))   // => 1

xs.take(n: Int): Repr
println(List(1, 2, 3).take(2))   // => List(1, 2)

xs.drop(n: Int): Repr
println(List(1, 2, 3).drop(2))   // => List(3)

xs.takeRight(n: Int): Repr
println(List(1, 2, 3).takeRight(2))   // => List(2, 3)

xs.dropRight(n: Int): Repr
println(List(1, 2, 3).dropRight(2))   // => List(1)

xs.slice(from: Int, until: Int): Repr
println(List(1, 2, 3).slice(1, 3))   // => List(2, 3)

xs.splitAt(n: Int): (Repr, Repr)
println(List(1, 2, 3).splitAt(1))   // => (List(1),List(2, 3))

xs.distinct: Repr
println(List(1, 2, 2, 3).distinct)   // => List(1, 2, 3)

xs.sorted: Repr
println(List(3, 1, 2).sorted)   // => List(1, 2, 3)

xs.reverse: Repr
println(List(1, 2, 3).reverse)   // => List(3, 2, 1)
println((1 to 3).reverse)      // => Range 3 to 1 by -1

xs.flatten: Repr
println(List(List(1), List(2, 3)).flatten)   // => List(1, 2, 3)

xs.grouped(n: Int): List[Repr]
println(List(1, 2, 3).grouped(2))   // => List(List(1, 2), List(3))

xs.sliding(n: Int): List[Repr]
println(List(1, 2, 3).sliding(2))   // => List(List(1, 2), List(2, 3))

xs.map(f: A => B): Repr[B]
println(List(1, 2, 3).map(_ * 2))   // => List(2, 4, 6)
println((1 to 3).map(_ * 2))      // => Vector(2, 4, 6)

xs.flatMap(f: A => Seq[B]): Repr[B]
println(List(1, 2).flatMap(x => List(x, x * 10)))   // => List(1, 10, 2, 20)

xs.filter(p: A => Boolean): Repr
println(List(1, 2, 3).filter(_ > 1))   // => List(2, 3)

xs.filterNot(p: A => Boolean): Repr
println(List(1, 2, 3).filterNot(_ > 1))   // => List(1)

xs.withFilter(p: A => Boolean): Repr
println(List(1, 2, 3).withFilter(_ > 1))   // => List(2, 3)

xs.collect(pf: PartialFunction[A, B]): Repr[B]
println(List(1, 2, 3, 4).collect { case x if x % 2 == 0 => x * 10 })   // => List(20, 40)

xs.collectFirst(pf: PartialFunction[A, B]): Option[B]
println(List(1, 2, 3).collectFirst { case x if x > 1 => x * 10 })   // => Some(20)

xs.foreach(f: A => Unit): Unit
List(1, 2).foreach(print)   // => 12

xs.zip(ys: Seq[B]): Repr[(A, B)]
println(List(1, 2, 3).zip(List("a", "b")))   // => List((1,a), (2,b))

xs.zipWithIndex: Repr[(A, Int)]
println(List("a", "b").zipWithIndex)   // => List((a,0), (b,1))

xs.unzip: (Repr[A], Repr[B])
println(List((1, 2), (3, 4)).unzip)   // => (List(1, 3),List(2, 4))

xs.partition(p: A => Boolean): (Repr, Repr)
println(List(1, 2, 3).partition(_ < 3))   // => (List(1, 2),List(3))

xs.span(p: A => Boolean): (Repr, Repr)
println(List(1, 2, 1).span(_ < 2))   // => (List(1),List(2, 1))

xs.takeWhile(p: A => Boolean): Repr
println(List(1, 2, 3).takeWhile(_ < 3))   // => List(1, 2)

xs.dropWhile(p: A => Boolean): Repr
println(List(1, 2, 3).dropWhile(_ < 3))   // => List(3)

xs.groupBy(f: A => K): HashMap[K, Repr]
println(List(1, 2, 3).groupBy(_ % 2))   // => HashMap(0 -> List(2), 1 -> List(1, 3))

xs.sortBy(f: A => K): Repr
println(List("bbb", "a").sortBy(_.length))   // => List(a, bbb)

xs.sortWith(lt: (A, A) => Boolean): Repr
println(List(1, 3, 2).sortWith((a, b) => a > b))   // => List(3, 2, 1)

xs.foldLeft(z: B)(op: (B, A) => B): B
println(List(1, 2, 3).foldLeft(0)((a, b) => a + b))   // => 6

xs.foldRight(z: B)(op: (A, B) => B): B
println(List(1, 2, 3).foldRight(0)((a, b) => a - b))   // => 2

xs.fold(z: A)(op: (A, A) => A): A
println(List(1, 2, 3).fold(0)((a, b) => a + b))   // => 6

xs.scanLeft(z: B)(op: (B, A) => B): Repr[B]
println(List(1, 2, 3).scanLeft(0)((a, b) => a + b))   // => List(0, 1, 3, 6)

xs.scanRight(z: B)(op: (A, B) => B): Repr[B]
println(List(1, 2, 3).scanRight(0)((a, b) => a + b))   // => List(6, 5, 3, 0)

xs.reduce(op: (A, A) => A): A
println(List(1, 2, 3).reduce((a, b) => a + b))   // => 6

xs.reduceLeft(op: (A, A) => A): A
println(List(1, 2, 3).reduceLeft((a, b) => a - b))   // => -4

xs.reduceRight(op: (A, A) => A): A
println(List(1, 2, 3).reduceRight((a, b) => a - b))   // => 2

xs.sum: A
println(List(1, 2, 3).sum)   // => 6

xs.product: A
println(List(1, 2, 3).product)   // => 6

xs.min: A
println(List(3, 1, 2).min)   // => 1

xs.max: A
println(List(3, 1, 2).max)   // => 3

xs.minBy(f: A => K): A
println(List("bbb", "a").minBy(_.length))   // => a

xs.maxBy(f: A => K): A
println(List("bbb", "a").maxBy(_.length))   // => bbb

xs.count(p: A => Boolean): Int
println(List(1, 2, 3).count(_ > 1))   // => 2

xs.exists(p: A => Boolean): Boolean
println(List(1, 2).exists(_ > 1))   // => true

xs.forall(p: A => Boolean): Boolean
println(List(1, 2).forall(_ > 0))   // => true

xs.find(p: A => Boolean): Option[A]
println(List(1, 2, 3).find(_ > 1))   // => Some(2)

xs.mkString[(sep)|(pre, sep, post)]: String
println(List(1, 2, 3).mkString(","))            // => 1,2,3
println(List(1, 2, 3).mkString("[", ",", "]"))   // => [1,2,3]

xs.toList: List[A]
println(Set(1, 2).toList)   // => List(1, 2)

xs.toSeq: List[A]
println(Array(1, 2).toSeq)   // => List(1, 2)

xs.toIterable: List[A]
println(List(1, 2).toIterable)   // => List(1, 2)

xs.toVector: Vector[A]
println(List(1, 2).toVector)   // => Vector(1, 2)

xs.toArray: Array[A]
println(List(1, 2).toArray)   // => Array(1, 2)

xs.toSet: Set[A]
println(List(1, 2, 2).toSet)   // => Set(1, 2)

xs.toMap: Map[K, V]
println(List((1, 2), (3, 4)).toMap)   // => Map(1 -> 2, 3 -> 4)

xs.union(ys: Seq[A]): Repr
println(Set(1, 2).union(Set(2, 3)))   // => Set(1, 2, 3)

xs.intersect(ys: Seq[A]): Repr
println(Set(1, 2, 3).intersect(Set(2, 3, 4)))   // => Set(2, 3)

xs.diff(ys: Seq[A]): Repr
println(List(1, 2, 3).diff(List(2)))   // => List(1, 3)

xs.subsetOf(ys: Set[A]): Boolean
println(Set(1, 2).subsetOf(Set(1, 2, 3)))   // => true

set.incl(e: A): Set[A]
println(Set(1, 2).incl(5))   // => Set(1, 2, 5)

set.excl(e: A): Set[A]
println(Set(1, 2).excl(1))   // => Set(2)

xs.removedAll(ys: Seq[A]): Repr
println(Set(1, 2, 3).removedAll(Set(2)))   // => Set(1, 3)

xs.concat(ys: Seq[A]): Repr
println(List(1, 2).concat(List(3)))   // => List(1, 2, 3)

xs.appended(e: A): Repr
println(List(1, 2).appended(3))   // => List(1, 2, 3)

xs.prepended(e: A): Repr
println(List(1, 2).prepended(0))   // => List(0, 1, 2)

(a to b).by(step: Int): Range
println((1 to 10 by 3).toList)   // => List(1, 4, 7, 10)

xs.update(i: Int, v: A): Unit
val a = Array(1, 2, 3)
a(0) = 9
println(a.mkString(","))   // => 9,2,3

xs += (e: A): xs.type
val b = mutable.ListBuffer(1, 2)
b += 3
println(b)   // => ListBuffer(1, 2, 3)

xs ++= (ys: Seq[A]): xs.type
val a = mutable.ArrayBuffer(1, 2)
a ++= List(3, 4)
println(a)   // => ArrayBuffer(1, 2, 3, 4)

xs -= (e: A): xs.type
val b = mutable.ArrayBuffer(1, 2, 1)
b -= 1
println(b)   // => ArrayBuffer(2, 1)

xs --= (ys: Seq[A]): xs.type
val b = mutable.ListBuffer(1, 2, 3)
b --= List(1, 3)
println(b)   // => ListBuffer(2)

b.prepend(e: A): b.type   // the reachable spelling
val b = mutable.ListBuffer(1, 2)
b.prepend(0)
println(b)   // => ListBuffer(0, 1, 2)

s.add(e: A): Boolean
val s = mutable.Set(1, 2)
println(s.add(3))   // => true

xs.addOne(e: A): xs.type
val b = mutable.ListBuffer(1)
b.addOne(2)
println(b)   // => ListBuffer(1, 2)

xs.addAll(ys: Seq[A]): xs.type
val b = mutable.ListBuffer(1)
b.addAll(List(2, 3))
println(b)   // => ListBuffer(1, 2, 3)

b.append(e: A): b.type
val b = mutable.ListBuffer(1)
b.append(2)
println(b)   // => ListBuffer(1, 2)

b.appendAll(ys: Seq[A]): b.type
val b = mutable.ListBuffer(1, 2)
b.appendAll(List(3))
println(b)   // => ListBuffer(1, 2, 3)

b.prepend(e: A): b.type
val b = mutable.ArrayBuffer(1, 2)
b.prepend(0)
println(b)   // => ArrayBuffer(0, 1, 2)

b.prependAll(ys: Seq[A]): b.type
val b = mutable.ListBuffer(3)
b.prependAll(List(1, 2))
println(b)   // => ListBuffer(1, 2, 3)

b.insert(i: Int, e: A): Unit
val b = mutable.ListBuffer(1, 2)
b.insert(1, 9)
println(b)   // => ListBuffer(1, 9, 2)

b.insertAll(i: Int, ys: Seq[A]): Unit
val b = mutable.ListBuffer(1, 2)
b.insertAll(1, List(7, 8))
println(b)   // => ListBuffer(1, 7, 8, 2)

b.remove(i: Int): A   |   s.remove(e: A): Boolean
val b = mutable.ListBuffer(1, 2)
println(b.remove(0))   // => 1

xs.subtractOne(e: A): xs.type
val b = mutable.ListBuffer(1, 2)
b.subtractOne(1)
println(b)   // => ListBuffer(2)

xs.subtractAll(ys: Seq[A]): xs.type
val b = mutable.ListBuffer(1, 2, 3)
b.subtractAll(List(1, 2))
println(b)   // => ListBuffer(3)

xs.clear(): Unit
val b = mutable.ListBuffer(1, 2)
b.clear()
println(b)   // => ListBuffer()

q.enqueue(e: A): q.type
val q = mutable.Queue(1)
q.enqueue(2)
println(q)   // => Queue(1, 2)

q.dequeue(): A
val q = mutable.Queue(1, 2)
println(q.dequeue())   // => 1

s.push(e: A): s.type
val s = mutable.Stack(1)
s.push(2)
println(s)   // => Stack(2, 1)

s.pop(): A
val s = mutable.Stack(1, 2)
println(s.pop())   // => 1

s.top: A
println(mutable.Stack(1, 2).top)   // => 1

d.removeHead(): A
val d = mutable.ArrayDeque(1, 2)
println(d.removeLast())   // => 2

b.result(): String
println(new StringBuilder("ab").result())   // => ab

b.setCharAt(i: Int, c: Char): b.type
val b = new StringBuilder("abc")
b.setCharAt(0, 'Q')
println(b)   // => Qbc

x.getClass: Class[_]
try { 1 / 0 } catch { case e: Throwable => println(e.getClass.getSimpleName) }   // => ArithmeticException

xs.toString: String
println(List(1, 2).toString)   // => List(1, 2)

xs.equals(other: Any): Boolean
println(List(1, 2) == List(1, 2))   // => true

xs.hashCode: Int
println(List(1, 2).hashCode == List(1, 2).hashCode)   // => true

m.size: Int
println(Map("a" -> 1, "b" -> 2).size)   // => 2

m.isEmpty: Boolean
println(Map().isEmpty)   // => true

m.nonEmpty: Boolean
println(Map("a" -> 1).nonEmpty)   // => true

m.apply(k: K): V
println(Map("a" -> 1)("a"))   // => 1

m.get(k: K): Option[V]
println(Map("a" -> 1).get("z"))   // => None

m.getOrElse(k: K, default: V): V
println(Map("a" -> 1).getOrElse("z", 0))   // => 0

m.contains(k: K): Boolean
println(Map("a" -> 1).contains("a"))   // => true

m.keys: Set[K]
println(Map("a" -> 1, "b" -> 2).keys)   // => Set(a, b)

m.keySet: Set[K]
println(Map("a" -> 1).keySet)   // => Set(a)

m.values: Iterable[V]
println(Map("a" -> 1).values)   // => Iterable(1)

m.updated(k: K, v: V): Map[K, V]
println(Map("a" -> 1).updated("b", 2))   // => Map(a -> 1, b -> 2)

m.removed(k: K): Map[K, V]
println(Map("a" -> 1, "b" -> 2).removed("a"))   // => Map(b -> 2)

m + (kv: (K, V)): Map[K, V]
println(Map("a" -> 1) + ("b" -> 2))   // => Map(a -> 1, b -> 2)

m - (k: K): Map[K, V]
println(Map("a" -> 1, "b" -> 2) - "a")   // => Map(b -> 2)

m ++ (other: Map[K, V] | Seq[(K, V)]): Map[K, V]
println(Map("a" -> 1) ++ Map("b" -> 2))   // => Map(a -> 1, b -> 2)

m.concat(other: Map[K, V]): Map[K, V]
println(Map("a" -> 1).concat(Map("b" -> 2)))   // => Map(a -> 1, b -> 2)

m.head: (K, V)
println(Map("a" -> 1, "b" -> 2).head)   // => (a,1)

m.last: (K, V)
println(Map("a" -> 1, "b" -> 2).last)   // => (b,2)

m.headOption: Option[(K, V)]
println(Map("a" -> 1).headOption)   // => Some((a,1))

m.lastOption: Option[(K, V)]
println(Map("a" -> 1).lastOption)   // => Some((a,1))

m.map(f: ((K, V)) => B): Map[K2, V2] | List[B]
val m = Map("a" -> 1, "b" -> 2)
println(m.map { case (k, v) => (k, v * 2) })   // => Map(a -> 2, b -> 4)
println(m.map { case (k, v) => v })           // => List(1, 2)

m.flatMap(f: ((K, V)) => Seq[B]): Map[K2, V2] | List[B]
println(Map("a" -> 1).flatMap { case (k, v) => List((k, v), (k + "!", v)) })   // => Map(a -> 1, a! -> 1)

m.collect(pf: PartialFunction[(K, V), B]): Map[K2, V2] | List[B]
println(Map("a" -> 1, "b" -> 2).collect { case (k, v) if v > 1 => (k, v) })   // => Map(b -> 2)

m.collectFirst(pf: PartialFunction[(K, V), B]): Option[B]
println(Map("a" -> 1).collectFirst { case (k, v) => v })   // => Some(1)

m.filter(p: ((K, V)) => Boolean): Map[K, V]
println(Map("a" -> 1, "b" -> 2).filter { case (k, v) => v > 1 })   // => Map(b -> 2)

m.filterNot(p: ((K, V)) => Boolean): Map[K, V]
println(Map("a" -> 1, "b" -> 2).filterNot { case (k, v) => v > 1 })   // => Map(a -> 1)

m.withFilter(p: ((K, V)) => Boolean): Map[K, V]
println(Map("a" -> 1, "b" -> 2).withFilter { case (k, v) => v > 1 })   // => Map(b -> 2)

m.takeWhile(p: ((K, V)) => Boolean): Map[K, V]
println(Map("a" -> 1, "b" -> 2).takeWhile { case (k, v) => v < 2 })   // => Map(a -> 1)

m.dropWhile(p: ((K, V)) => Boolean): Map[K, V]
println(Map("a" -> 1, "b" -> 2).dropWhile { case (k, v) => v < 2 })   // => Map(b -> 2)

m.partition(p: ((K, V)) => Boolean): (Map[K, V], Map[K, V])
println(Map("a" -> 1, "b" -> 2).partition { case (k, v) => v > 1 })   // => (Map(b -> 2),Map(a -> 1))

m.foreach(f: ((K, V)) => Unit): Unit
Map("a" -> 1).foreach { case (k, v) => print(k + v) }   // => a1

m.exists(p: ((K, V)) => Boolean): Boolean
println(Map("a" -> 1).exists { case (k, v) => v == 1 })   // => true

m.forall(p: ((K, V)) => Boolean): Boolean
println(Map("a" -> 1).forall { case (k, v) => v > 0 })   // => true

m.count(p: ((K, V)) => Boolean): Int
println(Map("a" -> 1, "b" -> 2).count { case (k, v) => v > 1 })   // => 1

m.find(p: ((K, V)) => Boolean): Option[(K, V)]
println(Map("a" -> 1).find { case (k, v) => v == 1 })   // => Some((a,1))

m.foldLeft(z: B)(op: (B, (K, V)) => B): B
println(Map("a" -> 1, "b" -> 2).foldLeft(0) { (acc, kv) => acc + kv._2 })   // => 3

m.foldRight(z: B)(op: ((K, V), B) => B): B
println(Map("a" -> 1).foldRight(0) { (kv, acc) => acc + kv._2 })   // => 1

m.fold(z: B)(op: (B, (K, V)) => B): B
println(Map("a" -> 1).fold(0) { (acc, kv) => acc + kv._2 })   // => 1

m.reduce(op: ((K, V), (K, V)) => (K, V)): (K, V)
println(Map("a" -> 1, "b" -> 2).reduce { (x, y) => (x._1 + y._1, x._2 + y._2) })   // => (ab,3)

m.maxBy(f: ((K, V)) => C): (K, V)
println(Map("a" -> 1, "b" -> 2).maxBy { case (k, v) => v })   // => (b,2)

m.minBy(f: ((K, V)) => C): (K, V)
println(Map("a" -> 1, "b" -> 2).minBy { case (k, v) => v })   // => (a,1)

m.groupBy(f: ((K, V)) => C): HashMap[C, List[(K, V)]]
println(Map("a" -> 1, "b" -> 2).groupBy { case (k, v) => v % 2 })   // => HashMap(0 -> List((b,2)), 1 -> List((a,1)))

m.sortBy(f: ((K, V)) => C): List[(K, V)]
println(Map("a" -> 2, "b" -> 1).sortBy { case (k, v) => v })   // => List((b,1), (a,2))

m.unzip: (List[K], List[V])
println(Map("a" -> 1, "b" -> 2).unzip)   // => (List(a, b),List(1, 2))

m.zipWithIndex: List[((K, V), Int)]
println(Map("a" -> 1).zipWithIndex)   // => List(((a,1),0))

m.mkString[(sep)|(pre, sep, post)]: String
println(Map("a" -> 1, "b" -> 2).mkString(";"))   // => (a,1);(b,2)

m.toList: List[(K, V)]
println(Map("a" -> 1).toList)   // => List((a,1))

m.toSeq: List[(K, V)]
println(Map("a" -> 1).toSeq)   // => List((a,1))

m.toVector: Vector[(K, V)]
println(Map("a" -> 1).toVector)   // => Vector((a,1))

m.toArray: Array[(K, V)]
println(Map("a" -> 1).toArray)   // => Array((a,1))

m.toSet: Set[(K, V)]
println(Map("a" -> 1).toSet)   // => Set((a,1))

m.toMap: Map[K, V]
println(Map("a" -> 1).toMap)   // => Map(a -> 1)

m += (kv: (K, V)): m.type
val m = mutable.Map("a" -> 1)
m += ("b" -> 2)
println(m)   // => HashMap(a -> 1, b -> 2)

m ++= (other: Map[K, V] | Seq[(K, V)]): m.type
val m = mutable.Map("a" -> 1)
m ++= Map("b" -> 2)
println(m)   // => HashMap(a -> 1, b -> 2)

m -= (k: K): m.type
val m = mutable.Map("a" -> 1, "b" -> 2)
m -= "a"
println(m)   // => HashMap(b -> 2)

m --= (ks: Seq[K]): m.type
val m = mutable.Map("a" -> 1, "b" -> 2)
m --= List("a", "b")
println(m)   // => HashMap()

m.addOne(kv: (K, V)): m.type
val m = mutable.Map("a" -> 1)
m.addOne("b" -> 2)
println(m)   // => HashMap(a -> 1, b -> 2)

m.addAll(other: Seq[(K, V)]): m.type
val m = mutable.Map("a" -> 1)
m.addAll(List("b" -> 2))
println(m)   // => HashMap(a -> 1, b -> 2)

m.subtractOne(k: K): m.type
val m = mutable.Map("a" -> 1, "b" -> 2)
m.subtractOne("a")
println(m)   // => HashMap(b -> 2)

m.subtractAll(ks: Seq[K]): m.type
val m = mutable.Map("a" -> 1, "b" -> 2)
m.subtractAll(List("a"))
println(m)   // => HashMap(b -> 2)

m.put(k: K, v: V): Option[V]
val m = mutable.Map("a" -> 1)
println(m.put("a", 2))   // => Some(1)

m.update(k: K, v: V): Unit
val m = mutable.Map("a" -> 1)
m("b") = 2
println(m)   // => HashMap(a -> 1, b -> 2)

m.getOrElseUpdate(k: K, default: V): V
val m = mutable.Map("a" -> 1)
println(m.getOrElseUpdate("b", 5))   // => 5
println(m)                          // => HashMap(a -> 1, b -> 5)

m.remove(k: K): Option[V]
val m = mutable.Map("a" -> 1)
println(m.remove("a"))   // => Some(1)

m.clear(): Unit
val m = mutable.Map("a" -> 1)
m.clear()
println(m)   // => HashMap()

s.length: Int
println("abc".length)   // => 3

s.size: Int
println("abc".size)   // => 3

s.isEmpty: Boolean
println("".isEmpty)   // => true

s.nonEmpty: Boolean
println("a".nonEmpty)   // => true

s.toUpperCase: String
println("abc".toUpperCase)   // => ABC

s.toLowerCase: String
println("ABC".toLowerCase)   // => abc

s.trim: String
println(" a ".trim)   // => a

s.concat(other: String): String
println("abc".concat("d"))   // => abcd

s.split(regex: String): Array[String]
println("a1b22c".split("[0-9]+").mkString("/"))   // => a/b/c

s.matches(regex: String): Boolean
println("a1".matches("[a-z][0-9]"))   // => true

s.replaceAll(regex: String, repl: String): String
println("a1b2".replaceAll("[0-9]", "#"))   // => a#b#

s.replaceFirst(regex: String, repl: String): String
println("a1b2".replaceFirst("[0-9]", "#"))   // => a#b2

s.r: Regex
println("(\\d+)".r.findFirstIn("ab12"))   // => Some(12)

s.toList: List[Char]
println("abc".toList)   // => List(a, b, c)
println("abc".toList.map(_.toInt))   // => List(97, 98, 99)

s.toSeq: Seq[Char]
println("ab".toSeq)   // => ab

s.reverse: String
println("abc".reverse)   // => cba

s.toInt: Int
println("42".toInt + 1)   // => 43

s.toByte: Byte
println("127".toByte)   // => 127

s.toShort: Short
println("-32768".toShort)   // => -32768

s.toBoolean: Boolean
println("TRUE".toBoolean)   // => true

s.toDouble: Double
println("1.5".toDouble * 2)   // => 3.0

s.charAt(i: Int): String
println("abc".charAt(1))   // => b

s.contains(sub: String): Boolean
println("abc".contains("bc"))   // => true

s.startsWith(prefix: String): Boolean
println("abc".startsWith("a"))   // => true

s.endsWith(suffix: String): Boolean
println("abc".endsWith("c"))   // => true

s.substring(begin: Int[, end: Int]): String
println("abc".substring(1))      // => bc
println("abc".substring(1, 2))   // => b

c.toInt: Int
println('a'.toInt)   // => 97
println('5'.toInt)   // => 53

n.toChar: Char
println(('a' + 1).toChar)   // => b

c.asDigit: Int
println('5'.asDigit)   // => 5

c.toUpper: Char
println('a'.toUpper)   // => A
println("abc".map(_.toUpper))   // => ABC

c.toLower: Char
println('Z'.toLower)   // => z

c.isDigit: Boolean
println('5'.isDigit)   // => true
println('a'.isLetter)   // => true

n.abs: Int
println(-3.abs)   // => 3

Int.MaxValue: Int
println(Int.MaxValue)   // => 2147483647

Integer.parseInt(s: String, radix?: Int): Int
println(Integer.parseInt("ff", 16))   // => 255

Integer.toHexString(i: Int): String
println(Integer.toHexString(-1))   // => ffffffff
println((-1L).toHexString)         // => ffffffffffffffff

Character.isDigit(c: Char): Boolean
println(Character.isDigit('5'))   // => true

String.valueOf(x: Any): String
println(String.valueOf(42))   // => 42

n.toInt: Int
println(5.toInt)   // => 5

n.toLong: Long
println(5.toLong)   // => 5

n.toDouble: Double
println(7.toDouble)   // => 7.0

n.toFloat: Float
println(7.toFloat)          // => 7.0
println(Int.MaxValue.toFloat)   // => 2.1474836E9

n.toByte: Byte
println(300.toByte)        // => 44
println(128.toByte)        // => -128
println(128.toByte + 1)    // => -127

n.toShort: Short
println(70000.toShort)   // => 4464

n.max(other: Int): Int
println(5.max(9))   // => 9

n.min(other: Int): Int
println(5.min(9))   // => 5

n & (other: Int): Int
println(6 & 3)   // => 2

n | (other: Int): Int
println(6 | 3)   // => 7

n ^ (other: Int): Int
println(6 ^ 3)   // => 5

~n: Int
println(~6)   // => -7

n << (dist: Int): Int
println(1 << 4)    // => 16
println(1 << 33)   // => 2

n >> (dist: Int): Int
println(-16 >> 2)   // => -4

n >>> (dist: Int): Int
println(-16 >>> 2)   // => 1073741820

d.abs: Double
println(-2.5.abs)   // => 2.5

d.toInt: Int
println(2.7.toInt)   // => 2

d.toLong: Long
println(2.7.toLong)   // => 2

d.toDouble: Double
println(2.5.toDouble)   // => 2.5

d.toFloat: Float
println(2.5.toFloat)              // => 2.5
println(0.1.toFloat.toDouble)   // => 0.10000000149011612

d.isNaN: Boolean
println((0.0 / 0.0).isNaN)   // => true

d.isInfinity: Boolean
println((1.0 / 0.0).isInfinity)   // => true

d.isInfinite: Boolean
println((1.0 / 0.0).isInfinite)   // => true

d.round: Long
println(2.7.round)   // => 3

b & (other: Boolean): Boolean
println(true & false)   // => false

b | (other: Boolean): Boolean
println(true | false)   // => true

b ^ (other: Boolean): Boolean
println(true ^ false)   // => true

!b: Boolean
println(!true)   // => false

t._1: A
println((1, "x")._1)   // => 1

t._2: B
println((1, "x")._2)   // => x

t.apply(i: Int): Any
println((1, "x")(0))   // => 1

t.productArity: Int
println((1, 2, 3).productArity)   // => 3

c.copy(field = v, …): C
case class P(x: Int, y: Int)
println(P(1, 2).copy(y = 9))   // => P(1,9)

instance.field: T
class Box(val n: Int)
println(new Box(3).n)   // => 3

some.value: A
println(List(1, 2).find(_ > 1).value)   // => 2

e.left: LeftProjection
val e: Either[String, Int] = Left("bad")
println(e.left.getOrElse("none"))   // => bad
println(e.left.map(_.length))       // => Left(3)

c.toString: String
case class P(x: Int, y: Int)
println(P(1, 2))   // => P(1,2)

c.equals(other: Any): Boolean
case class P(x: Int)
println(P(1) == P(1))   // => true

c.hashCode: Int
case class P(x: Int)
println(P(1).hashCode == P(1).hashCode)   // => true

(p: T, …) => body
val add = (a: Int, b: Int) => a + b
println(add(1, 2))   // => 3

expr containing _
println(List(1, 2).map(_ * 2))     // => List(2, 4)
println(List(1, 2).map { _ * 2 })  // => List(2, 4)
println(List(1, 2, 3).foldLeft(0) { _ + _ })   // => 6

recv.m { … }
println(List(1, 2, 3).filter { _ > 1 })          // => List(2, 3)
println(List(1, 2).map { x => if (x > 1) "hi" else "lo" })   // => List(lo, hi)

xs.map(namedDef)
def inc(x: Int) = x + 1
println(List(1, 2).map(inc))   // => List(2, 3)

f.apply(args): R
val f = (x: Int) => x + 1
println(f.apply(1))   // => 2

f.call(args): R
val f = (x: Int) => x + 1
println(f.call(1))   // => 2

pf.isDefinedAt(x: A): Boolean
val pf: PartialFunction[Int, String] = { case 1 => "one" }
println(pf.isDefinedAt(2))   // => false

pf.applyOrElse(x: A, default: A => B): B
val pf: PartialFunction[Int, String] = { case 1 => "one" }
println(pf.applyOrElse(2, (x: Int) => "no"))   // => no

pf.lift: A => Option[B]
val pf: PartialFunction[Int, Int] = { case 1 => 10 }
println(pf.lift(2))   // => None

pf.orElse(other: PartialFunction[A, B]): PartialFunction[A, B]
val a: PartialFunction[Int, Int] = { case 1 => 10 }
val b: PartialFunction[Int, Int] = { case 2 => 20 }
println((a orElse b)(2))   // => 20

f.andThen(g: B => C): A => C
val f = (x: Int) => x + 1
val g = (x: Int) => x * 2
println((f andThen g)(3))   // => 8

f.compose(g: C => A): C => B
val f = (x: Int) => x + 1
val g = (x: Int) => x * 2
println((f compose g)(3))   // => 7

math.Pi: Double
println(math.Pi)   // => 3.141592653589793

math.E: Double
println(math.E)   // => 2.718281828459045

math.abs(x: Int): Int   |   math.abs(x: Double): Double
println(math.abs(-3))     // => 3
println(math.abs(-3.5))   // => 3.5

math.signum(x: Int): Int   |   Math.signum(x): Double
println(math.signum(-5))   // => -1
println(Math.signum(-5))   // => -1.0

math.max(a, b)
println(math.max(2, 3))     // => 3
println(math.max(2, 3.0))   // => 3.0

math.min(a, b)
println(math.min(2, 3))   // => 2

math.round(x: Double): Long
println(math.round(2.5))    // => 3
println(math.round(-2.5))   // => -2

math.floor(x: Double): Double
println(math.floor(2.7))   // => 2.0

math.ceil(x: Double): Double
println(math.ceil(2.1))   // => 3.0

math.rint(x: Double): Double
println(math.rint(2.5))   // => 2.0

math.sqrt(x: Double): Double
println(math.sqrt(16.0))   // => 4.0

math.cbrt(x: Double): Double
println(math.cbrt(27.0))   // => 3.0

math.exp(x: Double): Double
println(math.exp(0.0))   // => 1.0

math.log(x: Double): Double
println(math.log(1.0))   // => 0.0

math.log10(x: Double): Double
println(math.log10(100.0))   // => 2.0

math.pow(x: Double, y: Double): Double
println(math.pow(2, 10))   // => 1024.0

math.hypot(x: Double, y: Double): Double
println(math.hypot(3, 4))   // => 5.0

math.sin(x: Double): Double
println(math.sin(0.0))   // => 0.0

math.cos(x: Double): Double
println(math.cos(0.0))   // => 1.0

math.tan(x: Double): Double
println(math.tan(0.0))   // => 0.0

math.asin(x: Double): Double
println(math.asin(0.0))   // => 0.0

math.acos(x: Double): Double
println(math.acos(1.0))   // => 0.0

math.atan(x: Double): Double
println(math.atan(0.0))   // => 0.0

math.atan2(y: Double, x: Double): Double
println(math.atan2(0.0, 1.0))   // => 0.0

math.toRadians(deg: Double): Double
println(math.toRadians(180.0))   // => 3.141592653589793

math.toDegrees(rad: Double): Double
println(math.toDegrees(math.Pi))   // => 180.0

new Throwable([msg: String])
try { throw new RuntimeException("x") } catch { case e: Throwable => println("caught") }   // => caught

new Exception([msg: String])
try { throw new IllegalStateException("x") } catch { case e: Exception => println("caught") }   // => caught

new Error([msg: String])
try { throw new Error("boom") } catch { case e: Error => println(e.getMessage) }   // => boom

new RuntimeException([msg: String])
try { throw new RuntimeException("m") } catch { case e: RuntimeException => println(e) }   // => java.lang.RuntimeException: m

new ArithmeticException([msg: String])
println(try { 1 / 0 } catch { case _: ArithmeticException => -1 })   // => -1

new IllegalArgumentException([msg: String])
println(try { (1 to 3 by 0).toList } catch { case e: IllegalArgumentException => e.getMessage })   // => step cannot be 0.

new IllegalStateException([msg: String])
try { throw new IllegalStateException("bad") } catch { case e: RuntimeException => println(e) }   // => java.lang.IllegalStateException: bad

new NumberFormatException([msg: String])
try { "z".toInt } catch { case e: NumberFormatException => println(e.getMessage) }   // => For input string: "z"

new IndexOutOfBoundsException([msg: String])
println(try { List(1, 2)(5) } catch { case e: IndexOutOfBoundsException => e.getMessage })   // => 5

new StringIndexOutOfBoundsException([msg: String])
println(try { "abc".charAt(9) } catch { case e: IndexOutOfBoundsException => "oob" })   // => oob

new ArrayIndexOutOfBoundsException([msg: String])
val a = Array(1)
println(try { a(5) = 0; "ok" } catch { case e: IndexOutOfBoundsException => "oob" })   // => oob

new NullPointerException([msg: String])
try { throw new NullPointerException() } catch { case e: RuntimeException => println(e) }   // => java.lang.NullPointerException

new ClassCastException([msg: String])
try { throw new ClassCastException("x") } catch { case e: ClassCastException => println(e.getMessage) }   // => x

new UnsupportedOperationException([msg: String])
println(try { List().max } catch { case e: UnsupportedOperationException => e.getMessage })   // => empty.max

new NoSuchElementException([msg: String])
println(try { List().head } catch { case e: NoSuchElementException => e.getMessage })   // => head of empty list

new MatchError([msg: String])
println(try { 2 match { case 1 => "one" } } catch { case e: MatchError => "no arm" })   // => no arm

e.getMessage: String
println(new RuntimeException("m").getMessage)   // => m

e.getLocalizedMessage: String
println(new RuntimeException("m").getLocalizedMessage)   // => m

e.toString: String
println(new IllegalStateException("x"))   // => java.lang.IllegalStateException: x

class MyErr(msg: String) extends Exception(msg)
class MyErr(msg: String) extends Exception(msg)
object T extends App {
  try { throw new MyErr("boom") } catch { case e: MyErr => println("caught") }   // => caught
}

a + b
println("n=" + 41)   // => n=41

a - b   |   -a
println(3 - 1)   // => 2

a * b
println(3 * 2)   // => 6

a / b
println(7 / 2)     // => 3
println(7 / 2.0)   // => 3.5

a % b
println(7 % 3)   // => 1

a == b
println("a" == "a")   // => true

a != b
println(1 != 2)   // => true

a < b
println(1 < 2)   // => true

a > b
println(2 > 1)   // => true

a <= b
println(1 <= 1)   // => true

a >= b
println(2 >= 3)   // => false

a && b
println(true && false)   // => false

a || b
println(false || true)   // => true

!a
println(!true)   // => false

a & b
println(6 & 3)                          // => 2
println(Set(1, 2, 3) & Set(2, 3, 4))   // => Set(2, 3)

a | b
println(6 | 3)       // => 7
println(5 & 3 | 2)   // => 3

a ^ b
println(6 ^ 3)   // => 5

~a
println(~6)   // => -7

a << b
println(1 << 4)   // => 16

a >> b
println(-16 >> 2)   // => -4

a >>> b
println(-16 >>> 2)   // => 1073741820

e :: xs
println(1 :: 2 :: Nil)   // => List(1, 2)

xs :+ e
println(List(1, 2) :+ 3)   // => List(1, 2, 3)

e +: xs
println(0 +: List(1, 2))   // => List(0, 1, 2)

xs ++ ys
println(List(1, 2) ++ List(3))   // => List(1, 2, 3)

xs -- ys
println(List(1, 2, 3) -- List(2))   // => List(1, 3)

s &~ t
println(Set(1, 2, 3) &~ Set(2))   // => Set(1, 3)

k -> v
println("a" -> 1)   // => (a,1)

name = expr   |   xs(i) = v
var n = 1
n = 2
println(n)   // => 2

n += e
var n = 0
n += 5
println(n)   // => 5

n -= e
var n = 5
n -= 2
println(n)   // => 3

n *= e
var n = 3
n *= 4
println(n)   // => 12

n /= e
var n = 12
n /= 4
println(n)   // => 3

n %= e
var n = 7
n %= 3
println(n)   // => 1

a method b
println(List(1, 2) map (_ * 2))   // => List(2, 4)

println(x: Any): Unit
println(3.0)   // => 3.0

print(x: Any): Unit
print("a"); print("b")   // => ab

s"text $name text ${expr}"
println(s"a${1 + 1}b")   // => a2b

f"${expr}%spec"
println(f"${3.14159}%.2f")   // => 3.14

raw"text\n$name"
println(raw"a\nb")   // => a\nb

f"${x}%[flags][width][.prec]conv"
println(f"${7}%05d")   // => 00007

rust { pub extern "C" fn name(x: i64) -> i64 { … } }
rust { pub extern "C" fn triple(x: i64) -> i64 { x * 3 } }
println(triple(5))   // => 15