Improve overall style and indenting

Parser/Core.hs

@@ -13,27 +13,32 @@ module Parser.Core (Parser,
 import Control.Applicative
 import Data.Char
 
+
 -- |The parser type. It allows us to create specific parsers,
 -- combine them and run them via 'runParser' to get a result.
 newtype Parser a = MkParser { runParser :: String -> Maybe (a, String) }
 
+
 -- |Functor instance.
 instance Functor Parser where
   fmap = inParser . fmap . fmap . first
 
+
 -- |Applicative functor instance.
 instance Applicative Parser where
-  pure a = MkParser (\s -> Just (a, s))
+  pure a               = MkParser (\s -> Just (a, s))
   (MkParser fp) <*> xp = MkParser $ \s ->
     case fp s of
       Nothing    -> Nothing
       Just (f,x) -> runParser (f <$> xp) x
 
+
 -- |Alternative functor instance.
 instance Alternative Parser where
-  empty = MkParser (const Nothing)
+  empty                       = MkParser (const Nothing)
   MkParser p1 <|> MkParser p2 = MkParser $ liftA2 (<|>) p1 p2
 
+
 inParser :: ((String -> Maybe (a1, String))
          -> String
          -> Maybe (a, String))
@@ -41,9 +46,11 @@ inParser :: ((String -> Maybe (a1, String))
          -> Parser a
 inParser f p = MkParser . f . runParser $ p
 
+
 first :: (a -> b) -> (a,c) -> (b,c)
 first f (x,y) = (f x, y)
 
+
 -- |Creates a Parser that parses a Char depending on a given condition.
 satisfy :: (Char -> Bool) -- ^ condition
         -> Parser Char    -- ^ created Parser
@@ -54,10 +61,12 @@ satisfy p = MkParser f
         | p x       = Just (x, xs)
         | otherwise = Nothing
 
+
 -- |Creates a Parser that accepts a given Char.
 char :: Char -> Parser Char
 char c = satisfy (== c)
 
+
 -- |Creates a Parser that accepts positive integers.
 posInt :: Parser Integer
 posInt = MkParser f
@@ -67,29 +76,34 @@ posInt = MkParser f
       | otherwise = Just (read ns, rest)
         where (ns, rest) = span isDigit xs
 
+
 -- |Creates a Parser that accepts positive doubles.
 -- Both 131.31 and 132 are valid.
 posDouble :: Parser Double
-posDouble = (read <$>)                   $
-              (\x y z -> x ++ [y] ++ z) <$>
-              MkParser f                <*>
-              char '.'                  <*>
-              MkParser f                <|>
-              MkParser f
+posDouble =
+  (read <$>)                   $
+    (\x y z -> x ++ [y] ++ z) <$>
+    MkParser f                <*>
+    char '.'                  <*>
+    MkParser f                <|>
+    MkParser f
   where
     f xs
       | null ns   = Nothing
       | otherwise = Just (ns, rest)
         where (ns, rest) = span isDigit xs
 
+
 -- |Convert a given Parser to a Parser that accepts zero or more occurences.
 zeroOrMore :: Parser a -> Parser [a]
 zeroOrMore p = oneOrMore p <|> pure []
 
+
 -- |Convert a given Parser to a Parser that accepts one or more occurences.
 oneOrMore :: Parser a -> Parser [a]
 oneOrMore p = (:) <$> p <*> zeroOrMore p
 
+
 -- |Creates a Parser that accepts spaces.
 spaces :: Parser String
 spaces = zeroOrMore (satisfy isSpace)

Parser/Meshparser.hs

@@ -12,16 +12,18 @@ import Parser.Core
 -- an array of float tuples.
 meshToArr :: String   -- ^ the string to convert
           -> [PT]     -- ^ the resulting vertice table
-meshToArr xs = fmap (p2)                       .
-                 fmap (\(Just (x, _)) -> x)    .
-                 filter (/= Nothing)           .
-                 fmap (runParser parseVertice) .
-                 lines                         $
-                 xs
+meshToArr xs =
+  fmap (p2)                       .
+    fmap (\(Just (x, _)) -> x)    .
+    filter (/= Nothing)           .
+    fmap (runParser parseVertice) .
+    lines                         $
+    xs
 
 
 -- | Creates a Parser that accepts a single vertice, such as 'v 1.0 2.0'.
 parseVertice :: Parser (Double, Double)
-parseVertice = (,)                                 <$>
-                 (char 'v' *> spaces *> posDouble) <*>
-                 (spaces *> posDouble)
+parseVertice =
+  (,)                                 <$>
+    (char 'v' *> spaces *> posDouble) <*>
+    (spaces *> posDouble)