Anonymous Functions and Lambdas

An anonymous function, or lambda, is a function value written inline without being given a name via def - its full syntax is (parameters) => expression, such as (x: Int) => x + 1, and it is typically used exactly once, right where it's needed, most often as an argument to a higher-order function like map or filter. Unlike a def, which declares a method, a lambda expression is itself a value of type FunctionN (e.g., Function1[Int, Int]) that can be stored in a val, passed around, or invoked immediately, which is what makes it interchangeable with any other function value in Scala's type system.

When the parameter type can be inferred from context - such as inside list.map(...) where Scala already knows the list's element type - you can drop the explicit type annotation and even the parentheses for a single untyped parameter, writing list.map(x => x * 2) instead of list.map((x: Int) => x * 2). Scala also offers a terser underscore placeholder syntax for simple, single-use expressions: list.map(_ * 2) is equivalent to list.map(x => x * 2), where each underscore represents one positional argument, though this shorthand becomes confusing and should be avoided once an expression needs to reference the same parameter more than once or has multiple parameters with unclear roles.

Lambdas are the primary way to customize collection operations without writing a separate named method for every one-off transformation: sortBy(_.age) sorts by a derived key, exists(_ > 100) checks for at least one matching element, and reduce((a, b) => if (a > b) a else b) finds a maximum without importing a utility function. Because lambdas are lightweight, idiomatic Scala tends to favor many small, inline lambdas over verbose loops, which keeps the transformation logic co-located with the operation it customizes and avoids naming trivial one-off helper functions that would only ever be called once.

A lambda that references a variable defined outside its own parameter list - such as val threshold = 100; nums.filter(x => x > threshold) - is called a closure, because it 'closes over' threshold from the enclosing scope and keeps a live reference to it rather than a frozen copy. If the captured variable is a mutable var, later changes to it are visible inside the closure the next time it runs, which is powerful for building stateful counters or accumulators but can also introduce subtle bugs if a closure escapes its original context and is called after the captured variable has changed unexpectedly.