prefer applicative over monadic style

3 files changed, 11 insertions, 11 deletions

diff --git a/src/Environment.hs b/src/Environment.hs
index 7b3f365..4c444b6 100644
--- a/src/Environment.hs
+++ b/src/Environment.hs
@@ -8,7 +8,8 @@ module Environment ( Env
                    , IOResult
                    ) where
 
-import           Control.Monad        (liftM, mapM)
+import           Control.Applicative  ((<$>))
+import           Control.Monad        (mapM)
 import           Control.Monad.Except
 import           Data.IORef
 import           Data.Maybe           (isJust)
@@ -44,7 +45,7 @@ setVar :: Env -> String -> Expr -> IOResult ()
 setVar env var val = do
     ptr <- liftIO $ readIORef env
     maybe (throwError $ UnboundVariable var)
-          (liftIO . (flip writeIORef val))
+          (liftIO . flip writeIORef val)
           $ lookup var ptr
 
 defineVar :: Env -> String -> Expr -> IOResult ()
@@ -65,5 +66,5 @@ makeBind (var, val) = do
 manyBindings :: Env -> [(String, Expr)] -> IO Env
 manyBindings env binds = do
     ptr <- readIORef env
-    extendedEnv <- liftM (++ ptr) $ mapM makeBind binds
+    extendedEnv <- (++ ptr) <$> mapM makeBind binds
     newIORef extendedEnv
diff --git a/src/Evaluator.hs b/src/Evaluator.hs
index 1cc9edd..3d3be02 100644
--- a/src/Evaluator.hs
+++ b/src/Evaluator.hs
@@ -19,9 +19,9 @@ apply fn args = maybe
 evalUnquote :: Env -> Expr -> IOResult Expr
 evalUnquote env (List [Id "unquote", vs]) = eval env vs
 evalUnquote env (List [Id "quote", vs]) =
-    liftM (List . ([Id "quote"] ++ ) . (: [])) (evalUnquote env vs)
-evalUnquote env (List vs)   = liftM List $ mapM (evalUnquote env) vs
-evalUnquote env (Vector vs) = liftM Vector $ mapM (evalUnquote env) vs
+    fmap (List . ([Id "quote"] ++ ) . (: [])) (evalUnquote env vs)
+evalUnquote env (List vs)   = List <$> mapM (evalUnquote env) vs
+evalUnquote env (Vector vs) = Vector <$> mapM (evalUnquote env) vs
 evalUnquote env literal = return literal
 
 evalQuasiQuote :: Env -> Expr -> IOResult Expr
@@ -35,12 +35,12 @@ eval _ v@(IntLiteral i)    = return v
 eval _ v@(BoolLiteral b)   = return v
 eval env (Id l)            = getVar env l
 eval _ v@(FloatLiteral f)  = return v
-eval env v@(Vector xs)     = liftM Vector $ mapM (eval env) xs
+eval env v@(Vector xs)     = Vector <$> mapM (eval env) xs
 eval env (List[Id "quote", val])      = return val
 eval env (List[Id "quasiquote", val]) = evalQuasiQuote env val
-eval env v@(List[Id "unquote", val])    = throwError $ BadForm "Cannot use `unquote` form outside quasiquote context" v
-eval env (List [Id "set!", Id var, val]) = eval env val >>= uncurry (*>) . ((setVar env var) &&& pure)
-eval env (List [Id "define", Id var, val]) = eval env val >>= uncurry (*>) . ((defineVar env var) &&& pure)
+eval env v@(List[Id "unquote", val])    = throwError $ BadForm "Cannot use `unquote` outside quasiquote form" v
+eval env (List [Id "set!", Id var, val]) = eval env val >>= uncurry (*>) . (setVar env var &&& pure)
+eval env (List [Id "define", Id var, val]) = eval env val >>= uncurry (*>) . (defineVar env var &&& pure)
 eval env (List (Id fn : args))        = mapM (eval env) args >>= liftLispResult . apply fn
 eval env NoReturn = throwError $ BadForm "Invalid usage of non-returning expression" NoReturn
 
diff --git a/src/Parser.hs b/src/Parser.hs
index a7f5571..6ec4ba0 100644
--- a/src/Parser.hs
+++ b/src/Parser.hs
@@ -8,7 +8,6 @@ module Parser ( parseLispValue
               ) where
 
 import           Control.Applicative           ((<$>))
-import           Control.Monad                 (liftM)
 import           Text.ParserCombinators.Parsec
 
 -- TODO: use LispNumber (src/Operators.hs) here instead of IntLiteral and FloatLiteral