Reader Applicative的应用功能

Question

Looking at the reader or environment applicative from Brent Yorgey's UPenn 2013 Lecture :

instance Functor ((->) e) where
  fmap = (.)

instance Applicative ((->) e) where
  pure = const
  f <*> x = \e -> (f e) (x e)

I'm trying to gain intuition for the Applicative instance.

Given:

(<*>) :: Applicative f => f (a -> b) -> fa -> fb

then how does \\e -> (fe) (xe) result in the fb type?

Answer 1

If we substitute ((->) e) for f (remembering that this is a function with e as its argument type), we get:

(<*>) ::     f    (a -> b)  ->    f     a  ->    f    b
(<*>) :: ((->) e) (a -> b)  -> ((->) e) a  -> ((->) e) b  -- Replace f with ((->) e)
(<*>) ::    (e -> (a -> b)) ->    (e -> a) ->    (e -> b) -- Apply ((->) e)
(<*>) ::    (e ->  a -> b)  ->    (e -> a) ->     e -> b  -- Remove unneeded parentheses

A key thing to remember is that ((->) e) a is the same as e -> a . The notation can look a bit misleading at first.

The only implementation for this type is the one you have provided in your question. This definition can also be written as:

f <*> x = \e -> f e (x e)

or, using prefix notation:

(<*>) f x e = f e (x e)

Answer 2

Looks like S combinator to me. (It's not an answer, it's a comment.)

My explanation is this:

Applicative operation is pretty much like zipping. In our specific case we have two entities ( f and a ) that both depend on e . So zipping them together produces another entity that depends on e again: and when called, it uses the same e for the left and for the right part. Compare to this:

We have f ₀ , f ₁ , f ₂ , etc, and a ₀ , a ₁ , a ₂ , etc. When zipping them, we get (f ₀ ,a ₀ ), (f ₁ ,a ₁ ), (f ₂ ,a ₂ ) etc.

In applicative case, we also apply fi to ai , so we get (f ₀ a ₀ ), (f ₁ a ₁ ), (f ₂ a ₂ ) etc. Note that we use the same index for f and a . If we consider the index as environment (we "read" the index), here we go, it's the same thing. And also, that's how S combinator works.