title: Examples of Haskell Applicative Transformers
body: <p>The wiki on www.haskell.org tells us the following about Applicative Transformers:</p>
  
  <blockquote>
    <p>So where are applicative transformers? The answer is, that we do not need special transformers for applicative functors since they can be combined in a generic way. 
    <a href="http://www.haskell.org/haskellwiki/Applicative_functor#Applicative_transfomers" rel="noreferrer">http://www.haskell.org/haskellwiki/Applicative_functor#Applicative_transfomers</a></p>
  </blockquote>
  
  <p>I tried the following in order to try to combine a bunch of applicative functors. But all I got was bunch of errors. Here is the code:</p>
  
  <pre><code>import Control.Applicative
  import System.IO
  
  ex x y = (:) &lt;$&gt; x &lt;*&gt; y 
  test1 = ex "abc" ["pqr", "xyz"]  -- only this works correctly as expected
  test2 = ex "abc" [Just "pqr", Just "xyz"]
  test3 = ex "abc" (Just "pqr")
  test4 = ex (Just 'a') ["pqr", "xyz"]
  test5 = ex (return ("abc"):: IO ()) [Just "pqr", Just "xyz"]
  </code></pre>
  
  <p>This produces a lot of type errors, which though I can partially understand, I couldn't resolve them at all.</p>
  
  <p>The errors are given at the end.</p>
  
  <p>So, how do I combine the Maybe Applicative and the List Applicative for example?</p>
  
  <p>How do I combine the State Applicative and the List Applicative for example?
  Are there any other examples, let's say, combining Maybe and List, Maybe and State and finally the dreadful of all the IO and State applicatives?</p>
  
  <p>Thanks.</p>
  
  <p>The GHCi error msgs follow.</p>
  
  <pre><code>example.hs:6:19:
      Couldn't match expected type `[Char]' with actual type `Maybe a0'
      In the return type of a call of `Just'
      In the expression: Just "pqr"
      In the second argument of `ex', namely `[Just "pqr", Just "xyz"]'
  
  example.hs:7:19:
      Couldn't match expected type `[[Char]]' with actual type `Maybe a0'
      In the return type of a call of `Just'
      In the second argument of `ex', namely `(Just "pqr")'
      In the expression: ex "abc" (Just "pqr")
  
  example.hs:8:23:
      Couldn't match expected type `Maybe' with actual type `[]'
      In the second argument of `ex', namely `["pqr", "xyz"]'
      In the expression: ex (Just 'a') ["pqr", "xyz"]
      In an equation for `test4': test4 = ex (Just 'a') ["pqr", "xyz"]
  
  example.hs:9:21:
      Couldn't match expected type `()' with actual type `[Char]'
      In the first argument of `return', namely `("abc")'
      In the first argument of `ex', namely `(return ("abc") :: IO ())'
      In the expression:
        ex (return ("abc") :: IO ()) [Just "pqr", Just "xyz"]
  Failed, modules loaded: none.
  Prelude&gt;
  </code></pre>