Reading Typeclassopedia, I just found out about Apply and have some questions.

# 1. `<*>`

vs `<.>`

also included `.> vs *>`

, `<. vs <*`

and `liftF2 vs liftA2`

Why are there multiple version of operations that seem like exactly the same (to me)?

```
λ> :t (<*>)
(<*>) :: Applicative f => f (a -> b) -> f a -> f b
λ> :t (<.>)
(<.>) :: Apply f => f (a -> b) -> f a -> f b
```

and `Apply`

is already a `Functor`

```
λ> :i Apply
class Functor f => Apply (f :: * -> *) where
(<.>) :: f (a -> b) -> f a -> f b
(.>) :: f a -> f b -> f b
(<.) :: f a -> f b -> f a
liftF2 :: (a -> b -> c) -> f a -> f b -> f c
{-# MINIMAL (<.>) | liftF2 #-}
λ> :i Applicative
class Functor f => Applicative (f :: * -> *) where
pure :: a -> f a
(<*>) :: f (a -> b) -> f a -> f b
GHC.Base.liftA2 :: (a -> b -> c) -> f a -> f b -> f c
(*>) :: f a -> f b -> f b
(<*) :: f a -> f b -> f a
{-# MINIMAL pure, ((<*>) | liftA2) #-}
```

What is the different between `<$>`

and `<.>`

why can’t just reuse `<,>`

instead of introducing `<*>`

?

Why it is not the case that the following (not sure about the syntax, hope you get the idea)

```
class Functor f, Apply f => Applicative f where
pure :: a -> f a
```

reuse `<.>`

, `.>`

, `<.`

and `liftF2`

and be able to free 4 operators to use else where with different meaning?

# 2. Why is the word `Apply`

?

What is the origin of the word `Apply`

in this context?

Is it the same as `Applicative model`

mentioned in Backus’s Paper