Scala | Partially Applied functions

In Scala, partially applied functions are a way to transform a function that takes multiple arguments into a function that takes fewer arguments. This is achieved by "fixing" some of the arguments of the original function and generating a new function that expects only the remaining arguments.

Basics

A simple way to think of a partially applied function is as a function where you don't provide all the arguments, just a subset of them. When you do this, the result isn't a value, but another function that you can call with the remaining arguments.

Example

Consider the following simple function that adds three integers:

def addThreeNumbers(a: Int, b: Int, c: Int): Int = a + b + c

We can create a partially applied function from it by supplying values for some of its parameters:

val addWithFiveAndSix = addThreeNumbers(5, 6, _: Int)

Here, addWithFiveAndSix is a function that takes a single integer as an argument and returns the sum of that integer with 5 and 6. The _: Int syntax is a placeholder that represents the argument that we haven't supplied yet.

You can now call addWithFiveAndSix with one argument:

println(addWithFiveAndSix(7))  // Outputs: 18

Usage Without Placeholder

You can also create a partially applied function without using placeholders, by simply using the _ after the function name:

val addPartial = addThreeNumbers _

This will return a function that expects all three arguments, but they can be supplied later:

println(addPartial(1, 2, 3))  // Outputs: 6

Use Cases

Callback Functions: They can be used when you want to supply some of the parameters of a function now and the rest later. This is useful in situations like event handlers or callbacks.
Function Factories: If you have a generic function and you want to generate more specific functions from it, you can use partial application. For example, if you have a generic function to compute taxes, you can create specific functions for different tax rates using partial application.
Simplifying Function Signatures: In some cases, you might have functions with many parameters, but in certain contexts, only a subset changes frequently. You can use partial application to simplify these functions in specific contexts.

Conclusion

Partially applied functions are a powerful concept in Scala, allowing for more flexible and modular code. They provide a way to "fix" some arguments of a function, producing a new function with fewer arguments, which can be particularly useful in functional programming paradigms.

Scala Partially Applied Functions Example:

Partially applied functions are created by fixing a subset of the arguments of a function.

def add(x: Int, y: Int, z: Int): Int = x + y + z

val partialFunc: Int => Int = add(1, 2, _: Int)
val result: Int = partialFunc(3) // Result: 6

How to Create and Use Partially Applied Functions in Scala:
Partially applied functions are created by fixing some arguments and leaving others unspecified.
```
def multiply(x: Int, y: Int): Int = x * y

val partialMultiply: Int => Int = multiply(2, _: Int)
val result: Int = partialMultiply(3) // Result: 6
```
Partial Function Application vs Currying in Scala:
Partial function application fixes a subset of arguments, while currying involves transforming a function with multiple arguments into a series of functions, each taking one argument.
```
// Partial Function Application
def add(x: Int, y: Int): Int = x + y
val partialAdd: Int => Int = add(1, _: Int)

// Currying
def curryAdd(x: Int)(y: Int): Int = x + y
val curriedAdd: Int => Int = curryAdd(1)
```
Currying and Partial Application in Scala Explained:
Currying transforms a function taking multiple arguments into a chain of functions, each taking one argument. Partial application fixes some arguments, creating a new function.
```
// Currying
def curryAdd(x: Int)(y: Int): Int = x + y

// Partial Application
val partialAdd: Int => Int = curryAdd(1)
```

Using Placeholders in Partially Applied Functions:

Placeholders (underscore _) can be used in partially applied functions for conciseness.

def divide(x: Double, y: Double): Double = x / y

val partialDivide: Double => Double = divide(10, _)
val result: Double = partialDivide(2) // Result: 5.0

Handling Multiple Argument Lists with Partially Applied Functions:

Functions with multiple argument lists can have each list partially applied separately.

def complexFunc(x: Int)(y: Int)(z: Int): Int = x + y + z

val partialFunc: Int => Int => Int = complexFunc(1)
val result: Int => Int = partialFunc(2)
val finalResult: Int = result(3) // Result: 6