From 24e068d02a44f482ffdbd57442d17b77eba8ff0e Mon Sep 17 00:00:00 2001
From: mmzk1526 <yc4120@ic.ac.uk>
Date: Tue, 10 Oct 2023 10:10:15 +0100
Subject: [PATCH] [mmzk] (refactor) Remove unnecessary Readers

---
 src/Year2015/Exam.hs | 10 +++-------
 src/Year2019/SOL.hs  | 15 +++++++--------
 2 files changed, 10 insertions(+), 15 deletions(-)

diff --git a/src/Year2015/Exam.hs b/src/Year2015/Exam.hs
index 8600bb9..e924acf 100644
--- a/src/Year2015/Exam.hs
+++ b/src/Year2015/Exam.hs
@@ -2,9 +2,8 @@
 {-# LANGUAGE InstanceSigs #-}
 
 module Year2015.Exam where
-import Debug.Trace
+
 import Control.Monad.Trans.Class
-import Control.Monad.Trans.Reader
 import qualified Control.Monad.Trans.State.Strict as S
 import Data.List
 import Data.Maybe
@@ -137,7 +136,7 @@ executeStatement :: Statement -> [FunDef] -> [ProcDef] -> State -> State
 -- Pre: All statements are well formed
 -- Pre: For array element assignment (AssignA) the array variable is in scope,
 --      i.e. it has a binding in the given state
-executeStatement stmt' fDefs pDefs st' = runReader (S.execStateT (worker stmt') st') (fDefs, pDefs)
+executeStatement stmt' fDefs pDefs st' = S.execState (worker stmt') st'
   where
     worker (Assign v e)     = do
       st <- S.get
@@ -147,13 +146,11 @@ executeStatement stmt' fDefs pDefs st' = runReader (S.execStateT (worker stmt')
       let arr = assignArray (getValue v st) (eval i fDefs st) (eval e fDefs st)
       S.put $ updateVar (v, arr) st
     worker (If e b1 b2)     = do
-      (fDefs, pDefs) <- lift ask
       st             <- S.get
       case eval e fDefs st of
         I 0 -> mapM_ worker b2
         _   -> mapM_ worker b1
     worker stmt@(While e b) = do
-      (fDefs, pDefs) <- lift ask
       st             <- S.get
       case eval e fDefs st of
         I 0 -> pure ()
@@ -187,8 +184,7 @@ translate (name, (as, e)) newName nameMap
     (b, e', ids') = translate' e nameMap ['$' : show n | n <- [1..]]
 
 translate' :: Exp -> [(Id, Id)] -> [Id] -> (Block, Exp, [Id])
-translate' exp nameMap ids
-  = uncurry' $ runReader (S.runStateT (worker exp) ids) nameMap
+translate' exp nameMap ids = uncurry' (S.runState (worker exp) ids)
   where
     uncurry' ((a, b), c)   = (a, b, c)
     getFresh               = S.state $ \(i : is) -> (i, is)
diff --git a/src/Year2019/SOL.hs b/src/Year2019/SOL.hs
index 072e646..9773e10 100644
--- a/src/Year2019/SOL.hs
+++ b/src/Year2019/SOL.hs
@@ -20,7 +20,6 @@ module Year2019.SOL where
 -- > the original one. This is what modern SAT solvers do.
 
 import Control.Monad
-import Control.Monad.Trans.Reader
 import Control.Monad.Trans.State
 import Data.List
 import Data.Tuple
@@ -96,14 +95,14 @@ toCNF = toCNF' . toNNF
 -- 4 marks
 flatten :: CNF -> CNFRep
 -- > The idea is very similar to parser combinators :)
-flatten f = runReader (flattenAnd f) (idMap f)
+flatten f = flattenAnd f
   where
-    flattenAnd (And f f') = liftM2 (++) (flattenAnd f) (flattenAnd f')
-    flattenAnd f          = pure <$> flattenOr f
-    flattenOr (Or f f')   = liftM2 (++) (flattenOr f) (flattenOr f')
-    flattenOr f           = pure <$> flattenVar f
-    flattenVar (Var v)    = lookUp v <$> ask
-    flattenVar (Not f)    = negate <$> flattenVar f
+    flattenAnd (And f f') = flattenAnd f ++ flattenAnd f'
+    flattenAnd f          = [flattenOr f]
+    flattenOr (Or f f')   = flattenOr f ++ flattenOr f'
+    flattenOr f           = [flattenVar f]
+    flattenVar (Var v)    = lookUp v (idMap f)
+    flattenVar (Not f)    = negate (flattenVar f)
 
 
 --------------------------------------------------------------------------