What Is a Function in Scala?
In Scala, a function is a named, reusable block of code that takes zero or more typed parameters and produces a value. Unlike purely object-oriented languages where every piece of logic must live inside a class method, Scala treats functions as first-class citizens: they can be assigned to variables, passed as arguments, and returned from other functions. The most common way to introduce a function is the def keyword, which defines a method on whatever type contains it (a class, object, or trait), while function values created with => syntax are objects of type FunctionN. This dual nature - methods defined with def and function values as objects - is central to how Scala blends object-oriented and functional programming.
Cricket analogy: Think of a Scala function like a signature delivery a bowler such as Jasprit Bumrah can bowl on demand - a reusable, named routine (the yorker) that can be called again and again in any match, and even handed off as a plan to a teammate.
Defining Functions with def
A def function declaration specifies a name, a parenthesized parameter list with explicit types, an optional return type after a colon, and a body. If the body is a single expression, the equals sign directly precedes it, such as def square(x: Int): Int = x * x; if it spans multiple statements, the body is wrapped in braces and the last expression's value is returned automatically - there is no explicit return keyword needed, and using one is considered poor style except for early exits. Scala can often infer the return type from the body, but public API methods and recursive functions should always declare it explicitly, both for documentation and because the compiler cannot infer the return type of a recursive function on its own.
Cricket analogy: Just as a scorecard entry for a single ball automatically reflects that delivery's outcome without an umpire separately announcing 'this counts', a Scala function's block body automatically returns the value of its last expression without an explicit return.
def add(a: Int, b: Int): Int = a + b
def greet(name: String): String = {
val trimmed = name.trim
s"Hello, $trimmed!"
}
def factorial(n: Int): Int =
if (n <= 1) 1 else n * factorial(n - 1)
println(add(3, 4)) // 7
println(greet(" Ada ")) // Hello, Ada!
println(factorial(5)) // 120Default and Named Parameters
Scala parameters can carry default values, so callers may omit arguments that rarely change, as in def connect(host: String, port: Int = 8080, timeout: Int = 30): Unit. When a call needs to skip an earlier default but supply a later one, or simply wants clarity at the call site, named arguments let you specify connect(host = "db.internal", timeout = 60) without repeating the port. Named arguments can also be given in a different order than the declaration, which is particularly useful in constructors and configuration-style APIs with many optional settings.
Cricket analogy: A T20 franchise's standard playing XI order is a default lineup that applies unless the captain, like MS Dhoni, explicitly names a change for a specific situation - just as Scala's default parameters apply unless you name and override them.
Combining default parameters with named arguments is idiomatic for configuration objects and builder-style APIs in Scala - it avoids the telescoping constructor problem common in Java, where overloaded methods multiply for every combination of optional settings.
Multiple Parameter Lists and Variadic Parameters
Scala allows a function to be declared with several parameter lists instead of one, for example def scale(factor: Int)(x: Int): Int = factor * x; this enables partial application, where scale(2) produces a new function Int => Int without applying the second list yet, and it is required syntax for defining custom control structures that take a trailing block. Variadic parameters, marked with a * after the type such as def sum(nums: Int*): Int, let a function accept any number of arguments of that type, exposed inside the body as a Seq; only the last parameter in a list may be variadic.
Cricket analogy: A bowling coach first sets a bowler's default line (the first parameter list) and later, on match day, fine-tunes the length for that specific batter (the second parameter list) - like Scala's curried scale(factor)(x) applying inputs in stages.
Recursive functions in Scala must have an explicit return type annotation - the compiler cannot infer it from a self-referential body, and omitting it produces a compile error such as 'recursive method needs result type'.
- def defines a named function/method with typed parameters and an optional explicit return type.
- A single-expression body follows = directly; a multi-statement body uses braces and returns its last expression's value.
- Recursive functions must declare an explicit return type because the compiler cannot infer it.
- Default parameter values let callers omit rarely-changed arguments.
- Named arguments allow overriding specific parameters, in any order, improving call-site clarity.
- Multiple parameter lists enable partial application (currying); variadic parameters (T*) accept any number of arguments as a Seq.
- Only the last parameter in a parameter list may be variadic.
Practice what you learned
1. What keyword is used to define a named function in Scala?
2. In `def square(x: Int): Int = x * x`, if the body were a multi-statement block in braces, what determines the returned value?
3. Why must recursive functions declare an explicit return type in Scala?
4. What does `def scale(factor: Int)(x: Int): Int = factor * x` demonstrate?
5. How do variadic parameters like `nums: Int*` appear inside the function body?
Was this page helpful?
You May Also Like
Higher-Order Functions
Learn how Scala functions that accept or return other functions enable powerful, reusable abstractions like map, filter, fold, and currying.
Anonymous Functions and Lambdas
Master Scala's lambda syntax, underscore shorthand, and closures for writing concise inline functions used throughout collection operations.
Conditionals and Match Expressions
Understand how Scala treats if-else and match as expressions that return values, including pattern matching on case classes and sealed traits.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics