# Composing functions

beginner

## Composing regular functions

#### Problem

I have:

• A function `f: (A) -> B`
• A function `g: (B) -> C`

I want to have:

• A function `h: (A) -> C`

#### Solution

Bow provides the `compose` function and the `<<<` operator to compose two functions. `g <<< f` is typically read as `g` after `f`, and refers to first applying `f` to a value of type `A`, and then applying `g` to the result.

Although this works nicely, it is sometimes cumbersome to use, as it needs to be read right-to-left. In order to improve that, Bow provides the `andThen` function and the `>>>` operator, which do exactly the same, but their arguments are flipped. Therefore, `g <<< f` is equivalent to `f >>> g`; likewise, `compose(g, f)` is equivalent to `andThen(f, g)`.

#### Example

Consider the following functions:

``````// Computes the length of a circumference from its radius.
func circumference(radius: Int) -> Double {
}

// Obtains a String from a Double, keeping only 2 decimal places.
func prettyPrint(_ n: Double) -> String {
String(format: "%.2f", n)
}
``````

We can create a function that, given a radius, it gives us the length of a circumference with only two decimal places. This can be achieved by composing the previous two functions:

``````let prettyCircumference: (Int) -> String =

prettyCircumference(3) // Returns "18.85"
``````

## Composing effectful functions

#### Problem

I have:

• A function `f: (A) -> F<B>`.
• A function `g: (B) -> F<C>`.

I want to have:

• A function `h: (A) -> F<C>`.

#### Solution

The previous composition functions and operators do not work here. If we inspect the return type of `f`, it does not match with the input type of `g`, since the functions are effectful.

These effectful functions are called Kleisli functions, and there is a type in Bow to represent them. The `Kleisli` type provides the `andThen` method to compose them.

#### Example

Consider the following functions:

``````// Provides the next conference after a certain date, if it exists.
func nextConference(after date: Date) -> Option<Conference>
``````
``````// Provides the next talk for a Conference, if it exists.
func nextTalk(at conference: Conference) -> Option<Talk>
``````

Both functions are Kleisli functions, as their result are effectful, with Option being the effect. We can compose them into a function that provides the next Talk after a certain date, if it exists:

``````// Kleisli<OptionPartial, Date, Talk> is equivalent to a function:
// (Date) -> Option<Talk>
let nextTalkAfterDate: Kleisli<OptionPartial, Date, Talk> = Kleisli(nextConference(after:))
.andThen(Kleisli(nextTalk(at:)))
``````

And we can invoke this function as:

``````nextTalkAfterDate.run(Date())
``````