Functional Programming Scala Composition Map Filter Monads For-Comprehensions Flatmap

August 31, 2025

For-Comprehensions and Monads: Elegant Composition

Master for-comprehensions to elegantly compose operations across Options, Lists, and other monadic types, creating readable and powerful data transformation pipelines.

Lesson 26 🚀 Practice

For-Comprehensions and Monads: Elegant Composition

Introduction

For-comprehensions (also called for-yield expressions) are one of Scala's most elegant features for composing operations across collections and monadic types. They provide a readable, imperative-style syntax for functional operations like map, flatMap, and filter.

Behind the scenes, for-comprehensions work with any type that implements the monadic operations: map, flatMap, and filter. This lesson will teach you to use for-comprehensions effectively and understand the monadic patterns that power them.

Basic For-Comprehensions

Simple Transformations

// Basic for-comprehension with collections
val numbers = List(1, 2, 3, 4, 5)

// Traditional approach
val doubled = numbers.map(_ * 2)
val evens = numbers.filter(_ % 2 == 0)
val doubledEvens = numbers.filter(_ % 2 == 0).map(_ * 2)

// For-comprehension approach
val forDoubled = for (n <- numbers) yield n * 2
val forEvens = for (n <- numbers if n % 2 == 0) yield n
val forDoubledEvens = for {
  n <- numbers
  if n % 2 == 0
} yield n * 2

println(s"Traditional doubled: $doubled")
println(s"For-comp doubled: $forDoubled")
println(s"Traditional evens: $evens")
println(s"For-comp evens: $forEvens")
println(s"Traditional doubled evens: $doubledEvens")
println(s"For-comp doubled evens: $forDoubledEvens")

// Multiple generators (Cartesian product)
val letters = List('a', 'b', 'c')
val digits = List(1, 2, 3)

val combinations = for {
  letter <- letters
  digit <- digits
} yield s"$letter$digit"

println(s"Combinations: $combinations")
// List(a1, a2, a3, b1, b2, b3, c1, c2, c3)

// Filtered combinations
val filteredCombinations = for {
  letter <- letters
  digit <- digits
  if digit % 2 == 1  // Only odd digits
} yield s"$letter$digit"

println(s"Filtered combinations: $filteredCombinations")
// List(a1, a3, b1, b3, c1, c3)

// Nested transformations
val matrix = List(
  List(1, 2, 3),
  List(4, 5, 6),
  List(7, 8, 9)
)

val flattened = for {
  row <- matrix
  element <- row
} yield element

val evenElements = for {
  row <- matrix
  element <- row
  if element % 2 == 0
} yield element

val squaredOdds = for {
  row <- matrix
  element <- row
  if element % 2 == 1
} yield element * element

println(s"Flattened: $flattened")     // List(1, 2, 3, 4, 5, 6, 7, 8, 9)
println(s"Even elements: $evenElements") // List(2, 4, 6, 8)
println(s"Squared odds: $squaredOdds")   // List(1, 9, 25, 49, 81)

Pattern Matching in For-Comprehensions

// For-comprehensions with pattern matching
case class Person(name: String, age: Int, city: String)

val people = List(
  Person("Alice", 25, "New York"),
  Person("Bob", 30, "San Francisco"),
  Person("Charlie", 35, "New York"),
  Person("Diana", 28, "Chicago"),
  Person("Eve", 32, "San Francisco")
)

// Extract names from people in specific cities
val newYorkers = for {
  Person(name, _, "New York") <- people
} yield name

val youngPeople = for {
  Person(name, age, city) <- people
  if age < 30
} yield s"$name from $city"

val adultNewYorkers = for {
  person@Person(_, age, "New York") <- people
  if age >= 25
} yield person

println(s"New Yorkers: $newYorkers")
println(s"Young people: $youngPeople")
println(s"Adult New Yorkers: $adultNewYorkers")

// Working with tuples
val coordinates = List((1, 2), (3, 4), (5, 6), (7, 8))

val sumCoordinates = for {
  (x, y) <- coordinates
} yield x + y

val positiveQuadrant = for {
  (x, y) <- coordinates
  if x > 0 && y > 0
} yield (x, y)

println(s"Sum coordinates: $sumCoordinates")      // List(3, 7, 11, 15)
println(s"Positive quadrant: $positiveQuadrant") // List((1,2), (3,4), (5,6), (7,8))

// Deconstructing complex data
case class Order(id: Int, items: List[String], total: Double)

val orders = List(
  Order(1, List("laptop", "mouse"), 1050.0),
  Order(2, List("book", "pen"), 25.0),
  Order(3, List("monitor", "keyboard", "mouse"), 450.0)
)

val expensiveItems = for {
  Order(id, items, total) <- orders
  if total > 100
  item <- items
} yield (id, item, total)

println("Expensive order items:")
expensiveItems.foreach { case (id, item, total) =>
  println(s"  Order $id: $item (total: $$$total)")
}

// Handling nested Options with pattern matching
val maybeData = List(Some("apple"), None, Some("banana"), Some("cherry"), None)

val uppercasedData = for {
  Some(data) <- maybeData
} yield data.toUpperCase

val lengthyData = for {
  Some(data) <- maybeData
  if data.length > 5
} yield data

println(s"Uppercased data: $uppercasedData")  // List(APPLE, BANANA, CHERRY)
println(s"Lengthy data: $lengthyData")        // List(banana, cherry)

For-Comprehensions with Options

Safe Operations

// Working with Options to avoid null pointer exceptions
case class Address(street: String, city: String, zipCode: String)
case class Person(name: String, age: Int, address: Option[Address])

val people = List(
  Person("Alice", 25, Some(Address("123 Main St", "New York", "10001"))),
  Person("Bob", 30, None),
  Person("Charlie", 35, Some(Address("456 Oak Ave", "San Francisco", "94102"))),
  Person("Diana", 28, None)
)

// Extract cities safely
val cities = for {
  person <- people
  address <- person.address
} yield address.city

println(s"Cities: $cities")  // List(New York, San Francisco)

// Complex validations with Options
def parseInt(s: String): Option[Int] = {
  try Some(s.toInt) catch { case _: NumberFormatException => None }
}

def validateAge(age: Int): Option[Int] = {
  if (age >= 0 && age <= 150) Some(age) else None
}

def validateEmail(email: String): Option[String] = {
  if (email.contains("@")) Some(email.toLowerCase) else None
}

// Chain validations using for-comprehensions
def createUser(name: String, ageStr: String, email: String): Option[Person] = {
  for {
    age <- parseInt(ageStr)
    validAge <- validateAge(age)
    validEmail <- validateEmail(email)
  } yield Person(name, validAge, None)
}

val userInputs = List(
  ("Alice", "25", "alice@example.com"),
  ("Bob", "not-a-number", "bob@test.com"),
  ("Charlie", "200", "charlie@example.com"),
  ("Diana", "30", "invalid-email")
)

userInputs.foreach { case (name, age, email) =>
  createUser(name, age, email) match {
    case Some(user) => println(s"✓ Created user: ${user.name}")
    case None => println(s"✗ Failed to create user: $name")
  }
}

// Combining multiple Options
def findPersonByName(name: String): Option[Person] = {
  people.find(_.name == name)
}

def getPersonCity(name: String): Option[String] = {
  for {
    person <- findPersonByName(name)
    address <- person.address
  } yield address.city
}

def getPersonInfo(name: String): Option[String] = {
  for {
    person <- findPersonByName(name)
    address <- person.address
  } yield s"${person.name}, age ${person.age}, lives in ${address.city}"
}

val nameQueries = List("Alice", "Bob", "Charlie", "Unknown")
nameQueries.foreach { name =>
  getPersonCity(name) match {
    case Some(city) => println(s"$name lives in $city")
    case None => println(s"City for $name not found")
  }
}

// Working with nested Options
val nestedOptions = List(Some(Some(1)), Some(None), None, Some(Some(5)))

val flattenedValues = for {
  outer <- nestedOptions
  inner <- outer
} yield inner

println(s"Flattened values: $flattenedValues")  // List(1, 5)

// Option combinations with guards
def safeDivide(a: Double, b: Double): Option[Double] = {
  if (b != 0) Some(a / b) else None
}

def safeSquareRoot(x: Double): Option[Double] = {
  if (x >= 0) Some(math.sqrt(x)) else None
}

def complexCalculation(a: Double, b: Double): Option[Double] = {
  for {
    divided <- safeDivide(a, b)
    sqrt <- safeSquareRoot(divided)
    if sqrt > 1.0  // Guard condition
  } yield sqrt * 2
}

val calculations = List(
  (16.0, 4.0),  // sqrt(16/4) = 2.0, * 2 = 4.0
  (4.0, 4.0),   // sqrt(4/4) = 1.0, fails guard
  (16.0, 0.0),  // Division by zero
  (-16.0, 4.0)  // Negative square root
)

calculations.foreach { case (a, b) =>
  complexCalculation(a, b) match {
    case Some(result) => println(f"calc($a, $b) = $result%.2f")
    case None => println(s"calc($a, $b) = failed")
  }
}

For-Comprehensions with Either

Error Handling Composition

// Working with Either for error handling
type Result[T] = Either[String, T]

def validateName(name: String): Result[String] = {
  if (name.trim.nonEmpty) Right(name.trim)
  else Left("Name cannot be empty")
}

def validateAge(age: Int): Result[Int] = {
  if (age >= 0 && age <= 150) Right(age)
  else Left(s"Invalid age: $age")
}

def validateEmail(email: String): Result[String] = {
  if (email.contains("@")) Right(email.toLowerCase)
  else Left("Invalid email format")
}

// Chain validations using for-comprehensions
def validateUser(name: String, age: Int, email: String): Result[Person] = {
  for {
    validName <- validateName(name)
    validAge <- validateAge(age)
    validEmail <- validateEmail(email)
  } yield Person(validName, validAge, None)
}

val userValidations = List(
  ("Alice", 25, "alice@example.com"),
  ("", 30, "bob@test.com"),
  ("Charlie", 200, "charlie@example.com"),
  ("Diana", 28, "invalid-email")
)

userValidations.foreach { case (name, age, email) =>
  validateUser(name, age, email) match {
    case Right(user) => println(s"✓ Valid user: ${user.name}")
    case Left(error) => println(s"✗ Validation error: $error")
  }
}

// Multiple error scenarios
def parseConfig(data: Map[String, String]): Result[Map[String, Any]] = {
  for {
    host <- data.get("host").toRight("Missing host")
    portStr <- data.get("port").toRight("Missing port")
    port <- Either.cond(portStr.forall(_.isDigit), portStr.toInt, "Invalid port format")
    _ <- Either.cond(port > 0 && port <= 65535, (), "Port out of range")
  } yield Map("host" -> host, "port" -> port)
}

val configTests = List(
  Map("host" -> "localhost", "port" -> "8080"),
  Map("host" -> "localhost"),  // Missing port
  Map("host" -> "localhost", "port" -> "abc"),  // Invalid port
  Map("host" -> "localhost", "port" -> "99999")  // Port out of range
)

configTests.foreach { config =>
  parseConfig(config) match {
    case Right(parsed) => println(s"✓ Config: $parsed")
    case Left(error) => println(s"✗ Config error: $error")
  }
}

// Combining Either results
def fetchUserData(userId: Int): Result[String] = {
  if (userId > 0) Right(s"User data for $userId")
  else Left(s"Invalid user ID: $userId")
}

def fetchUserPreferences(userId: Int): Result[Map[String, Any]] = {
  if (userId > 0) Right(Map("theme" -> "dark", "lang" -> "en"))
  else Left(s"No preferences for user $userId")
}

def getUserProfile(userId: Int): Result[(String, Map[String, Any])] = {
  for {
    userData <- fetchUserData(userId)
    preferences <- fetchUserPreferences(userId)
  } yield (userData, preferences)
}

List(1, 0, 5, -1).foreach { userId =>
  getUserProfile(userId) match {
    case Right((data, prefs)) => 
      println(s"✓ User $userId: $data, preferences: $prefs")
    case Left(error) => 
      println(s"✗ Failed to get profile for user $userId: $error")
  }
}

Advanced For-Comprehension Patterns

Custom Monadic Types

// Creating a custom monadic type
case class Logged[A](value: A, log: List[String]) {
  def map[B](f: A => B): Logged[B] = 
    Logged(f(value), log)

  def flatMap[B](f: A => Logged[B]): Logged[B] = {
    val result = f(value)
    Logged(result.value, log ++ result.log)
  }

  def withFilter(p: A => Boolean): Logged[A] = 
    if (p(value)) this 
    else Logged(value, log :+ s"Filter failed for $value")
}

object Logged {
  def apply[A](value: A, message: String): Logged[A] = 
    Logged(value, List(message))
}

// Functions that return Logged values
def loggedAdd(a: Int, b: Int): Logged[Int] = 
  Logged(a + b, s"Added $a + $b = ${a + b}")

def loggedMultiply(a: Int, b: Int): Logged[Int] = 
  Logged(a * b, s"Multiplied $a * $b = ${a * b}")

def loggedDivide(a: Int, b: Int): Logged[Option[Int]] = {
  if (b != 0) Logged(Some(a / b), s"Divided $a / $b = ${a / b}")
  else Logged(None, s"Cannot divide $a by $b")
}

// Using for-comprehensions with custom monadic type
val loggedComputation = for {
  x <- Logged(5, "Starting with 5")
  y <- loggedAdd(x, 3)
  z <- loggedMultiply(y, 2)
  if z > 10
} yield z * z

println(s"Result: ${loggedComputation.value}")
println("Log:")
loggedComputation.log.foreach(entry => println(s"  $entry"))

// Complex logged computation
def complexCalculation(a: Int, b: Int): Logged[Option[Int]] = {
  for {
    sum <- loggedAdd(a, b)
    product <- loggedMultiply(sum, 2)
    division <- loggedDivide(product, 4)
  } yield division.value
}

val result = complexCalculation(3, 7)
println(s"\nComplex calculation result: ${result.value}")
println("Computation log:")
result.log.foreach(entry => println(s"  $entry"))

// State monad example
case class State[S, A](run: S => (S, A)) {
  def map[B](f: A => B): State[S, B] = 
    State(s => {
      val (newState, a) = run(s)
      (newState, f(a))
    })

  def flatMap[B](f: A => State[S, B]): State[S, B] = 
    State(s => {
      val (newState, a) = run(s)
      f(a).run(newState)
    })
}

object State {
  def get[S]: State[S, S] = State(s => (s, s))
  def put[S](newState: S): State[S, Unit] = State(_ => (newState, ()))
  def modify[S](f: S => S): State[S, Unit] = State(s => (f(s), ()))
}

// Counter example using State monad
type Counter[A] = State[Int, A]

def increment: Counter[Int] = State(count => (count + 1, count + 1))
def decrement: Counter[Int] = State(count => (count - 1, count - 1))
def reset: Counter[Unit] = State(_ => (0, ()))

val counterProgram = for {
  _ <- increment
  _ <- increment
  a <- increment
  _ <- decrement
  b <- State.get[Int]
} yield (a, b)

val (finalState, (a, b)) = counterProgram.run(0)
println(s"\nCounter program: a=$a, b=$b, final state=$finalState")

For-Comprehensions with Multiple Types

// Combining different monadic types
import scala.util.{Try, Success, Failure}

// Helper to convert Try to Either
def tryToEither[T](t: Try[T]): Either[String, T] = t match {
  case Success(value) => Right(value)
  case Failure(exception) => Left(exception.getMessage)
}

// Mixed computations
def parseAndValidate(input: String): Either[String, Int] = {
  for {
    parsed <- tryToEither(Try(input.toInt))
    validated <- if (parsed > 0) Right(parsed) else Left("Number must be positive")
  } yield validated
}

def processNumbers(inputs: List[String]): List[Either[String, Int]] = {
  for {
    input <- inputs
  } yield parseAndValidate(input)
}

val numberInputs = List("42", "-5", "not-a-number", "100", "0")
val processed = processNumbers(numberInputs)

processed.zip(numberInputs).foreach { case (result, input) =>
  result match {
    case Right(value) => println(s"'$input' -> $value")
    case Left(error) => println(s"'$input' -> Error: $error")
  }
}

// Combining Option and List
val maybeNumbers = List(Some(1), None, Some(3), Some(4), None)
val multipliers = List(2, 3, 5)

val products = for {
  maybeNum <- maybeNumbers
  num <- maybeNum.toList  // Convert Option to List
  multiplier <- multipliers
} yield num * multiplier

println(s"Products: $products")  // List(2, 3, 5, 6, 9, 15, 8, 12, 20)

// Nested for-comprehensions
case class Department(name: String, employees: List[Person])
case class Company(name: String, departments: List[Department])

val company = Company("TechCorp", List(
  Department("Engineering", List(
    Person("Alice", 30, None),
    Person("Bob", 35, None)
  )),
  Department("Marketing", List(
    Person("Charlie", 28, None),
    Person("Diana", 32, None)
  ))
))

val allEmployees = for {
  dept <- company.departments
  employee <- dept.employees
} yield (dept.name, employee.name)

val youngEmployees = for {
  dept <- company.departments
  employee <- dept.employees
  if employee.age < 30
} yield s"${employee.name} from ${dept.name}"

println("All employees:")
allEmployees.foreach { case (dept, name) => 
  println(s"  $name ($dept)")
}

println(s"Young employees: $youngEmployees")

// Parallel comprehensions
val lists = List(
  List(1, 2, 3),
  List(4, 5, 6),
  List(7, 8, 9)
)

val parallelSum = for {
  (list, index) <- lists.zipWithIndex
  element <- list
} yield (index, element)

println(s"Parallel enumeration: $parallelSum")
// List((0,1), (0,2), (0,3), (1,4), (1,5), (1,6), (2,7), (2,8), (2,9))

Performance and Best Practices

Efficient For-Comprehensions

import scala.util.Random

// Performance considerations
def timeForComprehension[T](name: String)(operation: => T): T = {
  val start = System.nanoTime()
  val result = operation
  val end = System.nanoTime()
  println(f"$name: ${(end - start) / 1e6}%.2f ms")
  result
}

val largeList = (1 to 100000).toList

// Efficient filtering and mapping
timeForComprehension("For-comprehension with early filtering") {
  val result = for {
    n <- largeList
    if n % 1000 == 0  // Filter early
    doubled = n * 2   // Intermediate value
  } yield doubled * doubled
  result.length
}

timeForComprehension("Traditional approach") {
  val result = largeList
    .filter(_ % 1000 == 0)
    .map(n => {
      val doubled = n * 2
      doubled * doubled
    })
  result.length
}

// View for lazy evaluation
timeForComprehension("For-comprehension with view") {
  val result = for {
    n <- largeList.view
    if n % 1000 == 0
    doubled = n * 2
  } yield doubled * doubled
  result.take(10).toList.length
}

// Best practices demonstration
case class Product(id: Int, name: String, price: Double, category: String)
case class Order(id: Int, productId: Int, quantity: Int, customerId: Int)
case class Customer(id: Int, name: String, city: String)

val products = (1 to 1000).map(i => 
  Product(i, s"Product $i", Random.nextDouble() * 100, 
    List("Electronics", "Books", "Clothing")(i % 3))
).toList

val orders = (1 to 5000).map(i => 
  Order(i, Random.nextInt(1000) + 1, Random.nextInt(10) + 1, Random.nextInt(100) + 1)
).toList

val customers = (1 to 100).map(i => 
  Customer(i, s"Customer $i", List("New York", "San Francisco", "Chicago")(i % 3))
).toList

// Efficient join operations
timeForComprehension("For-comprehension join") {
  val result = for {
    order <- orders.view
    product <- products
    if product.id == order.productId
    if product.category == "Electronics"
    customer <- customers
    if customer.id == order.customerId
  } yield (order.id, product.name, customer.name, order.quantity * product.price)

  result.take(100).toList.length
}

// More efficient with Maps for lookups
val productMap = products.map(p => p.id -> p).toMap
val customerMap = customers.map(c => c.id -> c).toMap

timeForComprehension("Optimized with Maps") {
  val result = for {
    order <- orders
    product <- productMap.get(order.productId)
    if product.category == "Electronics"
    customer <- customerMap.get(order.customerId)
  } yield (order.id, product.name, customer.name, order.quantity * product.price)

  result.length
}

// Guidelines for readable for-comprehensions
def processComplexData(): List[String] = {
  for {
    // Use meaningful variable names
    customer <- customers

    // Group related conditions
    if customer.city == "New York"

    // Extract intermediate values when complex
    customerOrders = orders.filter(_.customerId == customer.id)

    // Continue with clear, single-purpose steps
    order <- customerOrders
    product <- productMap.get(order.productId).toList

    // Final transformations
    orderValue = order.quantity * product.price
    if orderValue > 50
  } yield f"${customer.name}: ${product.name} ($$${orderValue}%.2f)"
}

val complexResults = processComplexData()
println(s"Complex query results: ${complexResults.take(5)}")

Summary

In this lesson, you've mastered for-comprehensions and monadic composition:

✅ Basic For-Comprehensions: Syntax and simple transformations
✅ Pattern Matching: Deconstructing data within for-expressions
✅ Option Composition: Safe chaining of nullable operations
✅ Either Composition: Elegant error handling pipelines
✅ Custom Monads: Creating your own composable types
✅ Performance: Writing efficient for-comprehensions
✅ Best Practices: Readable and maintainable code patterns

For-comprehensions provide a powerful abstraction for working with monadic types, making complex data transformations readable and composable.

What's Next

In the next lesson, we'll explore lazy evaluation and streams, learning how to work with potentially infinite data structures and optimize performance through deferred computation.

🚀 Practice Exercise

Put your knowledge to practice with hands-on coding exercises

Advanced ⏱️ 2h

Instructions

For-Comprehensions and Monads

Build a comprehensive monadic computation framework that demonstrates advanced for-comprehension patterns, custom monads, monad transformers, and complex control flow scenarios.

Your program should:
1. Implement custom monads (State, Writer, Reader) from scratch
2. Build monad transformers for combining effects
3. Create a validation system using Applicative Functor patterns
4. Implement complex control flow with nested for-comprehensions
5. Build a functional configuration and dependency injection system
6. Create a domain-specific language (DSL) using monadic patterns

Requirements:
- Implement at least 3 custom monads with proper flatMap/map methods
- Create monad transformer stack for handling multiple effects
- Use for-comprehensions for complex control flow and resource management
- Implement applicative validation that accumulates errors
- Build composable operations using monadic patterns
- Create type-safe DSL using for-comprehensions

Example usage:
```scala
val computation = for {
config <- ask[Config]
user <- validateUser(userInput)
result <- processWithLogging(user)
_ <- saveToState(result)
} yield result
```

Interactive Playground

⚠️ Spoiler Alert! Try to solve the exercise yourself first. Learning happens through practice!

```scala
object AdvancedMonadicFramework extends App {
println("=== Advanced For-Comprehensions and Monads ===")

// 1. Custom State Monad
println("\n1. State Monad Implementation")

case class State[S, A](runState: S => (S, A)) {
def map[B](f: A => B): State[S, B] =
State(s => {
val (newState, a) = runState(s)
(newState, f(a))
})

def flatMap[B](f: A => State[S, B]): State[S, B] =
State(s => {
val (newState, a) = runState(s)
f(a).runState(newState)
})

def withFilter(p: A => Boolean): State[S, A] =
flatMap(a => if (p(a)) State.pure(a) else State.fail())
}

object State {
def pure[S, A](a: A): State[S, A] = State(s => (s, a))

def get[S]: State[S, S] = State(s => (s, s))

def put[S](newState: S): State[S, Unit] = State(_ => (newState, ()))

def modify[S](f: S => S): State[S, Unit] =
for {
s <- get[S]
_ <- put(f(s))
} yield ()

def fail[S, A](): State[S, A] = State(s => throw new RuntimeException("State computation failed"))
}

// Counter example using State monad
type Counter = Int

def increment: State[Counter, Unit] = State.modify[Counter](_ + 1)
def decrement: State[Counter, Unit] = State.modify[Counter](_ - 1)
def getValue: State[Counter, Counter] = State.get[Counter]
def setValue(n: Int): State[Counter, Unit] = State.put(n)

val counterProgram = for {
_ <- increment
_ <- increment
_ <- decrement
current <- getValue
_ <- setValue(current * 2)
final <- getValue
} yield final

val (finalState, result) = counterProgram.runState(0)
println(s"Counter program: initial=0, final=$finalState, result=$result")

// Stack example with State
case class Stack[A](items: List[A]) {
def push(item: A): Stack[A] = Stack(item :: items)
def pop: Option[(A, Stack[A])] = items match {
case Nil => None
case head :: tail => Some((head, Stack(tail)))
}
def peek: Option[A] = items.headOption
def size: Int = items.length
}

def pushStack[A](item: A): State[Stack[A], Unit] =
State.modify[Stack[A]](_.push(item))

def popStack[A]: State[Stack[A], Option[A]] =
for {
stack <- State.get[Stack[A]]
result <- stack.pop match {
case Some((item, newStack)) =>
for {
_ <- State.put(newStack)
} yield Some(item)
case None => State.pure(None)
}
} yield result

def stackSize[A]: State[Stack[A], Int] =
State.get[Stack[A]].map(_.size)

val stackProgram = for {
_ <- pushStack("first")
_ <- pushStack("second")
_ <- pushStack("third")
size1 <- stackSize[String]
popped1 <- popStack[String]
popped2 <- popStack[String]
size2 <- stackSize[String]
remaining <- State.get[Stack[String]]
} yield (size1, popped1, popped2, size2, remaining.items)

val stackResult = stackProgram.runState(Stack[String](Nil))
println(s"Stack program result: ${stackResult._2}")

// 2. Writer Monad for Logging
println("\n2. Writer Monad Implementation")

case class Writer[W, A](run: (W, A)) {
def map[B](f: A => B): Writer[W, B] = Writer((run._1, f(run._2)))

def flatMap[B](f: A => Writer[W, B])(implicit M: Monoid[W]): Writer[W, B] = {
val (log1, a) = run
val (log2, b) = f(a).run
Writer((M.combine(log1, log2), b))
}

def withFilter(p: A => Boolean)(implicit M: Monoid[W]): Writer[W, A] = {
if (p(run._2)) this else Writer.fail[W, A]()
}
}

object Writer {
def pure[W, A](a: A)(implicit M: Monoid[W]): Writer[W, A] =
Writer((M.empty, a))

def tell[W](w: W): Writer[W, Unit] = Writer((w, ()))

def fail[W, A]()(implicit M: Monoid[W]): Writer[W, A] =
Writer((M.empty, throw new RuntimeException("Writer computation failed")))
}

trait Monoid[A] {
def empty: A
def combine(x: A, y: A): A
}

implicit val stringMonoid: Monoid[String] = new Monoid[String] {
def empty: String = ""
def combine(x: String, y: String): String = x + y
}

implicit val listMonoid: Monoid[List[String]] = new Monoid[List[String]] {
def empty: List[String] = Nil
def combine(x: List[String], y: List[String]): List[String] = x ++ y
}

// Logging computation
def loggedComputation(x: Int): Writer[List[String], Int] =
for {
_ <- Writer.tell(List(s"Starting computation with $x"))
doubled <- Writer.pure(x * 2)
_ <- Writer.tell(List(s"Doubled $x to get $doubled"))
incremented <- Writer.pure(doubled + 1)
_ <- Writer.tell(List(s"Incremented $doubled to get $incremented"))
} yield incremented

val (logs, result2) = loggedComputation(5).run
println("Logged computation:")
logs.foreach(log => println(s"  LOG: $log"))
println(s"  RESULT: $result2")

// 3. Reader Monad for Dependency Injection
println("\n3. Reader Monad Implementation")

case class Reader[R, A](run: R => A) {
def map[B](f: A => B): Reader[R, B] = Reader(r => f(run(r)))

def flatMap[B](f: A => Reader[R, B]): Reader[R, B] =
Reader(r => f(run(r)).run(r))

def withFilter(p: A => Boolean): Reader[R, A] =
Reader(r => {
val a = run(r)
if (p(a)) a else throw new RuntimeException("Reader filter failed")
})
}

object Reader {
def pure[R, A](a: A): Reader[R, A] = Reader(_ => a)

def ask[R]: Reader[R, R] = Reader(identity)

def local[R, A](f: R => R)(reader: Reader[R, A]): Reader[R, A] =
Reader(r => reader.run(f(r)))
}

// Configuration and dependency injection
case class Config(dbUrl: String, apiKey: String, timeout: Int)
case class Database(url: String) {
def query(sql: String): List[String] = List(s"Result for: $sql")
}
case class ApiClient(key: String, timeout: Int) {
def get(endpoint: String): String = s"API response from $endpoint"
}

def createDatabase: Reader[Config, Database] =
for {
config <- Reader.ask[Config]
} yield Database(config.dbUrl)

def createApiClient: Reader[Config, ApiClient] =
for {
config <- Reader.ask[Config]
} yield ApiClient(config.apiKey, config.timeout)

def businessLogic: Reader[Config, String] =
for {
config <- Reader.ask[Config]
db <- createDatabase
api <- createApiClient
_ = println(s"Using DB: ${db.url}, API key: ${api.key}")
dbResult = db.query("SELECT * FROM users")
apiResult = api.get("/users/profile")
} yield s"Combined: ${dbResult.headOption.getOrElse("No data")} + $apiResult"

val config = Config("jdbc:postgresql://localhost/mydb", "secret-api-key", 5000)
val businessResult = businessLogic.run(config)
println(s"Business logic result: $businessResult")

// 4. Monad Transformer: StateT
println("\n4. Monad Transformer - StateT")

case class StateT[F[_], S, A](runStateT: S => F[(S, A)])(implicit F: Monad[F]) {
def map[B](f: A => B): StateT[F, S, B] =
StateT(s => F.map(runStateT(s)) { case (newS, a) => (newS, f(a)) })

def flatMap[B](f: A => StateT[F, S, B]): StateT[F, S, B] =
StateT(s =>
F.flatMap(runStateT(s)) { case (newS, a) =>
f(a).runStateT(newS)
})
}

trait Monad[F[_]] {
def pure[A](a: A): F[A]
def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B]
def map[A, B](fa: F[A])(f: A => B): F[B] = flatMap(fa)(a => pure(f(a)))
}

implicit val optionMonad: Monad[Option] = new Monad[Option] {
def pure[A](a: A): Option[A] = Some(a)
def flatMap[A, B](fa: Option[A])(f: A => Option[B]): Option[B] = fa.flatMap(f)
}

object StateT {
def pure[F[_]: Monad, S, A](a: A): StateT[F, S, A] =
StateT(s => implicitly[Monad[F]].pure((s, a)))

def get[F[_]: Monad, S]: StateT[F, S, S] =
StateT(s => implicitly[Monad[F]].pure((s, s)))

def put[F[_]: Monad, S](newS: S): StateT[F, S, Unit] =
StateT(_ => implicitly[Monad[F]].pure((newS, ())))

def liftF[F[_]: Monad, S, A](fa: F[A]): StateT[F, S, A] =
StateT(s => implicitly[Monad[F]].map(fa)(a => (s, a)))
}

// Example: State + Option
type StateOption[S, A] = StateT[Option, S, A]

def safeDivideState(a: Int, b: Int): StateOption[List[String], Int] =
if (b != 0) {
for {
_ <- StateT.liftF[Option, List[String], Unit](Some(()))
logs <- StateT.get[Option, List[String]]
_ <- StateT.put(s"Divided $a by $b" :: logs)
} yield a / b
} else {
StateT(_ => None) // Failure case
}

val stateOptionProgram = for {
result1 <- safeDivideState(20, 4)
result2 <- safeDivideState(result1, 2)
logs <- StateT.get[Option, List[String]]
} yield (result2, logs)

val stateOptionResult = stateOptionProgram.runStateT(Nil)
println(s"StateT Option result: $stateOptionResult")

// 5. Validation with Applicative Functor
println("\n5. Validation System")

sealed trait ValidationResult[+A]
case class Valid[A](value: A) extends ValidationResult[A]
case class Invalid(errors: List[String]) extends ValidationResult[Nothing]

object ValidationResult {
def valid[A](value: A): ValidationResult[A] = Valid(value)
def invalid(error: String): ValidationResult[Nothing] = Invalid(List(error))
def invalid(errors: List[String]): ValidationResult[Nothing] = Invalid(errors)

implicit class ValidationOps[A](va: ValidationResult[A]) {
def map[B](f: A => B): ValidationResult[B] = va match {
case Valid(a) => Valid(f(a))
case Invalid(errors) => Invalid(errors)
}

def flatMap[B](f: A => ValidationResult[B]): ValidationResult[B] = va match {
case Valid(a) => f(a)
case Invalid(errors) => Invalid(errors)
}

def withFilter(p: A => Boolean): ValidationResult[A] = va match {
case Valid(a) if p(a) => Valid(a)
case Valid(_) => Invalid(List("Filter condition failed"))
case Invalid(errors) => Invalid(errors)
}
}

// Applicative operations for accumulating errors
def map2[A, B, C](va: ValidationResult[A], vb: ValidationResult[B])(f: (A, B) => C): ValidationResult[C] = {
(va, vb) match {
case (Valid(a), Valid(b)) => Valid(f(a, b))
case (Invalid(e1), Invalid(e2)) => Invalid(e1 ++ e2)
case (Invalid(e), _) => Invalid(e)
case (_, Invalid(e)) => Invalid(e)
}
}

def map3[A, B, C, D](va: ValidationResult[A], vb: ValidationResult[B], vc: ValidationResult[C])
(f: (A, B, C) => D): ValidationResult[D] = {
(va, vb, vc) match {
case (Valid(a), Valid(b), Valid(c)) => Valid(f(a, b, c))
case _ =>
val errors = List(va, vb, vc).collect { case Invalid(e) => e }.flatten
Invalid(errors)
}
}
}

import ValidationResult._

case class User(name: String, email: String, age: Int)

def validateName(name: String): ValidationResult[String] = {
if (name.nonEmpty && name.length <= 50) valid(name)
else invalid("Name must be non-empty and <= 50 characters")
}

def validateEmail(email: String): ValidationResult[String] = {
if (email.contains("@") && email.contains(".")) valid(email)
else invalid("Email must contain @ and .")
}

def validateAge(age: Int): ValidationResult[Int] = {
if (age >= 0 && age <= 150) valid(age)
else invalid("Age must be between 0 and 150")
}

def validateUser(name: String, email: String, age: Int): ValidationResult[User] = {
map3(validateName(name), validateEmail(email), validateAge(age))(User)
}

// Test validations
val validUser = validateUser("Alice", "alice@example.com", 30)
println(s"Valid user: $validUser")

val invalidUser = validateUser("", "invalid-email", -5)
println(s"Invalid user: $invalidUser")

// 6. Domain-Specific Language (DSL)
println("\n6. Configuration DSL")

sealed trait ConfigAction[A]
case class ReadProperty(key: String) extends ConfigAction[Option[String]]
case class WriteProperty(key: String, value: String) extends ConfigAction[Unit]
case class DeleteProperty(key: String) extends ConfigAction[Unit]
case class ListKeys() extends ConfigAction[List[String]]

case class ConfigProgram[A](actions: List[ConfigAction[_]], result: A) {
def map[B](f: A => B): ConfigProgram[B] = ConfigProgram(actions, f(result))

def flatMap[B](f: A => ConfigProgram[B]): ConfigProgram[B] = {
val next = f(result)
ConfigProgram(actions ++ next.actions, next.result)
}
}

object ConfigDSL {
def read(key: String): ConfigProgram[Option[String]] =
ConfigProgram(List(ReadProperty(key)), None)

def write(key: String, value: String): ConfigProgram[Unit] =
ConfigProgram(List(WriteProperty(key, value)), ())

def delete(key: String): ConfigProgram[Unit] =
ConfigProgram(List(DeleteProperty(key)), ())

def listKeys: ConfigProgram[List[String]] =
ConfigProgram(List(ListKeys()), Nil)

def pure[A](a: A): ConfigProgram[A] = ConfigProgram(Nil, a)
}

import ConfigDSL._

val configProgram = for {
_ <- write("database.host", "localhost")
_ <- write("database.port", "5432")
host <- read("database.host")
port <- read("database.port")
keys <- listKeys
_ <- delete("database.port")
remaining <- listKeys
} yield (host, port, keys.size, remaining.size)

println(s"Config DSL program: ${configProgram.actions.length} actions")
println(s"Config DSL result type: ${configProgram.result}")

// 7. Complex Workflow with Error Handling
println("\n7. Complex Workflow")

sealed trait WorkflowError
case class ValidationError(message: String) extends WorkflowError
case class NetworkError(message: String) extends WorkflowError
case class DatabaseError(message: String) extends WorkflowError

type WorkflowResult[A] = Either[WorkflowError, A]

def validateInput(input: String): WorkflowResult[String] = {
if (input.nonEmpty) Right(input.trim)
else Left(ValidationError("Input cannot be empty"))
}

def fetchFromNetwork(query: String): WorkflowResult[String] = {
if (query.length > 100) Left(NetworkError("Query too long"))
else Right(s"Network data for: $query")
}

def saveToDatabase(data: String): WorkflowResult[Int] = {
if (data.contains("error")) Left(DatabaseError("Cannot save data containing 'error'"))
else Right(data.length)
}

def processWorkflow(input: String): WorkflowResult[String] = {
for {
validated <- validateInput(input)
networkData <- fetchFromNetwork(validated)
savedId <- saveToDatabase(networkData)
} yield s"Successfully processed: $validated, saved with ID: $savedId"
}

// Test workflows
val successfulWorkflow = processWorkflow("valid input")
println(s"Successful workflow: $successfulWorkflow")

val failedWorkflow = processWorkflow("")
println(s"Failed workflow: $failedWorkflow")

val networkFailureWorkflow = processWorkflow("a" * 101)
println(s"Network failure workflow: $networkFailureWorkflow")

println("\n=== Advanced Monadic Framework Complete! ===")
println("Advanced concepts demonstrated:")
println("- Custom State, Writer, and Reader monads")
println("- Monad transformers (StateT) for effect composition")
println("- Applicative validation with error accumulation")
println("- Domain-specific languages using monadic patterns")
println("- Complex workflows with proper error handling")
println("- Type-safe dependency injection")
println("- Functional logging and state management")
}
```

Comments

Be the first to comment on this lesson!

For-Comprehensions and Monads: Elegant Composition

Introduction

Basic For-Comprehensions

Simple Transformations

Pattern Matching in For-Comprehensions

For-Comprehensions with Options

Safe Operations

For-Comprehensions with Either

Error Handling Composition

Advanced For-Comprehension Patterns

Custom Monadic Types

For-Comprehensions with Multiple Types

Performance and Best Practices

Efficient For-Comprehensions

Summary

What's Next

🚀 Practice Exercise

Instructions

Interactive Playground

Comments

Sign In

Sign Up

Reset Password

Sign Out

Reset Password