ApplicativeDo pragma and Applicative Functor in Haskell

Question

An example from Functor, Applicative, and Monad slightly changed:

{-# LANGUAGE ApplicativeDo #-}

import Safe (readMay)
-- import Control.Applicative ((<$>), (<*>))

displayAge maybeAge =
    case maybeAge of
        Nothing -> putStrLn "You provided invalid input"
        Just age -> putStrLn $ "In that year, you will be: " ++ show age

yearDiff futureYear birthYear = futureYear - birthYear

maybeAge fS bS = do 
   fI <- readMay fS
   bI <- readMay bS
   pure $ yearDiff fI bI       

main = do
    putStrLn "Please enter your birth year"
    birthYearString <- getLine
    putStrLn "Please enter some year in the future"
    futureYearString <- getLine
    displayAge $ maybeAge birthYearString futureYearString

where maybeAge with do I used instead of

maybeAge fS bS = yearDiff <$> readMay fS <*> readMay bS

I have the 2 questions:

1. How can I check does maybeAge use Applicative Functor semantic or Monad one in this case?
2. What is an advantage in that case if Applicative Functor used?

About: ApplicativeDo.

Answer 1

I made a self-contained example out of yours:

{-# LANGUAGE ApplicativeDo #-}

import Text.Read (readMaybe)

displayAge :: Maybe Int -> IO ()
displayAge maybeAge =
    case maybeAge of
        Nothing -> putStrLn "You provided invalid input"
        Just age -> putStrLn $ "In that year, you will be: " ++ show age

yearDiff :: Int -> Int -> Int
yearDiff  = (-)

maybeAge :: String -> String -> Maybe Int
maybeAge fS bS = do 
   fI <- readMaybe fS
   bI <- readMaybe bS
   pure $ yearDiff fI bI

main :: IO ()
main = do
    putStrLn "Please enter your birth year"
    birthYearString <- getLine
    putStrLn "Please enter some year in the future"
    futureYearString <- getLine
    displayAge $ maybeAge futureYearString birthYearString

Also, in the last line, I swapped the arguments, as they appear to be in the wrong order in your example. Also I improved yearDif definition as per @Redu's comment.

Here are the answers on your questions.

1. You can check that applicative (and functor) operations are indeed applied, following the advice in the GHC's User Guide, namely, using the -ddump-ds compiler switch. I add a couple more switches below to make the output more succinct. I also show only excerpt concerning the maybeAge function.

   $ ghc appdo.hs -ddump-ds -dsuppress-type-applications -dsuppress-module-prefixes 
   [1 of 1] Compiling Main             ( appdo.hs, appdo.o )
   
   ==================== Desugar (after optimization) ====================
   Result size of Desugar (after optimization)
     = {terms: 75, types: 75, coercions: 0, joins: 0/0}
   ...
   -- RHS size: {terms: 17, types: 13, coercions: 0, joins: 0/0}
   maybeAge :: String -> String -> Maybe Int
   [LclId]
   maybeAge
     = \ (fS_a1h3 :: String) (bS_a1h4 :: String) ->
         <*>
           $fApplicativeMaybe
           (fmap
              $fFunctorMaybe
              (\ (fI_a1h5 :: Int) (bI_a1h6 :: Int) -> yearDiff fI_a1h5 bI_a1h6)
              (readMaybe $fReadInt fS_a1h3))
           (readMaybe $fReadInt bS_a1h4)
   ...
   

2. Most certainly, no speedup is gained here. Applicative opertaions for Maybe have constant complexity (O(1)) — just like the monadic ones.

   In the original paper, the authors of ApplicativeDo give several examples of more sophisticated monadic types (Haxl, Data.Seq, parsing, etc.) allowing for asymptotically more efficient applicative operations. See Section 6 of the paper.