# FunctionK

A `FunctionK`

transforms values from one first-order-kinded type (a type that takes a single type
parameter, such as `List`

or `Option`

) into another first-order-kinded type. This transformation is
universal, meaning that a `FunctionK[List, Option]`

will translate all `List[A]`

values into an
`Option[A]`

value for all possible types of `A`

. This explanation may be easier to understand if we
first step back and talk about ordinary functions.

## Ordinary Functions

Consider the following scala method:

```
def first(l: List[Int]): Option[Int] = l.headOption
```

This isn’t a particularly helpful method, but it will work as an example. Instead of writing this as a
method, we could have written this as a function *value*:

```
val first: List[Int] => Option[Int] = l => l.headOption
```

And here, `=>`

is really just some syntactic sugar for `Function1`

, so we could also write that as:

```
val first: Function1[List[Int], Option[Int]] = l => l.headOption
```

Let’s cut through the syntactic sugar even a little bit further. `Function1`

isn’t really a special type.
It’s just a trait that looks something like this:

```
// we are calling this `MyFunction1` so we don't collide with the actual `Function1`
trait MyFunction1[A, B] {
def apply(a: A): B
}
```

So if we didn’t mind being a bit verbose, we could have written our function as:

```
val first: Function1[List[Int], Option[Int]] = new Function1[List[Int], Option[Int]] {
def apply(l: List[Int]): Option[Int] = l.headOption
}
```

## Abstracting via Generics

Recall our `first`

method:

```
def first(l: List[Int]): Option[Int] = l.headOption
```

The astute reader may have noticed that there’s really no reason that this method needs to be tied directly to `Int`

. We could use generics to make this a bit more general:

```
def first[A](l: List[A]): Option[A] = l.headOption
```

But how would we represent this new `first`

method as a `=>`

/`Function1`

value? We are looking for something like a type of `List[A] => Option[A] forAll A`

, but this isn’t valid scala syntax. `Function1`

isn’t quite the right fit, because its `apply`

method doesn’t take a generic type parameter.

## Higher Kinds to the Rescue

It turns out that we can represent our universal `List`

to `Option`

transformation with something that looks a bit like `Function1`

but
that adds a type parameter to the `apply`

method and utilizes higher kinds:

```
trait MyFunctionK[F[_], G[_]] {
def apply[A](fa: F[A]): G[A]
}
```

Cats provides this type as `FunctionK`

(we used `MyFunctionK`

for our example type to avoid confusion). So now we can write `first`

as a `FunctionK[List, Option]`

value:

```
import cats.arrow.FunctionK
val first: FunctionK[List, Option] = new FunctionK[List, Option] {
def apply[A](l: List[A]): Option[A] = l.headOption
}
```

## Syntactic Sugar

If the example above looks a bit too verbose for you, the kind-projector
compiler plugin provides a more concise syntax.
After adding the plugin to your project, you could write the `first`

example as:

```
val first: FunctionK[List, Option] = λ[FunctionK[List, Option]](_.headOption)
```

Cats also provides a `~>`

type alias for `FunctionK`

, so an even more concise version would be:

```
import cats.~>
val first: List ~> Option = λ[List ~> Option](_.headOption)
```

Being able to use `~>`

as an alias for `FunctionK`

parallels being able to use `=>`

as an alias for `Function1`

.

## Use-cases

`FunctionK`

tends to show up when there is abstraction over higher-kinds. For example, interpreters for free monads and free applicatives are represented as `FunctionK`

instances.

## Types with more than one type parameter

Earlier it was mentioned that `FunctionK`

operates on first-order-kinded types (types that take a single type parameter such as `List`

or `Option`

). It’s still possible to use `FunctionK`

with types that would normally take more than one type parameter (such as `Either`

) if we fix all of the type parameters except for one. For example:

```
type ErrorOr[A] = Either[String, A]
val errorOrFirst: FunctionK[List, ErrorOr] =
λ[FunctionK[List, ErrorOr]](_.headOption.toRight("ERROR: the list was empty!"))
```

## Natural Transformation

In category theory, a natural transformation provides a morphism between Functors while preserving the internal structure. It’s one of the most fundamental notions of category theory.

If we have two Functors `F`

and `G`

, `FunctionK[F, G]`

is a natural transformation via parametricity. That is, given `fk: FunctionK[F, G]`

, for all functions `A => B`

and all `fa: F[A]`

the following are equivalent:

```
fk(F.map(fa)(f)) <-> G.map(fk(fa))(f)
```

We don’t need to write a law to test the implementation of the `fk`

for the above to be true. It’s automatically given by parametricity.

Thus natural transformation can be implemented in terms of `FunctionK`

. This is why a parametric polymorphic function `FunctionK[F, G]`

is sometimes referred as a natural transformation. However, they are two different concepts that are not isomorphic.

For more details, Bartosz Milewski has written a great blog post titled “Parametricity: Money for Nothing and Theorems for Free”.