Exploring Higher-Order Functions and Currying in Scala

This blog is part of a 10-part series designed to help readers learn Scala from the ground up. Whether you’re new to Scala or looking to solidify your understanding, this series will guide you through its core concepts step by step.

Scala’s functional programming capabilities make it a powerful tool for developers looking to write clean and expressive code. In this blog, we’ll explore higher-order functions, currying, and other functional programming features through unique examples.

Higher-Order Functions (HOFs)

Higher-order functions are functions that can take other functions as arguments or return functions as results. Here’s an example that applies a function multiple times to a value:

object HigherOrderFunctions extends App {
  def repeatFunction(f: Int => Int, times: Int, value: Int): Int =
    if (times <= 0) value else repeatFunction(f, times - 1, f(value))

  println(repeatFunction(x => x * 2, 3, 1)) // Output: 8

  def repeatFunctionBetter(f: Int => Int, times: Int): Int => Int =
    if (times <= 0) (x: Int) => x
    else (x: Int) => repeatFunctionBetter(f, times - 1)(f(x))

  val increment = (x: Int) => x + 1
  println(repeatFunctionBetter(increment, 5)(0)) // Output: 5
}

Currying

Currying is a technique where a function with multiple parameters is transformed into a series of functions, each taking a single parameter. Here’s an example:

object CurryingExample extends App {
  def formatNumber(format: String)(number: Double): String = format.format(number)
  val standardFormatter = formatNumber("%4.2f") _
  val preciseFormatter = formatNumber("%10.8f") _

  println(standardFormatter(Math.PI))  // Output: 3.14
  println(preciseFormatter(Math.PI))   // Output: 3.14159265
}

Composition and Chaining

Function composition allows you to combine two or more functions into a single function:

object FunctionComposition extends App {
  def addTwo(x: Int): Int = x + 2
  def multiplyByThree(x: Int): Int = x * 3
  val composedFunction = (x: Int) => multiplyByThree(addTwo(x))
  val chainedFunction = (x: Int) => addTwo(multiplyByThree(x))

  println(composedFunction(4))  // Output: 18
  println(chainedFunction(4))  // Output: 14
}

Using generic types, you can create reusable composition utilities:

object GenericComposition extends App {
  def compose[A, B, C](f: B => C, g: A => B): A => C = x => f(g(x))
  def andThen[A, B, C](f: A => B, g: B => C): A => C = x => g(f(x))

  val composed = compose(multiplyByThree, addTwo)
  val chained = andThen(addTwo, multiplyByThree)

  println(composed(4))  // Output: 18
  println(chained(4))  // Output: 14
}

Map, FlatMap, and Filter

Scala collections offer powerful methods like map, flatMap, and filter for transforming and filtering data:

object CollectionOperations extends App {
  val numbers = List(1, 2, 3, 4)

  println(numbers.map(_ * 2))       // Output: List(2, 4, 6, 8)
  println(numbers.filter(_ % 2 == 0)) // Output: List(2, 4)

  val expand = (x: Int) => List(x, x + 1)
  println(numbers.flatMap(expand)) // Output: List(1, 2, 2, 3, 3, 4, 4, 5)
}

For-Comprehensions

For-comprehensions provide a concise way to work with nested collections:

object ForComprehensionExample extends App {
  val numbers = List(1, 2, 3)
  val letters = List('a', 'b', 'c')
  val colors = List("red", "blue")

  val combinations = for {
    number <- numbers
    letter <- letters
    color <- colors
  } yield s"$number$letter$color"

  println(combinations) // Output: List(1ared, 1ablue, 1bred, ...)
}

Conclusion

Scala’s support for higher-order functions, currying, and functional composition makes it a great choice for developers. These features, combined with powerful collection operations, enable you to write expressive and concise code. Mastering these concepts will elevate your programming skills and help you tackle complex problems with ease.

Happy coding!

Pizenith is a trusted technology partner specializing in Data Engineering, Machine Learning, AI, Cloud Engineering, DevOps, and Functional Programming with Scala and Java. We help businesses scale with secure, automated, and data-driven solutions, delivering innovation in Test Automation and DevSecOps. Trusted by global enterprises, we empower organizations to stay ahead with AI-powered insights and scalable cloud infrastructure.

Want to future-proof your tech stack? Let’s talk! or reach us at info@pizenith.com.