functions as applicative functors (Haskell / LYAH)

by

First of all, remember how fmap is defined for applicatives:

fmap f x = pure f <*> x

This means that your example is the same as (fmap (+ 5) (* 3)) 4. The fmap function for functions is just composition, so your exact expression is the same as ((+ 5) . (* 3)) 4.

Now, let’s think about why the instance is written the way it is. What <*> does is essentially apply a function in the functor to a value in the functor. Specializing to (->) r, this means it applies a function returned by a function from r to a value returned by a function from r. A function that returns a function is just a function of two arguments. So the real question is this: how would you apply a function of two arguments (r and a, returning b) to a value a returned by a function from r?

The first thing to note is that you have to return a value of type (->) r which means the result also has to be a function from r. For reference, here is the <*> function:

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

Since we want to return a function taking a value of type r, x :: r. The function we return has to have a type r -> b. How can we get a value of type b? Well, we have a function f :: r -> a -> b. Since r is going to be the argument of the result function, we get that for free. So now we have a function from a -> b. So, as long as we have some value of type a, we can get a value of type b. But how do we get a value of type a? Well, we have another function g :: r -> a. So we can take our value of type r (the parameter x) and use it to get a value of type a.

So the final idea is simple: we use the parameter to first get a value of type a by plugging it into g. The parameter has type r, g has type r -> a, so we have an a. Then, we plug both the parameter and the new value into f. We need both because f has a type r -> a -> b. Once we plug both an r and an a in, we have a b1. Since the parameter is in a lambda, the result has a type r -> b, which is what we want.

More Related Contents:

  1. Good examples of Not a Functor/Functor/Applicative/Monad?
  2. Applicatives compose, monads don’t
  3. Distinction between typeclasses MonadPlus, Alternative, and Monoid?
  4. Applicative functor evaluation is not clear to me
  5. Difference between Monad and Applicative in Haskell
  6. What are Alternative’s “some” and “many” useful for?
  7. How to interpret bind/>>= of the function instance?
  8. Why should Applicative be a superclass of Monad?
  9. Monoidal Functor is Applicative but where is the Monoid typeclass in the definition of Applicative?
  10. How to handle side effect with Applicative?
  11. Haskell \p -> not takeWhile
  12. Sum of two numbers with function in haskell
  13. How to group similar items in a list using Haskell?
  14. How do I deal with many levels of indentation?
  15. Memoization in Haskell?
  16. Wrong IO actions order using putStr and getLine
  17. How do functors work in haskell?
  18. double stream feed to prevent unneeded memoization?
  19. Haskell: how to evaluate a String like “1+2”
  20. Why does haskell’s bind function take a function from non-monadic to monadic
  21. Why is lazy evaluation useful?
  22. Using Maybe type in Haskell
  23. What is a monad?
  24. Why is there “data” and “newtype” in Haskell? [duplicate]
  25. haskell running out of memory with finite lists
  26. Haskell – simple constructor comparison (?) function
  27. Comparing functions in Haskell
  28. Apostrophe in identifiers in Haskell
  29. In what sense is the IO Monad pure?
  30. Return specific type within Haskell

Leave a Comment