{- From Learn Haskell Fast and Hard : 4.3.1.  Maybe is a monad
 http://yannesposito.com/Scratch/en/blog/Haskell-the-Hard-Way/#maybe-monad
 
 Concerning the code below I have the following questions:
 1) Are eligibleLet and eligibleEquational operationally equivalent (i.e. perform the same operations) and/or semantically equivalent(i.e. Church-Rosser)?
 2) Apart from the return type of Maybe instead of Bool how does eligibleMonad differ from eligibleLet?
 
 Regards,
 Pat
 -}

deposit  value account = account + value
withdraw value account = account - value

-- You are eligible for a bonus only if your sequence of transactions stays out of the red.
eligibleLet :: (Num a,Ord a) => a -> Bool
eligibleLet account =
  let account1 = deposit 100 account in
    if (account1 < 0)
    then False
    else
      let account2 = withdraw 200 account1 in
      if (account2 < 0)
      then False
      else
        let account3 = deposit 100 account2 in
        if (account3 < 0)
        then False
        else
          let account4 = withdraw 300 account3 in
          if (account4 < 0)
          then False
          else
            let account5 = deposit 1000 account4 in
            if (account5 < 0)
            then False
            else
              True

-- No let expressions, hence intermediate calculations are performed multiple times.
-- Should terminates on first point of failure    
eligibleEquational :: (Num a,Ord a) => a -> Bool
eligibleEquational account =  if (deposit 100 account) < 0 then False else
                              if (withdraw 200 (deposit 100 account)) < 0  then False  else
                              if (deposit 100 (withdraw 200 (deposit 100 account))) < 0  then False else
                              if (withdraw 300 (deposit 100 (withdraw 200 (deposit 100 account)))) < 0 then False else
                              if (deposit 1000 (withdraw 300 (deposit 100 (withdraw 200 (deposit 100 account))))) < 0 then False else
                               True
    

-- Monadic version    
depositM :: (Num a) => a -> a -> Maybe a
depositM value account = Just (account + value)

withdrawM :: (Num a,Ord a) => a -> a -> Maybe a
withdrawM value account = if (account < value)
                         then Nothing
                         else Just (account - value)

eligibleMonad :: (Num a, Ord a) => a -> Maybe Bool
eligibleMonad account = do
  account1 <- depositM 100 account
  account2 <- withdrawM 200 account1
  account3 <- depositM 100 account2
  account4 <- withdrawM 300 account3
  account5 <- depositM 1000 account4
  Just True

main = do
  print $ eligibleLet 300 -- True
  print $ eligibleLet 299 -- Falsen
  print $ eligibleEquational 300 -- True
  print $ eligibleEquational 299 -- False
  print $ eligibleMonad 300 -- Just True
  print $ eligibleMonad 299 -- Nothing