## Motivation

`Functor` solves the problem of mapping regular single-parameter functions into a sub-category, but that’s not easy for functions with more than one parameter.

Let’s consider a function with two parameters `f :: a -> b -> c`, which can also read as `a -> (b -> c)`. Applying `fmap` on `f` will yield `fmap f :: m a -> m (b -> c)`. That’s still distant from what we expect: `f' :: m a -> m b -> m c`. To get `f'`, we need a transform from `m (b -> c)` to `m b -> m c`. Here we denote it as `<*> :: m （b -> c) -> m b -> m c`. We will later show that such transform is universal for functions with more parameters.

Now consider a function with three parameters `f :: a -> b -> c -> d`. We are going to transform it into a wrapped-value version, with the help of `fmap` and `<*>`.

Here `\a_ b_ c_ -> ((fmap f a_) <*> b_) <*> c_` is in the desired type. For most of the time, applying parameters directly is actually what we want, instead of the function itself, so the code could simply be written as `((fmap f a) <*> b) <*> c`, where `a`, `b` and `c` are wrapped values. Parenthesis could be omitted if precedences are set properly, which leads to a neat and easy-to-read form:

In haskell, `fmap` has an infix name `<\$>`. So finally we get: `f <\$> a <*> b <*> c`.

## Applicative

Haskell pre-defines a type class `Applicative`, which captures the pattern of `<*>`. Any type that implements `Applicative` works well with `<\$>` and `<*>`.

Note that an `Applicative` is also a `Functor`. Apart from `<*>`, there are some other helper functions or operators in `Applicative`.

`pure` is equivalent to the default value constructor of `f`, e.g. `(:[])` for `List` or `Just` for `Maybe`. This may be handful when lifting an unwrapped value to a wrapped one.

`liftA2` transforms a binary operator to the corresponding version. The function exists as binary operators would be frequently passed among high-order functions.

`*>` takes two wrapped parameters and simply returns the second one, which sequence up two wrapped values. This is quite useful for `Applicative` with action semantics, such as `IO`. In fact, it’s so useful that Haskell introduces a syntax sugar for it, known as the `do-notation`. Particularly:

is equivalent to

`<*` is similar. Both will be reviewed while studying Monad.