*Apply* is *Functor* that also has apply method.
Scalaz defines *Apply[F[_]]* trait with *ap* abstract method.

Having a higher kind A and hight kind of A to B mapping we can get higher
kind B. And since *Apply* is also a functor we also have

We can do interesting things with those two. We can define *ap2* for example,
which will take, F[A], F[B], F[(A, B) ⇒ C] and return F[C]

And we can extends this to apN to go as many levels deep as we want.
We can also define *apply2* which will take F[A], F[B] and (A, B) ⇒ C mapping
and retrun F[C]. Note that unlike *ap2*, it takes (A, B) ⇒ C instead of
F[(A, B) ⇒ C].

This one also we can extends to applyN. Since *apply2* takes (A, B) ⇒ C
mapping we can just not map it to another type and return (A, B) tuple.

And of course we can define tupleN using applyN.
Having *apply2* we can define *lift2* which will take (A, B) ⇒ C mapping and
lift it to (F[A], F[B]) ⇒ F[C] mapping.

We can also define liftN based on applyN.

Of course we don’t have to derive all those factions ourself since scalaz is so awesome it provides those for us. It also defines following syntax functions:

**<*>**for ap.**tuple**for tuple2.***>**which uses apply2 with (_, b) ⇒ b mapping to discard the left.**<***which uses apply2 with (a, _) ⇒ a mapping to discard the right.**⊛**and**|@|**applicative builders as alternatives to applyN.**^**,**^^**,**^^^**,**^^^^**,**^^^^^**and**^^^^^^**for apply2, apply3, apply4, apply5, apply6, apply7

Since both *Option* and *Lists* are *Apply* I’m gonna demonstrate those methods
on them with short examples:

## Output

```
1.some <*> ((_:Int) + 1).some Some(2)
none <*> ((_:Int) + 1).some None
1.some <*> none None
1.some.tuple(2.some) Some((1,2))
none.tuple(2.some) None
1.some.tuple(none) None
List(1,2).tuple(List("a", "b")) List((1,a), (1,b), (2,a), (2,b))
1.some *> 2.some Some(2)
none *> 2.some None
1.some *> none None
1.some <* 2.some Some(1)
none <* 2.some None
1.some <* none None
("a".some ⊛ "b".some)(_ + _) Some(ab)
^("a".some, "b".some)(_ + _) Some(ab)
^^("a".some, "b".some, "c".some)(_ + _ + _) Some(abc)
```