Scala | Function Composition

Function composition is a fundamental concept in functional programming. It involves taking two functions and "composing" them into a single function. Scala provides built-in methods for function composition.

Given two functions f and g, there are two primary ways to compose them:

Forward Composition (andThen): In this case, you're taking the output of one function and passing it as input to another. For functions f and g, it's represented as (g andThen f).
Backward Composition (compose): Here, you're chaining the functions in the reverse direction. For f and g, it's represented as (g compose f).

Example:

val f: Int => Int = _ + 1      // A function that adds 1
val g: Int => Int = _ * 2      // A function that multiplies by 2

// Forward composition (andThen)
val forwardCompose = f andThen g
println(forwardCompose(2))  // Outputs: 6 because (2 + 1) * 2 = 6

// Backward composition (compose)
val backwardCompose = f compose g
println(backwardCompose(2))  // Outputs: 5 because (2 * 2) + 1 = 5

Remember:

(f andThen g)(x) is the same as g(f(x))
(f compose g)(x) is the same as f(g(x))

Advantages of Function Composition:

Modularity: You can break complex logic into simpler, reusable functions and then compose them to get desired behaviors.
Readability: By naming functions descriptively, the composed function can read like a series of steps, enhancing clarity.
Ease of testing: Smaller functions can be individually tested, ensuring each unit of logic behaves as expected.

In functional programming, building systems out of small, well-defined pieces and then composing them is a fundamental principle, and Scala's support for function composition aligns well with this idea.

Introduction to Function Composition in Scala:
Function composition is a technique where two or more functions are combined to create a new function.
```
val addOne: Int => Int = x => x + 1
val multiplyByTwo: Int => Int = x => x * 2
val composedFunction: Int => Int = addOne compose multiplyByTwo
```

Using and Composing Functions in Scala:

Use and compose functions to create more complex behavior.

val addOne: Int => Int = x => x + 1
val multiplyByTwo: Int => Int = x => x * 2
val result = multiplyByTwo(addOne(3))

Compose and andThen Methods in Scala:

The compose and andThen methods are used for function composition.

val addOne: Int => Int = x => x + 1
val multiplyByTwo: Int => Int = x => x * 2
val composedFunction: Int => Int = addOne.compose(multiplyByTwo)
val anotherComposedFunction: Int => Int = addOne.andThen(multiplyByTwo)

Chaining Functions with Function Composition in Scala:

Chain multiple functions together for sequential processing.

val addOne: Int => Int = x => x + 1
val multiplyByTwo: Int => Int = x => x * 2
val square: Int => Int = x => x * x
val chainedFunction: Int => Int = addOne.andThen(multiplyByTwo).andThen(square)

Partial Function Application and Composition in Scala:

Combine partial function application and composition for more flexibility.

def multiply(x: Int, y: Int): Int = x * y
val multiplyByTwo: Int => Int = multiply(_, 2)
val square: Int => Int = multiplyByTwo andThen (_ * 2)

Function Composition vs. Method Chaining in Scala:

Understand the difference between function composition and method chaining.

val addOne: Int => Int = x => x + 1
val multiplyByTwo: Int => Int = x => x * 2
val composedFunction: Int => Int = addOne.andThen(multiplyByTwo)

val result = addOne(3).toString // Method chaining

Composing Higher-Order Functions in Scala:

Compose higher-order functions for more advanced composition.

def square(x: Int): Int = x * x
def cube(x: Int): Int = x * x * x
val higherOrderFunction: Int => Int = square.compose(cube)

Advanced Techniques with Function Composition in Scala:

Explore advanced techniques like composing functions with side effects.

def addOne(x: Int): Int = {
  println(s"Adding one to $x")
  x + 1
}

def multiplyByTwo(x: Int): Int = {
  println(s"Multiplying by two: $x")
  x * 2
}

val composedFunction: Int => Int = addOne.andThen(multiplyByTwo)