[Haskell-beginners] Applicative: how <*> really works

[Yassine]

Hi,

I have a question about functor applicate.

I know that:
pure (+1) <*> Just 2


produce: Just 3
because pure (+1) produce Just (+1) and then Just (+1) <*> Just 2
produce Just (2+1)


but in more complex case like:
newtype Parser a = P (String -> [(a,String)])

parse :: Parser a -> String -> [(a,String)]
parse (P p) inp = p inp


item :: Parser Char
item = P (\inp -> case inp of
 []     -> []
(x:xs) -> [(x,xs)])

instance Functor Parser where
fmap g p = P (\inp -> case p inp of
[]              -> []
 [(v, out)]      -> [(g v, out)])

instance Applicative Parser where
pure v = P (\inp -> [(v, inp)])
pg <*> px = P (\inp -> case parse pg inp of
[]              -> []
[(g, out)]      -> parse (fmap g px) out)


When I do:
parse (pure (\x y -> (x,y)) <*> item <*> item) "abc"

The answer is:
[(('a','b'),"c")]

But I don't understand what exactly happens.
First:
pure (\x y -> (x,y)) => P (\inp -> [(\x y -> (x,y), inp)])

Then:
P (\inp -> [(\x y -> (x,y), inp)]) <*> item => ???

Can someone explain what's happens step by step please.

Thank you.