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.

Resources

• Functional Programming in Scala

• Scala Documentation - Pattern Matching

• Scala with Cats

• Functional Programming Principles in Scala (Coursera)

• Herding Cats - Cats Tutorial