# Functions as Functors

Hello! I was explaining the other day how `Function`’s implementations of the different typeclasses can be useful, and I thought I might as well write them up in case they can be useful to someone. It’s also much easier than writing 140-character blocks. Specifically, we’ll go through `Functor`, `Apply`, and `Chain`, with examples all the way.

In all these cases, I’ve represented the `Function` type as `((->) x)`. So, `Function a` means `((->) x) a`, which probably looks more familiar as `x -> a`. Read it as, “A function from values of type `x` to values of type `a`”. I’ve written the signatures in all three styles, along with the general rule where applicable.

## `Functor`

``````//       f  a ~> (a -> b) ->       f  b
// Function a ~> (a -> b) -> Function b
// ((->) x) a ~> (a -> b) -> ((->) x) b
//  (x -> a)  ~> (a -> b) ->  (x -> b)
Function.prototype.map = function (that) {
return x => that(this(x))
}
``````

What `map` does is create a new function that calls the original, and then the mapping function, to build up a kind of pipeline:

``````const myFunction =
(x => x.length)
.map(x => x + 2)
.map(x => x / 2)

// Returns "7.5"
myFunction('Hello, world!')
``````

Of course, you probably know of another tool for creating pipelines of functions:

``````// The `map` we know and love.
// map :: Functor f => (b -> c)
//                  -> f b -> f c
const map = f => xs => xs.map(f)

// WHAT IF I TOLD YOU...

// Read `f` in the above as ((->) a)...
// compose :: (b -> c)
//         -> (a -> b)
//         ->  a -> c
const compose = map // WHAT
``````

I know, right?

## `Apply`

``````// f  a ~> f (a -> b)
//      -> f  b

// Function a ~> Function (a -> b)
//            -> Function b

// ((->) x) a ~> ((->) x) (a -> b)
//            -> ((->) x) b

//  (x -> a) ~> (x -> a -> b)
//           ->  (x -> b)

Function.prototype.ap = function (that) {
return x => that(x)(this(x))
}
``````

Some of you will know that I find `Apply` to be best appreciated through the lens of `lift2`. As mentioned in the `Apply` article of the Fantasy Land series, `lift2` combines two contexts into one:

``````// (a -> b -> c) -> f a
//               -> f b
//               -> f c

// (a -> b -> c) -> Function a
//               -> Function b
//               -> Function c

// (a -> b -> c) -> ((->) x) a
//               -> ((->) x) b
//               -> ((->) x) c

// (a -> b -> c) -> (x -> a)
//               -> (x -> b)
//               -> (x -> c)

const lift2 = (f, a, b) => b.ap(a.map(f))
``````

What we end up with is a function of one argument (type `x`), which applies to `f` the result of applying that argument to `a` and `b`. Ramda fans may recognise this as `converge`:

``````// From the Ramda docs:
const divide = x  => y => x / y

const sum = xs => xs.reduce(
(x, y) => x + y, 0
)

const length = xs => xs.length

// divide(sum, length)
//   === 28 / 7 === 4
const average = lift2(divide, sum, length)
average([1, 2, 3, 4, 5, 6, 7])

// This generalises to liftN!
const lift3 = (f, a, b, c) =>
c.ap(b.ap(a.map(f)))

const longEnough =
length.map(x => x > 8) // Functor!

const hasNumber = x =>
null !== x.match(/\d+/g)

const hasUppercase = x =>
null !== x.match(/[A-Z]+/g)

// Some combining function...
const and3 = x => y => z => x && y && z

// Combine the three functions with and3
and3, longEnough
, hasNumber
, hasUppercase)

``````

So, we can take a set of functions that act on the same type, and combine their outputs with another function. This is the magic of `ap`.

## `Chain`

``````// m  a ~> (a -> m b)
//      -> m b

// Function a ~> (a -> Function b)
//            -> Function b

// ((->) x) a ~> (a -> ((->) x) b)
//            -> ((->) x) b

//  (x -> a) ~> (a -> x -> b)
//           -> x -> b
Function.prototype.chain =
function (that) {
return x => that(this(x))(x)
}
``````

The `Function` type also has a `Chain` implementation, with an eventual type that looks really similar to `Functor`. The difference this time, however, is that the intermediate function can access the original argument. No matter how many functions we `chain` together, the second argument to the `chain` function will always be of type `x`, and the value of the original input.

``````const myNextFunction =
(x => x.length)
.map(x => x + 2)
.map(x => x / 2)
.chain(x => s =>
'started from the ' + s
+ ' now we ' + x)

// started from the Hello! now we 4
myNextFunction('Hello!')
``````

So, after two `map` calls that transform the input entirely, `chain` re-introduces the original value. In fact, we can call `chain` whenever we want access to that initial value. We can’t modify the value - it’s effectively read-only. This is why the `Function` type, when used as a `Functor`, is often called `Reader`.

`Reader`’s most obvious application is to provide a way of accessing some global application state (e.g. config or a database):

``````// a ->       f  a
// a -> Function a
// a -> ((->) x) a
// a ->   x -> a
Function.of = x => _ => x

const MyApp =
// Set a "starting value"... or just
// a function that _takes_ a starting
// value and THEN the environment!
Function.of('Hello, ')

// Get a variable from environment,
// augment the string.
.chain(x => ({ isProduction }) =>
x + (isProduction ? 'customers'
: 'developers'))

// Augment the string.
.map(x => x + '!')

// Get ANOTHER variable from the
// environment, augment the string.
.chain(x => ({ caller }) =>
caller === 'browser'
? '<h1>' + x + '</h1>'
: '{ data: "' + x + '}" }')

// Send to the consumer.
.map(sendToConsumer)

// This object becomes our app's "global
// config", and the function returns
// whatever `sendToConsumer` would if given
// '{ data: "hello, customers!" }'
MyApp({
isProduction: true,
caller: 'api'
})
``````

Here, our argument is a config object, and our app is free to pick bits out whenever it chooses. Also notice the `Function.of` at the top - this is the `Pointed` implementation. This was the ingredient missing from `Apply` for an `Applicative`, and from `Chain` for a `Monad`. Developers, meet the `Reader` monad, in all its glory.

I think `Function` provides three instances here that are of immediate benefit, and they all have uses in practical code! I hope you found this useful, and I hope to see a lot more uses of `Function` as a `Functor` in the wild.

Until Monday, have fun, enjoy the long weekend, and take care! ♥