Implement HLint suggestions

5 files changed, 31 insertions, 32 deletions

diff --git a/Assembler.hs b/Assembler.hs
index 0b58482..62649e4 100644
--- a/Assembler.hs
+++ b/Assembler.hs
@@ -43,9 +43,9 @@ data Instruction = MOVA Argument Argument
 -- is simple conversion from lexemes to IR
 resolve :: Integer -> [L.Lexeme] -> [(Argument, Segment)]
 resolve _ [] = []
-resolve line ((L.Label seg n):xs) = (Immediate $ n-line, seg) : resolve line xs
-resolve line ((L.Immediate seg n):xs) = (Immediate n, seg) : resolve line xs
-resolve line ((L.Register seg n):xs) = (Register n, seg) : resolve line xs
+resolve line (L.Label seg n : xs) = (Immediate $ n-line, seg) : resolve line xs
+resolve line (L.Immediate seg n : xs) = (Immediate n, seg) : resolve line xs
+resolve line (L.Register seg n : xs) = (Register n, seg) : resolve line xs
 
 data Requirement = ImmRange Integer Integer
                  | RegRoof Integer
@@ -55,7 +55,7 @@ require :: Segment -> [(Argument, Segment)] -> [Requirement] -> Either Error [Ar
 require _ [] [] = return []
 require _ ((a, seg):_) [] = Left $ Error [ErrorLine seg "Too many arguments supplied to instruction."]
 require iseg [] (r:rs) = Left $ Error [ErrorLine iseg "Too few arguments supplied to instruction."]
-require iseg ((a, seg):as) ((ImmRange l h):rs) = do
+require iseg ((a, seg):as) (ImmRange l h : rs) = do
     rest <- require iseg as rs
     case a of
         Immediate i -> if i >= l && i <= h
@@ -65,7 +65,7 @@ require iseg ((a, seg):as) ((ImmRange l h):rs) = do
                                                           "address is too far away from the branch"]
                             where range = '[' : show l ++ ';' : show h ++ "]"
         _ -> Left $ Error [ErrorLine seg "Expected immediate or label."]
-require iseg ((a, seg):as) ((RegRoof h):rs) = do
+require iseg ((a, seg):as) (RegRoof h : rs) = do
     rest <- require iseg as rs
     case a of
         Register i -> if i >= 0 && i <= h
@@ -147,14 +147,14 @@ mkWord :: Word16 -> Word16 -> Word16 -> Word16 -> Word16
 mkWord inst dr sa sb = ((inst .&. 0x7F) `shift` 9)
                        .|. ((dr .&. 0x7) `shift` 6)
                        .|. ((sa .&. 0x7) `shift` 3)
-                       .|. ((sb .&. 0x7))
+                       .|.  (sb .&. 0x7)
 
 -- Helper for bit mangling instructions using the sign extender
 mkWordSE :: Word16 -> Word16 -> Word16 -> Word16
 mkWordSE inst dr sa = ((inst .&. 0x7F) `shift` 9)
                       .|. ((dr .&. 0x38) `shift` 6)
                       .|. ((sa .&. 0x7) `shift` 3)
-                      .|. ((dr .&. 0x7))
+                      .|.  (dr .&. 0x7)
 
 -- Convert argument to Word16
 argToWord :: Argument -> Word16
@@ -183,13 +183,13 @@ asm (JMP sa) = mkWord 0x70 0 (argToWord sa) 0
 asm (LRI dr sa) = mkWord 0x11 (argToWord dr) (argToWord sa) 0
 asm (SRM dr sa sb) = mkWord 0x0D (argToWord dr) (argToWord sa) (argToWord sb)
 asm (SRL dr sa sb) = mkWord 0x0E (argToWord dr) (argToWord sa) (argToWord sb)
-asm (DB imm) = (argToWord imm) .&. 0xFF
+asm (DB imm) = argToWord imm .&. 0xFF
 
 -- Zero pad the numbers to 4c boundary
 zeroPad :: String -> String
 zeroPad xs = replicate (if n < 4 then n else 0) '0' ++ xs
-           where n = (4 - (length xs `rem` 4))
+           where n = 4 - (length xs `rem` 4)
 
 -- Assemble IR into string
 assemble :: [Instruction] -> String
-assemble is = foldl (\x y -> zeroPad $ showHex (asm y) x) "" is
+assemble = foldl (\x y -> zeroPad $ showHex (asm y) x) ""
diff --git a/Compiler.hs b/Compiler.hs
index 6eb8be5..f80d1d0 100644
--- a/Compiler.hs
+++ b/Compiler.hs
@@ -12,16 +12,16 @@ import qualified Control.Monad.Error as E
 -- Extract a list of label declarations from lexemes and find their absolute
 -- position
 getLabels :: [([Lexeme], Maybe Lexeme, [Lexeme])] -> [Lexeme]
-getLabels xs = concat $ map (\(ls, _, _, n) -> map (g n) ls) numbered
+getLabels xs = concatMap (\(ls, _, _, n) -> map (g n) ls) numbered
              where numbered = scanl f ([], Nothing, [], 0) xs
-                   f (_, pi, _, n) (ls, i, as) = (ls, i, as, n+(inc pi))
-                   inc pi = maybe 0 (\_ -> 1) pi
+                   f (_, pi, _, n) (ls, i, as) = (ls, i, as, n + inc pi)
+                   inc = maybe 0 (\_ -> 1)
                    g n (Label seg _) = Label seg n
 
 -- Ensure uniqueness of a label lexeme list
 getUniqueLabels :: [Lexeme] -> Either Error (M.Map String Lexeme)
 getUniqueLabels [] = Right M.empty
-getUniqueLabels ((Label seg n):xs) = do
+getUniqueLabels (Label seg n : xs) = do
     rest <- getUniqueLabels xs
     case M.lookup key rest of
         Nothing -> return $ M.insert key (Label seg n) rest
@@ -38,11 +38,11 @@ getInstructions ((_, Nothing, _):xs) = getInstructions xs
 -- Resolve labels used in arguments to their absolute position
 resolveLabels :: M.Map String Lexeme -> [Lexeme] -> Either Error [Lexeme]
 resolveLabels _ [] = return []
-resolveLabels m ((Label seg _):xs) = do
+resolveLabels m (Label seg _ : xs) = do
     rest <- resolveLabels m xs
     case M.lookup key m of
         Nothing -> Left $ Error [ErrorLine seg "Undeclared label."]
-        Just (Label _ n') -> return $ (Label seg n') : rest
+        Just (Label _ n') -> return $ Label seg n' : rest
     where key = getSegment seg
 resolveLabels m (x:xs) = do
     rest <- resolveLabels m xs
@@ -51,7 +51,7 @@ resolveLabels m (x:xs) = do
 -- Lex a list of files and accompanying data
 lexFiles :: [(FilePath, String)] -> Either Error [([Lexeme], Maybe Lexeme, [Lexeme])]
 lexFiles xs = mapM (\((f, l), o) -> lexLine f o l) (zip expanded [1..])
-              where expanded = concat $ map (\(f, l) -> zip (repeat f) (lines l)) xs
+              where expanded = concatMap (\(f, l) -> zip (repeat f) (lines l)) xs
 
 -- Split a list into n-sized sublists
 chunk :: Int -> [a] -> [[a]]
@@ -61,7 +61,7 @@ chunk n xs = y1 : chunk n y2
 
 -- Format assembled string into code that's easily pasted into RAM block
 formatRAM :: String -> Either Error [String]
-formatRAM s = if (length chunks) <= 16
+formatRAM s = if length chunks <= 16
               then return $ map f ss
               else Left $ Error [ErrorLine (Segment "*" 0 0 0 "Maximum amount of instructions can't exceed RAM size.") "Code is too long."]
             where chunks = map reverse $ chunk 64 (reverse s)
@@ -70,7 +70,7 @@ formatRAM s = if (length chunks) <= 16
                                          then replicate (64 - length h) '0'
                                          else "") ++ h, l)) lls
                   delim l = if l < 15 then ',' else ')'
-                  f (h, l) = printf "INIT_%02X => \"" l ++ h ++ '\"':delim l:[]
+                  f (h, l) = printf "INIT_%02X => \"" l ++ h ++ ['\"', delim l]
 
 -- Compile a list of files and accompanying data to a string list
 compile :: Bool -> [(FilePath, String)] -> Either Error [String]
@@ -83,5 +83,5 @@ compile ppo xs = do
         return (i, as')) (getInstructions lexed)
     ir <- processInstructions is
     if ppo
-    then return $ map show ir
-    else formatRAM $ assemble ir
+        then return $ map show ir
+        else formatRAM $ assemble ir
diff --git a/Error.hs b/Error.hs
index 8ffff44..01065df 100644
--- a/Error.hs
+++ b/Error.hs
@@ -17,8 +17,8 @@ data Segment = Segment { file :: FilePath
                        deriving (Show)
 
 instance Eq Segment where
-    a == b = (getSegment a) == (getSegment b)
-    a /= b = (getSegment a) /= (getSegment b)
+    a == b = getSegment a == getSegment b
+    a /= b = getSegment a /= getSegment b
 
 -- Prints a segment with underline
 showSegment :: Segment -> String
@@ -35,11 +35,11 @@ data ErrorLine = ErrorLine Segment String
 data Error = Error [ErrorLine]
 
 instance Show ErrorLine where
-    show (ErrorLine seg desc) = unlines $ (pp ++ desc) : (lines $ showSegment seg)
+    show (ErrorLine seg desc) = unlines $ (pp ++ desc) : lines (showSegment seg)
                               where pp = file seg ++ (':' : (show (line seg) ++ ": "))
 
 instance Show Error where
-    show (Error es) = concat $ map show es
+    show (Error es) = concatMap show es
 
 -- Duplicates whitespace so underlines fit under the string it underlines
 dupWhitespace :: Integer -> String -> String
diff --git a/Lexer.hs b/Lexer.hs
index d690080..1f06b75 100644
--- a/Lexer.hs
+++ b/Lexer.hs
@@ -45,7 +45,7 @@ getToken (x:xs) p
 tokenize :: String -> Integer -> [Token]
 tokenize [] _ = []
 tokenize xs pos = let (t, r) = getToken xs pos
-                  in t:(tokenize r $ case t of
+                  in t : tokenize r (case t of
                                          (Name _ _ e) -> e+1
                                          (Separator _ p) -> p+1)
 
@@ -88,10 +88,10 @@ numberBase xs = (10, xs)
 isNumber'' :: Integer -> String -> Bool
 isNumber'' _ [] = False
 isNumber'' b (x:[])
-    | isHexDigit x = (toInteger $ digitToInt x) < b
+    | isHexDigit x = toInteger (digitToInt x) < b
     | otherwise = False
 isNumber'' b (x:y:zs)
-    | isHexDigit x = ((toInteger $ digitToInt x) < b) && (isNumber'' b (y:zs))
+    | isHexDigit x = (toInteger (digitToInt x) < b) && isNumber'' b (y:zs)
     | otherwise = False
 
 isNumber' :: String -> Bool
@@ -100,13 +100,13 @@ isNumber' xs = isNumber'' b s where (b, s) = numberBase xs
 
 parseNumber :: String -> Integer
 parseNumber ('-':xs) = -(parseNumber xs)
-parseNumber xs = foldl (\n k -> n * b + (toInteger $ digitToInt k)) 0 s
+parseNumber xs = foldl (\n k -> n * b + toInteger (digitToInt k)) 0 s
                  where (b, s) = numberBase xs
 
 -- Register parsing
 isRegister :: String -> Bool
 isRegister [] = False
-isRegister (x:xs) = if toLower x == 'r' then isNumber'' 10 xs else False
+isRegister (x:xs) = (toLower x == 'r') && isNumber'' 10 xs
 
 parseRegister :: String -> Integer
 parseRegister (x:xs) = parseNumber xs
diff --git a/PWFASM.hs b/PWFASM.hs
index f3a08d4..0f905a5 100644
--- a/PWFASM.hs
+++ b/PWFASM.hs
@@ -31,8 +31,7 @@ closeOutput h
     | otherwise = hClose h
 
 writeOutput :: Handle -> [String] -> IO ()
-writeOutput h ls = do
-    hPutStr h (unlines ls)
+writeOutput h ls = hPutStr h (unlines ls)
 
 readInput :: [FilePath] -> IO [String]
 readInput [] = do