Functions

def name(param: Type, ...): ReturnType = body defines a function. Parameters always need their types; the return type can usually be inferred from the body. The body is an expression — often a single line — and its value is what the function returns. There is no need for return. A multi-line body is an indented block, and its last expression is the result.

def square(x: Int): Int = x * x

def area(width: Double, height: Double) = width * height

def greet(name: String): Unit =
  println(s"Hello, $name")

def describe(n: Int): String =
  val sign = if n < 0 then "negative" else "non-negative"
  s"$n is $sign"

@main def run(): Unit =
  println(square(7))
  println(area(2.5, 4))
  greet("Asha")
  println(describe(-3))

49
10.0
Hello, Asha
-3 is negative

def factorial(n: Int) =
  if n <= 1 then 1 else n * factorial(n - 1)

@main def run(): Unit =
  println(factorial(5))

-- [E044] Cyclic Error: Main.scala:2:28
2 |  if n <= 1 then 1 else n * factorial(n - 1)
  |                            ^
  |                Overloaded or recursive method factorial needs return type
  |
  |                 Run with -explain-cyclic for more details.
1 error found
Compilation failed

def factorial(n: Int): Int =
  if n <= 1 then 1 else n * factorial(n - 1)

@main def run(): Unit =
  println(factorial(5))

A parameter can have a default value, used when the caller leaves it out. Callers can also pass arguments by name — ssl = false — which lets them skip earlier defaults, pass arguments in any order, and makes a call with several booleans or numbers readable. Between them, these two features replace most of the overloaded methods and builder classes you would write in Java.

def connect(host: String, port: Int = 5432, ssl: Boolean = true): String =
  s"$host:$port ssl=$ssl"

@main def run(): Unit =
  println(connect("db.local"))
  println(connect("db.local", 6543))
  println(connect("db.local", ssl = false))
  println(connect(port = 3306, host = "mysql.local"))

db.local:5432 ssl=true
db.local:6543 ssl=true
db.local:5432 ssl=false
mysql.local:3306 ssl=true

def greet(name: String, greeting: String = "Hello"): String =
  s"$greeting, $name!"

@main def run(): Unit =
  println(greet(greeting = "Hi"))

-- [E171] Type Error: Main.scala:5:15
5 |  println(greet(greeting = "Hi"))
  |          ^^^^^^^^^^^^^^^^^^^^^^
  |missing argument for parameter name of method greet: (name: String, greeting: String): String
1 error found
Compilation failed

def greet(name: String, greeting: String = "Hello"): String =
  s"$greeting, $name!"

@main def run(): Unit =
  println(greet("Ravi", greeting = "Hi"))

A recursive function calls itself on a smaller problem until it reaches a base case. Each call that is still waiting for a result takes a frame on the JVM call stack, and the stack is only a few thousand frames deep — so a naive recursion over a million items crashes with StackOverflowError. The fix is tail recursion: if the recursive call is the very last thing the function does, the Scala compiler turns it into a loop. @tailrec asks the compiler to prove it did.

import scala.annotation.tailrec

def factorial(n: Int): BigInt =
  if n <= 1 then 1 else n * factorial(n - 1)

@tailrec
def sumTo(n: Int, acc: Long = 0): Long =
  if n == 0 then acc else sumTo(n - 1, acc + n)

@main def run(): Unit =
  println(factorial(5))
  println(factorial(25))
  println(sumTo(4))
  println(sumTo(1_000_000))

120
15511210043330985984000000
10
500000500000

import scala.annotation.tailrec

@tailrec
def factorial(n: Int): Long =
  if n <= 1 then 1L else n * factorial(n - 1)

@main def run(): Unit =
  println(factorial(5))

-- Error: Main.scala:5:38
5 |  if n <= 1 then 1L else n * factorial(n - 1)
  |                             ^^^^^^^^^^^^^^^^
  |                 Cannot rewrite recursive call: it is not in tail position
1 error found
Compilation failed

import scala.annotation.tailrec

@tailrec
def factorial(n: Int, acc: Long = 1): Long =
  if n <= 1 then acc else factorial(n - 1, acc * n)

@main def run(): Unit =
  println(factorial(5))

An accumulator parameter is an implementation detail callers should not see. Hide it in a nested function: a def inside another def is visible only there, and it can read the outer function's parameters and vals directly.

import scala.annotation.tailrec

def isPalindrome(text: String): Boolean =
  val clean = text.toLowerCase.filter(c => c.isLetterOrDigit)

  @tailrec
  def check(i: Int, j: Int): Boolean =
    if i >= j then true
    else if clean(i) != clean(j) then false
    else check(i + 1, j - 1)

  check(0, clean.length - 1)

@main def run(): Unit =
  println(isPalindrome("Never odd or even"))
  println(isPalindrome("Scala"))

true
false

Functions in Scala are values: you can store one in a val, pass it to a method, and return it from another function. The literal syntax is a lambda (also called an anonymous function): (x: Int) => x * 2. Its type is written Int => Int, or (Int, Int) => Int for two parameters. When the compiler already knows the parameter types — for example inside map on a List[Int] — you can leave them out.

@main def run(): Unit =
  val double = (x: Int) => x * 2
  val add: (Int, Int) => Int = (a, b) => a + b
  println(double(21))
  println(add(2, 3))

  val nums = List(1, 2, 3, 4)
  println(nums.map(double))
  println(nums.map(n => n + 1))
  println(nums.map(_ * 10))
  println(nums.filter(_ % 2 == 0))
  println(nums.reduce(_ + _))

  val shout: String => String = _.toUpperCase + "!"
  println(shout("hi"))

42
5
List(2, 4, 6, 8)
List(2, 3, 4, 5)
List(10, 20, 30, 40)
List(2, 4)
10
HI!

@main def run(): Unit =
  val nums = List(1, 2, 3)
  println(nums.map(_ * _))

-- [E086] Syntax Error: Main.scala:3:19
3 |  println(nums.map(_ * _))
  |                   ^^^^^
  |                   Wrong number of parameters, expected: 1
1 error found
Compilation failed

@main def run(): Unit =
  val nums = List(1, 2, 3)
  println(nums.map(n => n * n))

A def defines a method: it belongs to an enclosing class, object or file and is not itself a value. A lambda is a function value: an ordinary object with an apply method, an instance of Function1, Function2 and so on. double(4) is really double.apply(4). When you use a method where a function value is expected — nums.map(square) or val f = square — Scala 3 converts it automatically. This is called eta-expansion.

def square(x: Int): Int = x * x

@main def run(): Unit =
  val f = square
  val inc = (x: Int) => x + 1
  println(f(5))
  println(inc.apply(5))
  println(List(1, 2, 3).map(square))

  val incThenSquare = inc.andThen(square)
  val squareThenInc = inc.compose(square)
  println(incThenSquare(2))
  println(squareThenInc(2))

25
6
List(1, 4, 9)
9
5

A method can have more than one parameter list: def add(a: Int)(b: Int). Call it with both, add(2)(3), or supply only the first to get back a function waiting for the rest — add(10) is an Int => Int. This is currying. In everyday Scala it matters for two reasons: partial application, and letting the last argument be a block in braces, which is how Scala libraries make method calls look like built-in syntax.

def add(a: Int)(b: Int): Int = a + b

def timed(label: String)(body: => Int): Int =
  println(s"[$label] start")
  val result = body
  println(s"[$label] result $result")
  result

@main def run(): Unit =
  println(add(2)(3))
  val addTen = add(10)
  println(addTen(5))
  println(List(1, 2, 3).map(add(100)))

  val total = timed("sum") {
    (1 to 4).sum
  }
  println(total)
  println(List(1, 2, 3).foldLeft(0)(_ + _))

5
15
List(101, 102, 103)
[sum] start
[sum] result 10
10
6

Normally an argument is evaluated once, before the function runs (by-value). Put => before a parameter's type — msg: => String — and it becomes by-name: the argument expression is passed unevaluated and runs every time the parameter is used, and not at all if it is never used. That is how getOrElse, loggers, assertions and the timed block above avoid doing work they do not need.

def expensive(): Int =
  println("computing...")
  42

def logByValue(debug: Boolean, x: Int): Unit =
  if debug then println(s"value $x")

def logByName(debug: Boolean, x: => Int): Unit =
  if debug then println(s"value $x")

def twice(x: => Int): Int = x + x

@main def run(): Unit =
  logByValue(false, expensive())
  logByName(false, expensive())
  println("---")
  println(twice(expensive()))

computing...
---
computing...
computing...
84

A last parameter typed Int* accepts any number of arguments, including zero. Inside the method it is a Seq[Int]. To pass an existing collection into a varargs parameter, spread it with xs* (Scala 2 wrote xs: _*). List(1, 2, 3) and println-style APIs are built on this.

def sumAll(nums: Int*): Int = nums.sum

def log(level: String, parts: String*): Unit =
  println(s"[$level] ${parts.mkString(" ")}")

@main def run(): Unit =
  println(sumAll())
  println(sumAll(1, 2, 3))
  val xs = List(4, 5, 6)
  println(sumAll(xs*))
  log("INFO", "server", "started", "on", "8080")
  log("WARN")

0
6
15
[INFO] server started on 8080
[WARN] 

def sum(nums: Int*): Int = nums.sum

@main def run(): Unit =
  val list = List(1, 2, 3)
  println(sum(list))

-- [E007] Type Mismatch Error: Main.scala:5:14
5 |  println(sum(list))
  |              ^^^^
  |              Found:    (list : List[Int])
  |              Required: Int
1 error found
Compilation failed

def sum(nums: Int*): Int = nums.sum

@main def run(): Unit =
  val list = List(1, 2, 3)
  println(sum(list*))

def

Defines a method: a named function belonging to an enclosing class, object or file.

Default argument

A parameter value used when the caller omits that argument.

Named argument

Passing an argument as name = value, in any order.

Tail recursion

Recursion where the recursive call is the last step, so the compiler can turn it into a loop.

@tailrec

An annotation that makes compilation fail unless the method really is tail recursive.

Accumulator

An extra parameter that carries a partial result through recursive calls.

Lambda

An anonymous function value, such as (x: Int) => x * 2.

Placeholder _

Shorthand for a lambda parameter; each _ is the next parameter.

Eta-expansion

Automatic conversion of a method into a function value when one is expected.

Currying

Splitting parameters into several lists so a function can be applied one list at a time.

By-name parameter

A parameter declared x: => T whose argument is evaluated each time it is used, not before the call.

Varargs

A last parameter T* that accepts any number of arguments as a Seq[T].