# Path to FP - Fancy functions

March 19, 2019

We already know FP is about programming just with functions, pure and descriptive functions.

There are some really fancy kind of functions out there:

## HOF (High Order Function)

Yep, a HOF is one that can take in as parameter or spit out as its result a function, and guess what, if for some weird reason you’ve been doing some JavaScript there’s a super high probability that you already used HOF.

```
function add1(x) { return x + 1; }
var number = [1, 2, 3, 4, 5].map(add1);
```

Where `map`

is a HOF. Now let’s see the same example in Scala:

```
val numbers = (0 to 10).toList
numbers.map(x => x * x)
println(numbers)
```

Let’s get some diabetes by syntactic sugar 🤣

```
numbers.map(_ + 1)
```

When doing Scala code and working with HOF is super normal to pass around anonymous functions
(as we did in `number.map`

example) rather than declaring a val or a `def`

.

## Partial Functions

A partial function is a function that will only work for a given set of its domain. A function that will not produce a value for every possible input value it can be given. We can use this type of function whenever we have functions with a ton of guard code (a bunch if and else testing the inputs). A simple example is when dividing by zero.

```
def divide(x: Int, y: Int) = x / y
// dividing(1, 0) will throw
// we can use partial function for testing valid y values
val devidePF: PartialFunction[(Int, Int), Int] = {
case (x, y) if y > 0 => x / y
}
println("8/2 equals " + devidePF(8, 2))
// println("8/2 equals " + devidePF(2, 0)) this will throw, the value of y is not valid
```