majiayu000 Scala Functional Patterns
Introduction
Scala uniquely blends object-oriented and functional programming paradigms, enabling developers to leverage the best of both worlds. Functional programming in Scala emphasizes immutability, pure functions, and composability, leading to more predictable and maintainable code.
Core functional patterns in Scala include higher-order functions, immutable data structures, pattern matching, algebraic data types (ADTs), monadic composition, for-comprehensions, and type classes. These patterns enable elegant solutions to complex problems while maintaining type safety.
This skill covers immutability principles, higher-order functions, pattern matching, ADTs with sealed traits, Option and Either monads, for-comprehensions, function composition, and functional error handling.
Immutability and Pure Functions
Immutable data structures and pure functions form the foundation of functional programming, ensuring predictable behavior and thread safety.
// Immutable case classes
case class User(
id: Int,
name: String,
email: String,
age: Int
)
// Copying with modifications
val user = User(1, "Alice", "alice@example.com", 30)
val updatedUser = user.copy(age = 31)
// Immutable collections
val numbers = List(1, 2, 3, 4, 5)
val doubled = numbers.map(_ * 2) // Original list unchanged
// Pure functions (deterministic, no side effects)
def add(a: Int, b: Int): Int = a + b
def multiply(a: Int, b: Int): Int = a * b
def calculateTotal(price: Double, quantity: Int, discount: Double): Double = {
val subtotal = price * quantity
val discountAmount = subtotal * discount
subtotal - discountAmount
}
// Impure function (side effect: logging)
def impureAdd(a: Int, b: Int): Int = {
println(s"Adding $a and $b") // Side effect
a + b
}
// Separating pure logic from side effects
def pureCalculation(items: List[Double]): Double =
items.sum
def displayResult(result: Double): Unit =
println(s"Total: $result")
val items = List(10.0, 20.0, 30.0)
val total = pureCalculation(items)
displayResult(total)
// Immutable data transformations
case class Order(items: List[String], total: Double)
def addItem(order: Order, item: String, price: Double): Order =
order.copy(
items = order.items :+ item,
total = order.total + price
)
def applyDiscount(order: Order, percentage: Double): Order =
order.copy(total = order.total * (1 - percentage))
// Composing immutable transformations
val order = Order(List("Book"), 25.0)
val finalOrder = applyDiscount(addItem(order, "Pen", 5.0), 0.1)
// Immutable builder pattern
case class PersonBuilder(
name: Option[String] = None,
age: Option[Int] = None,
email: Option[String] = None
) {
def withName(n: String): PersonBuilder = copy(name = Some(n))
def withAge(a: Int): PersonBuilder = copy(age = Some(a))
def withEmail(e: String): PersonBuilder = copy(email = Some(e))
def build: Option[Person] = for {
n <- name
a <- age
e <- email
} yield Person(n, a, e)
}
case class Person(name: String, age: Int, email: String)
val person = PersonBuilder()
.withName("Bob")
.withAge(25)
.withEmail("bob@example.com")
.build
Immutability eliminates entire classes of bugs related to shared mutable state and enables safe concurrent programming.
Higher-Order Functions
Higher-order functions accept functions as parameters or return functions, enabling powerful abstraction and code reuse.
// Functions as parameters
def applyOperation(x: Int, y: Int, op: (Int, Int) => Int): Int =
op(x, y)
val sum = applyOperation(5, 3, (a, b) => a + b)
val product = applyOperation(5, 3, (a, b) => a * b)
// Functions as return values
def multiplyBy(factor: Int): Int => Int =
(x: Int) => x * factor
val double = multiplyBy(2)
val triple = multiplyBy(3)
println(double(5)) // 10
println(triple(5)) // 15
// Currying
def curriedAdd(a: Int)(b: Int): Int = a + b
val add5 = curriedAdd(5) _
println(add5(3)) // 8
// Partial application
def greet(greeting: String, name: String): String =
s"$greeting, $name!"
val sayHello: String => String = greet("Hello", _)
println(sayHello("Alice")) // Hello, Alice!
// Function composition
val addOne: Int => Int = _ + 1
val multiplyByTwo: Int => Int = _ * 2
val addThenMultiply = addOne andThen multiplyByTwo
val multiplyThenAdd = addOne compose multiplyByTwo
println(addThenMultiply(5)) // (5 + 1) * 2 = 12
println(multiplyThenAdd(5)) // (5 * 2) + 1 = 11
// Collection operations with higher-order functions
val numbers = List(1, 2, 3, 4, 5)
val squared = numbers.map(x => x * x)
val evens = numbers.filter(_ % 2 == 0)
val sum = numbers.reduce(_ + _)
val product = numbers.fold(1)(_ * _)
// FlatMap for nested transformations
val nested = List(List(1, 2), List(3, 4), List(5))
val flattened = nested.flatMap(identity)
val pairs = numbers.flatMap(x => numbers.map(y => (x, y)))
// Custom higher-order functions
def retry[T](times: Int)(operation: => T): Option[T] = {
@scala.annotation.tailrec
def attempt(remaining: Int): Option[T] = {
if (remaining <= 0) None
else {
try {
Some(operation)
} catch {
case _: Exception => attempt(remaining - 1)
}
}
}
attempt(times)
}
def withLogging[T](name: String)(operation: => T): T = {
println(s"Starting $name")
val result = operation
println(s"Finished $name")
result
}
// Measuring execution time
def timed[T](operation: => T): (T, Long) = {
val start = System.nanoTime()
val result = operation
val elapsed = System.nanoTime() - start
(result, elapsed / 1000000) // Convert to milliseconds
}
val (result, time) = timed {
(1 to 1000000).sum
}
println(s"Result: $result, Time: ${time}ms")
Higher-order functions enable powerful abstraction, allowing you to capture common patterns and eliminate code duplication.
Pattern Matching
Pattern matching provides elegant syntax for conditional logic and data extraction, far more powerful than traditional switch statements.
// Basic pattern matching
def describe(x: Any): String = x match {
case 0 => "zero"
case 1 => "one"
case i: Int => s"integer: $i"
case s: String => s"string: $s"
case _ => "unknown"
}
// Matching with guards
def classify(x: Int): String = x match {
case n if n < 0 => "negative"
case 0 => "zero"
case n if n > 0 && n < 10 => "small positive"
case n if n >= 10 => "large positive"
}
// Destructuring case classes
case class Point(x: Int, y: Int)
def locationDescription(point: Point): String = point match {
case Point(0, 0) => "origin"
case Point(0, y) => s"on Y-axis at $y"
case Point(x, 0) => s"on X-axis at $x"
case Point(x, y) if x == y => s"on diagonal at ($x, $y)"
case Point(x, y) => s"at ($x, $y)"
}
// List pattern matching
def sumList(list: List[Int]): Int = list match {
case Nil => 0
case head :: tail => head + sumList(tail)
}
def describeList[T](list: List[T]): String = list match {
case Nil => "empty"
case _ :: Nil => "single element"
case _ :: _ :: Nil => "two elements"
case _ :: _ :: _ :: _ => "three or more elements"
}
// Variable binding in patterns
def processMessage(msg: Any): String = msg match {
case s: String if s.length > 10 => s"Long string: ${s.take(10)}..."
case s @ String => s"String: $s"
case n @ (_: Int | _: Double) => s"Number: $n"
case _ => "Unknown type"
}
// Option pattern matching
def getUserName(userId: Int): Option[String] = {
if (userId > 0) Some(s"User$userId") else None
}
def displayUserName(userId: Int): String = getUserName(userId) match {
case Some(name) => s"Welcome, $name"
case None => "User not found"
}
// Either pattern matching
def divide(a: Int, b: Int): Either[String, Double] =
if (b == 0) Left("Division by zero")
else Right(a.toDouble / b)
def describeDivision(result: Either[String, Double]): String = result match {
case Left(error) => s"Error: $error"
case Right(value) => s"Result: $value"
}
// Tuple pattern matching
def processPair(pair: (String, Int)): String = pair match {
case (name, age) if age < 18 => s"$name is a minor"
case (name, age) => s"$name is $age years old"
}
// Nested pattern matching
sealed trait Tree[+T]
case class Leaf[T](value: T) extends Tree[T]
case class Branch[T](left: Tree[T], right: Tree[T]) extends Tree[T]
def depth[T](tree: Tree[T]): Int = tree match {
case Leaf(_) => 1
case Branch(left, right) => 1 + Math.max(depth(left), depth(right))
}
// Pattern matching in for-comprehensions
val tuples = List((1, "one"), (2, "two"), (3, "three"))
val result = for {
(num, word) <- tuples
if num % 2 != 0
} yield s"$num: $word"
Pattern matching makes code more readable and exhaustive, with the compiler ensuring all cases are covered for sealed types.
Algebraic Data Types (ADTs)
ADTs model data with sealed traits and case classes, enabling exhaustive pattern matching and type-safe domain modeling.
// Simple ADT for results
sealed trait Result[+T]
case class Success[T](value: T) extends Result[T]
case class Failure(error: String) extends Result[Nothing]
def processResult[T](result: Result[T]): String = result match {
case Success(value) => s"Success: $value"
case Failure(error) => s"Failure: $error"
}
// ADT for payment methods
sealed trait PaymentMethod
case class CreditCard(number: String, cvv: String) extends PaymentMethod
case class PayPal(email: String) extends PaymentMethod
case class BankTransfer(accountNumber: String) extends PaymentMethod
def processPayment(method: PaymentMethod, amount: Double): String =
method match {
case CreditCard(number, _) => s"Charging $$${amount} to card ending in ${number.takeRight(4)}"
case PayPal(email) => s"Charging $$${amount} via PayPal account $email"
case BankTransfer(account) => s"Transferring $$${amount} from account $account"
}
// Recursive ADT for lists
sealed trait MyList[+T]
case object MyNil extends MyList[Nothing]
case class Cons[T](head: T, tail: MyList[T]) extends MyList[T]
def length[T](list: MyList[T]): Int = list match {
case MyNil => 0
case Cons(_, tail) => 1 + length(tail)
}
// ADT for expression trees
sealed trait Expr
case class Num(value: Double) extends Expr
case class Add(left: Expr, right: Expr) extends Expr
case class Multiply(left: Expr, right: Expr) extends Expr
case class Divide(left: Expr, right: Expr) extends Expr
def evaluate(expr: Expr): Either[String, Double] = expr match {
case Num(value) => Right(value)
case Add(left, right) => for {
l <- evaluate(left)
r <- evaluate(right)
} yield l + r
case Multiply(left, right) => for {
l <- evaluate(left)
r <- evaluate(right)
} yield l * r
case Divide(left, right) => for {
l <- evaluate(left)
r <- evaluate(right)
result <- if (r != 0) Right(l / r) else Left("Division by zero")
} yield result
}
// Example usage
val expr = Divide(Add(Num(10), Num(5)), Multiply(Num(3), Num(2)))
println(evaluate(expr)) // Right(2.5)
// ADT for JSON
sealed trait Json
case object JNull extends Json
case class JBoolean(value: Boolean) extends Json
case class JNumber(value: Double) extends Json
case class JString(value: String) extends Json
case class JArray(values: List[Json]) extends Json
case class JObject(fields: Map[String, Json]) extends Json
def stringify(json: Json): String = json match {
case JNull => "null"
case JBoolean(value) => value.toString
case JNumber(value) => value.toString
case JString(value) => s""""$value""""
case JArray(values) => values.map(stringify).mkString("[", ",", "]")
case JObject(fields) =>
fields.map { case (k, v) => s""""$k":${stringify(v)}""" }
.mkString("{", ",", "}")
}
// State machine with ADT
sealed trait ConnectionState
case object Disconnected extends ConnectionState
case object Connecting extends ConnectionState
case object Connected extends ConnectionState
case object Disconnecting extends ConnectionState
def transition(state: ConnectionState, event: String): ConnectionState =
(state, event) match {
case (Disconnected, "connect") => Connecting
case (Connecting, "connected") => Connected
case (Connected, "disconnect") => Disconnecting
case (Disconnecting, "disconnected") => Disconnected
case (current, _) => current // Invalid transition
}
ADTs provide exhaustive pattern matching guarantees and make illegal states unrepresentable at compile time.
Option and Either Monads
Option and Either provide functional error handling without exceptions, enabling composable error handling.
// Option for nullable values
def findUser(id: Int): Option[User] =
if (id > 0) Some(User(id, "Alice", "alice@example.com", 30))
else None
// Option operations
val maybeUser = findUser(1)
val name = maybeUser.map(_.name).getOrElse("Unknown")
val email = maybeUser.flatMap(u => Some(u.email))
// Option chaining
def getAddress(user: User): Option[String] = Some("123 Main St")
def getCity(address: String): Option[String] = Some("Springfield")
val city = for {
user <- findUser(1)
address <- getAddress(user)
city <- getCity(address)
} yield city
// Either for error handling
def parseInt(s: String): Either[String, Int] =
try Right(s.toInt)
catch { case _: NumberFormatException => Left(s"'$s' is not a valid integer") }
def divide(a: Int, b: Int): Either[String, Double] =
if (b == 0) Left("Division by zero")
else Right(a.toDouble / b)
// Either composition
def calculate(a: String, b: String): Either[String, Double] = for {
x <- parseInt(a)
y <- parseInt(b)
result <- divide(x, y)
} yield result
println(calculate("10", "2")) // Right(5.0)
println(calculate("10", "0")) // Left(Division by zero)
println(calculate("ten", "2")) // Left('ten' is not a valid integer)
// Combining multiple Options
def combineOptions(a: Option[Int], b: Option[Int], c: Option[Int]): Option[Int] =
for {
x <- a
y <- b
z <- c
} yield x + y + z
// Handling collections of Options
val options = List(Some(1), None, Some(3), Some(4))
val flattened = options.flatten // List(1, 3, 4)
val sumOfSomes = options.flatten.sum // 8
// Converting between Option and Either
def optionToEither[T](opt: Option[T], error: String): Either[String, T] =
opt.toRight(error)
def eitherToOption[T](either: Either[String, T]): Option[T] =
either.toOption
// Validation with Either
case class ValidationError(field: String, message: String)
def validateEmail(email: String): Either[ValidationError, String] =
if (email.contains("@")) Right(email)
else Left(ValidationError("email", "Invalid email format"))
def validateAge(age: Int): Either[ValidationError, Int] =
if (age >= 18) Right(age)
else Left(ValidationError("age", "Must be 18 or older"))
def validateUser(email: String, age: Int):
Either[List[ValidationError], User] = {
val emailResult = validateEmail(email)
val ageResult = validateAge(age)
(emailResult, ageResult) match {
case (Right(e), Right(a)) => Right(User(1, "User", e, a))
case (Left(e1), Left(e2)) => Left(List(e1, e2))
case (Left(e), _) => Left(List(e))
case (_, Left(e)) => Left(List(e))
}
}
// Try for exception handling
import scala.util.{Try, Success, Failure}
def safeDivide(a: Int, b: Int): Try[Double] =
Try(a.toDouble / b)
val tryResult = safeDivide(10, 2) match {
case Success(value) => s"Result: $value"
case Failure(exception) => s"Error: ${exception.getMessage}"
}
// Converting Try to Either
def tryToEither[T](tried: Try[T]): Either[Throwable, T] =
tried.toEither
Option and Either eliminate null pointer exceptions and make error handling explicit in function signatures.
For-Comprehensions
For-comprehensions provide syntactic sugar for monadic operations, making sequential computations more readable.
// Basic for-comprehension
val result = for {
x <- List(1, 2, 3)
y <- List(10, 20)
} yield x + y
// With filtering
val evens = for {
x <- 1 to 10
if x % 2 == 0
} yield x
// Nested for-comprehensions
val pairs = for {
x <- 1 to 3
y <- 1 to 3
if x < y
} yield (x, y)
// With Option
def getUserById(id: Int): Option[User] =
Some(User(id, "Alice", "alice@example.com", 30))
def getOrdersByUser(user: User): Option[List[Order]] =
Some(List(Order(List("Book"), 25.0)))
val totalOrders = for {
user <- getUserById(1)
orders <- getOrdersByUser(user)
} yield orders.length
// With Either
def validateInput(input: String): Either[String, Int] =
if (input.isEmpty) Left("Input is empty")
else if (input.toIntOption.isEmpty) Left("Not a number")
else Right(input.toInt)
def processValue(value: Int): Either[String, Int] =
if (value < 0) Left("Value must be positive")
else Right(value * 2)
val processed = for {
input <- validateInput("10")
doubled <- processValue(input)
} yield doubled
// Parallel composition with for-comprehension
case class UserProfile(user: User, orders: List[Order], friends: List[User])
def getUserProfile(userId: Int): Option[UserProfile] = for {
user <- getUserById(userId)
orders <- getOrdersByUser(user)
friends <- getFriendsByUser(user)
} yield UserProfile(user, orders, friends)
def getFriendsByUser(user: User): Option[List[User]] = Some(List())
// For-comprehension with Future
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
def fetchUser(id: Int): Future[User] =
Future(User(id, "Alice", "alice@example.com", 30))
def fetchOrders(user: User): Future[List[Order]] =
Future(List(Order(List("Book"), 25.0)))
val userWithOrders: Future[(User, List[Order])] = for {
user <- fetchUser(1)
orders <- fetchOrders(user)
} yield (user, orders)
// De-sugaring for-comprehension
val manual = List(1, 2, 3)
.flatMap(x => List(10, 20).map(y => x + y))
val withFor = for {
x <- List(1, 2, 3)
y <- List(10, 20)
} yield x + y
// Both produce the same result
For-comprehensions make monadic composition readable and eliminate callback nesting in asynchronous code.
Function Composition and Combinators
Function composition creates complex functions from simpler ones, promoting reusability and modularity.
// Basic composition
val addOne: Int => Int = _ + 1
val double: Int => Int = _ * 2
val square: Int => Int = x => x * x
val addOneThenDouble = addOne andThen double
val doubleBeforeAddOne = addOne compose double
println(addOneThenDouble(3)) // (3 + 1) * 2 = 8
println(doubleBeforeAddOne(3)) // (3 * 2) + 1 = 7
// Function combinators
def constant[A, B](b: B): A => B = _ => b
def identity[A]: A => A = a => a
def compose[A, B, C](f: B => C, g: A => B): A => C =
a => f(g(a))
// Lifting functions
def lift[A, B](f: A => B): Option[A] => Option[B] =
_.map(f)
val lifted = lift(addOne)
println(lifted(Some(5))) // Some(6)
println(lifted(None)) // None
// Kleisli composition (composing monadic functions)
def kleisli[A, B, C](f: A => Option[B], g: B => Option[C]): A => Option[C] =
a => f(a).flatMap(g)
def safeDivideBy(divisor: Int): Int => Option[Int] =
n => if (divisor != 0) Some(n / divisor) else None
def validatePositive(n: Int): Option[Int] =
if (n > 0) Some(n) else None
val composed = kleisli(safeDivideBy(2), validatePositive)
println(composed(10)) // Some(5)
println(composed(3)) // None (not positive after division)
// Reader monad for dependency injection
case class Config(apiUrl: String, timeout: Int)
type Reader[A] = Config => A
def getApiUrl: Reader[String] = config => config.apiUrl
def getTimeout: Reader[Int] = config => config.timeout
def buildRequest: Reader[String] = for {
url <- getApiUrl
timeout <- getTimeout
} yield s"Request to $url with timeout $timeout"
val config = Config("https://api.example.com", 5000)
println(buildRequest(config))
// Applicative functors
def map2[A, B, C](fa: Option[A], fb: Option[B])(f: (A, B) => C): Option[C] =
for {
a <- fa
b <- fb
} yield f(a, b)
val result1 = map2(Some(2), Some(3))(_ + _) // Some(5)
val result2 = map2(Some(2), None: Option[Int])(_ + _) // None
// Traverse
def traverse[A, B](list: List[A])(f: A => Option[B]): Option[List[B]] =
list.foldRight(Some(Nil): Option[List[B]]) { (a, acc) =>
map2(f(a), acc)(_ :: _)
}
val numbers = List("1", "2", "3")
println(traverse(numbers)(s => s.toIntOption)) // Some(List(1, 2, 3))
Function composition enables building complex operations from simple, testable components.
Best Practices
Prefer immutable data structures to eliminate entire classes of bugs related to shared mutable state
Use sealed traits for ADTs to enable exhaustive pattern matching and compile-time guarantees
Leverage for-comprehensions for monadic composition instead of nested flatMap calls
Make side effects explicit by separating pure computation from IO operations
Use Option instead of null to make nullable values explicit in type signatures
Prefer Either for error handling over exceptions to make error cases explicit
Compose functions rather than writing large monolithic functions for better reusability
Use tail recursion with @tailrec annotation for recursive functions to prevent stack overflow
Leverage type inference but provide explicit types for public APIs and complex expressions
Apply partial application and currying to create specialized functions from general ones
Common Pitfalls
Mixing mutable and immutable collections leads to unexpected modifications and bugs
Overusing var instead of val defeats immutability benefits and makes code harder to reason about
Not handling None cases in Option results in runtime failures despite type safety
Catching all exceptions instead of using Try, Either, or Option loses type safety benefits
Creating non-tail-recursive functions for large inputs causes stack overflow errors
Not making ADTs sealed allows adding cases elsewhere, breaking pattern match exhaustiveness
Nesting flatMap calls instead of for-comprehensions reduces readability significantly
Using null instead of Option defeats the purpose of functional error handling
Creating impure functions without documenting side effects makes code unpredictable
Over-abstracting with higher-kinded types prematurely adds complexity without clear benefits
When to Use This Skill
Apply functional patterns throughout Scala development to leverage the language's strengths and build maintainable systems.
Use immutability and pure functions when building business logic to ensure predictability and testability.
Leverage pattern matching and ADTs when modeling domain entities with distinct states or variants.
Apply Option and Either for error handling in APIs and service layers to make error cases explicit.
Use for-comprehensions when composing multiple monadic operations for improved readability.
Employ function composition when building data transformation pipelines or reusable utility functions.