Syntax and immutability

Values, inferred types, methods versus functions, and why Scala makes immutability the default you have to opt out of.

Values and types

Scala runs on the JVM and everything is an object, including numbers. val declares a binding that cannot be reassigned and var declares one that can. The type is usually inferred, but it is still checked by the compiler.

// scalac Main.scala && scala Main
object Main {
  def main(args: Array[String]): Unit =
    println("Hello, world")
}

// most files are small enough to run as a script: scala script.scala
val name = "Ada"              // inferred String, cannot be reassigned
val count: Int = 3            // explicit type
var total = 0                 // reassignable
total += count

// everything is an expression: if, match and blocks all return values
val label = if (count > 2) "many" else "few"
val doubled = { val base = count * 2; base + 1 }

// string interpolation, with an optional format
val message = s"$name has $count items"
val money = f"${1.5}%.2f"     // braces are needed for expressions and formats

Methods and functions

// a method: it belongs to an object
def add(a: Int, b: Int): Int = a + b

// a function value: an object you can pass around and store
val addFn: (Int, Int) => Int = (a, b) => a + b

// the underscore form for a short lambda
val double: Int => Int = _ * 2

// default and named arguments
def greet(name: String, greeting: String = "Hello"): String = s"$greeting, $name"
greet("Ada")
greet(name = "Grace", greeting = "Hi")

// a block body when the logic needs more than one line
def classify(n: Int): String = {
  if (n < 0) "negative"
  else if (n == 0) "zero"
  else "positive"
}                          // the last expression is the result; no return keyword

• A method is not a value: add must be converted, as add _ or add(_, _), before it can be passed as an argument.
• Unit is the type of an expression that produces nothing useful, such as println.
• Give public methods an explicit return type: it makes compiler errors point at the mistake instead of at the inferred type.
• return exists but is discouraged. Inside a lambda it throws rather than returning from the enclosing method.

Immutability by default

// prefer building a new value to changing an existing one
val xs = List(1, 2, 3)
val ys = xs :+ 4              // a new list; xs is unchanged

// mutable collections exist, but opt in deliberately and freeze before sharing
val buf = scala.collection.mutable.ArrayBuffer.empty[Int]
buf += 1
val snapshot = buf.toList

// copy a value with one field changed
case class User(name: String, age: Int)
val ada = User("Ada", 36)
val older = ada.copy(age = 37)

FAQ

Related

Case classes and pattern matching Collections and functional style

Last refreshed 2026-09-18.