diff --git a/app/Api/Api.hs b/app/Api/Api.hs
index 8567a0b..5568d0a 100644
--- a/app/Api/Api.hs
+++ b/app/Api/Api.hs
@@ -49,133 +49,100 @@ jsonHeaders :: [Header]
 jsonHeaders = [("Content-Type", "application/json")]
 
 messageResponse :: String -> String
-messageResponse value =
-  j2s
-    [aesonQQ|{
+messageResponse value = j2s [aesonQQ|{
     "message":#{value}
 }|]
 
 apiMap :: [APIRoute]
-apiMap =
-  [
-    ( "POST"
-    ,
-      [
-        ( "/visits/new"
-        , \r -> do
+apiMap = [
+    ("POST", [
+        ("/visits/new", \r -> do
             body <- getRequestBodyChunk r
             result <- uuidExists $ unpackBS body
-            res <-
-              if result
-                then do
-                  time <- fmap round getPOSIXTime :: IO Int
-                  uuid <- nextRandom
-                  runDb $ insertEntity $ Visit 0 time $ toString uuid
-                  return $ toString uuid
-                else
-                  return $ unpackBS body
+            res <- if result then do
+                time <- fmap round getPOSIXTime :: IO Int
+                uuid <- nextRandom
+                runDb $ insertEntity $ Visit 0 time $ toString uuid
+                return $ toString uuid
+            else
+                return $ unpackBS body
             return (status200, j2s [aesonQQ|{"uuid":#{res}}|], jsonHeaders)
-        )
-      ,
-        ( "/admin/login"
-        , \r -> do
+        ),
+        ("/admin/login", \r -> do
             body <- getRequestBodyChunk r
             let credentials = getDefault T.EmptyCredentials (decode (fromStrict body) :: Maybe T.Credentials)
             case credentials of
-              (T.Credentials username password) -> do
-                let pass = mkPassword $ pack password
-                rows <- map (\(Entity _ e) -> e) <$> (runDb $ selectList [Filter UserName (FilterValue username) (BackendSpecificFilter "LIKE")] [] :: IO [Entity User])
-                case rows of
-                  [user] -> case checkPassword pass (PasswordHash $ pack (userPassword user)) of
-                    PasswordCheckSuccess -> do
-                      rows <- map (\(Entity _ e) -> e) <$> (runDb $ selectList [Filter TokenName (FilterValue username) (BackendSpecificFilter "LIKE")] [] :: IO [Entity Token])
-                      response <-
-                        if null rows
-                          then do
-                            token <- stringRandomIO "[0-9a-zA-Z]{4}-[0-9a-ZA-Z]{10}-[0-9a-zA-Z]{15}"
-                            runDb $ insertEntity $ Token 0 (unpack token) username
-                            return $ unpack token
-                          else return $ tokenToken $ head rows
-                      return (status200, j2s [aesonQQ|{"token":#{response}}|], jsonHeaders)
-                    PasswordCheckFail -> return (status400, messageResponse "Error, Wrong username or password", jsonHeaders)
-                  _ -> return (status400, messageResponse "Error, no user exists", jsonHeaders)
-              _ -> return (status400, messageResponse "Error, Invalid request", jsonHeaders)
-        )
-      ,
-        ( "/brainfuck"
-        , \r -> do
+                (T.Credentials username password) -> do
+                    let pass = mkPassword $ pack password
+                    rows <- map (\(Entity _ e) -> e) <$> (runDb $ selectList [Filter UserName (FilterValue username) (BackendSpecificFilter "LIKE")] [] :: IO [Entity User])
+                    case rows of
+                        [user] -> case checkPassword pass (PasswordHash $ pack (userPassword user)) of
+                            PasswordCheckSuccess -> do
+                                rows <- map (\(Entity _ e) -> e) <$> (runDb $ selectList [Filter TokenName (FilterValue username) (BackendSpecificFilter "LIKE")] [] :: IO [Entity Token])
+                                response <- if null rows then do
+                                    token <- stringRandomIO "[0-9a-zA-Z]{4}-[0-9a-ZA-Z]{10}-[0-9a-zA-Z]{15}"
+                                    runDb $ insertEntity $ Token 0 (unpack token) username
+                                    return $ unpack token
+                                else return $ tokenToken $ head rows
+                                return (status200, j2s [aesonQQ|{"token":#{response}}|], jsonHeaders)
+                            PasswordCheckFail -> return (status400, messageResponse "Error, Wrong username or password", jsonHeaders)
+                        _ -> return (status400, messageResponse "Error, no user exists", jsonHeaders)
+                _ -> return (status400, messageResponse "Error, Invalid request", jsonHeaders)
+        ),
+        ("/brainfuck", \r -> do
             input <- getRequestBodyChunk r
             let result = code $ unpackBS input
             return (status200, result, [("Content-Disposition", "attachment; filename=\"brainfuck.c\"")])
         )
-      ]
-    )
-  ,
-    ( "GET"
-    ,
-      [
-        ( "/visits/get"
-        , \_ -> do
+    ]),
+    ("GET", [
+        ("/visits/get", \_ -> do
             visits <- show . length <$> getVisits
             return (status200, j2s [aesonQQ|{"visits":#{visits}}|], jsonHeaders)
-        )
-      ,
-        ( "/guestbook/get"
-        , \_ -> do
+        ),
+        ("/guestbook/get", \_ -> do
             entries <- getGuestbook
             return (status200, j2s [aesonQQ|{"entries":#{unpackBS $ toStrict $ encode $ show entries}}|], jsonHeaders)
         )
-      ]
-    )
-  ,
-    ( "PUT"
-    ,
-      [
-        ( "/guestbook/add"
-        , \r -> do
+    ]),
+    ("PUT", [
+        ("/guestbook/add", \r -> do
             body <- getRequestBodyChunk r
             let entry = getDefault T.EmptyGuestbook (decode (fromStrict body) :: Maybe T.GuestbookEntry)
             case entry of
-              (T.GuestbookEntry "" _ _) -> return (status400, messageResponse "Error, name cannot be empty", jsonHeaders)
-              (T.GuestbookEntry _ "" _) -> return (status400, messageResponse "Error, content cannot be empty", jsonHeaders)
-              (T.GuestbookEntry name content parentId) -> do
-                time <- fmap round getPOSIXTime :: IO Int
-                runDb $ insertEntity $ GuestbookEntry 0 time name content parentId
-                return (status200, messageResponse "Success", jsonHeaders)
-        )
-      ,
-        ( "/snake/add"
-        , \r -> do
+                (T.GuestbookEntry "" _ _) -> 
+                    return (status400, messageResponse "Error, name cannot be empty", jsonHeaders)
+                (T.GuestbookEntry _ "" _) -> 
+                    return (status400, messageResponse "Error, content cannot be empty", jsonHeaders)
+                (T.GuestbookEntry name content parentId) -> do
+                    time <- fmap round getPOSIXTime :: IO Int
+                    runDb $ insertEntity $ GuestbookEntry 0 time name content parentId
+                    return (status200, messageResponse "Success", jsonHeaders)
+        ),
+        ("/snake/add", \r -> do
             body <- getRequestBodyChunk r
             let entry = getDefault T.EmptyLeaderboard (decode (fromStrict body) :: Maybe T.LeaderboardEntry)
             case entry of
-              T.EmptyLeaderboard -> return (status400, messageResponse "Error, leaderboard empty", jsonHeaders)
-              (T.LeaderboardEntry name score speed fruits) -> do
-                time <- fmap round getPOSIXTime :: IO Int
-                runDb $ insertEntity $ Snake 0 time name score speed fruits
-                return (status200, messageResponse "Success", jsonHeaders)
+                T.EmptyLeaderboard -> return (status400, messageResponse "Error, leaderboard empty", jsonHeaders)
+                (T.LeaderboardEntry name score speed fruits) -> do
+                    time <- fmap round getPOSIXTime :: IO Int
+                    runDb $ insertEntity $ Snake 0 time name score speed fruits
+                    return (status200, messageResponse "Success", jsonHeaders)
         )
-      ]
-    )
-  ,
-    ( "DELETE"
-    , []
-    )
-  ]
+    ]),
+    ("DELETE", [])
+    ]
 
 api :: Request -> APIResponse
 api request = do
-  let method = unpackBS $ requestMethod request
-  let path = pathInfo request
-  case find (\(name, _) -> name == method) apiMap of
-    (Just (_, endpoints)) -> case find
-      ( \(regex, _) ->
-          ( case matchRegex (mkRegex ("api" ++ regex)) $ unpack (intercalate "/" path) of
-              Nothing -> False
-              _ -> True
-          )
-      )
-      endpoints of
-      (Just (_, f)) -> f request
-      Nothing -> return (status400, messageResponse "Error, no endpoint found", defaultHeaders)
-    Nothing -> return (status400, messageResponse "Error, no endpoint found", defaultHeaders)
+    let method = unpackBS $ requestMethod request
+    let path = pathInfo request
+    case find (\(name, _) -> name == method) apiMap of
+        (Just (_, endpoints)) -> case find (checkEndpoint path) endpoints of
+            (Just (_, f)) -> f request
+            Nothing -> return (status400, messageResponse "Error, no endpoint found", defaultHeaders)
+        Nothing -> return (status400, messageResponse "Error, no endpoint found", defaultHeaders)
+    where
+        checkEndpoint path (regex, _) = case matchRegex (mkRegex ("api" ++ regex)) $ unpack (intercalate "/" path) of
+            Nothing -> False
+            _ -> True
diff --git a/app/Footer.hs b/app/Footer.hs
index 76be0ee..bb1c392 100644
--- a/app/Footer.hs
+++ b/app/Footer.hs
@@ -4,8 +4,7 @@ import IHP.HSX.QQ (hsx)
 import Text.Blaze.Html (Html)
 
 footer :: Html
-footer =
-  [hsx|
+footer = [hsx|
     <div>
     </div>
 |]
diff --git a/app/Header.hs b/app/Header.hs
index 0eb93cd..e7c57f4 100644
--- a/app/Header.hs
+++ b/app/Header.hs
@@ -5,8 +5,7 @@ import Text.Blaze.Html (Html)
 
 makeLinks :: [(String, String)] -> Html
 makeLinks [] = [hsx||]
-makeLinks [(display, url)] =
-  [hsx|
+makeLinks [(display, url)] = [hsx|
     <a href={url}>{display}</a> | 
     <input id="search" placeholder="search">
     <script>
@@ -18,15 +17,13 @@ makeLinks [(display, url)] =
         }
     </script>
 |]
-makeLinks ((display, url) : xs) =
-  [hsx|
+makeLinks ((display, url) : xs) = [hsx|
     <a href={url}>{display}</a> |
     {makeLinks xs}
 |]
 
 header :: [(String, String)] -> Html
-header links =
-  [hsx|
+header links = [hsx|
     <div>
         {makeLinks links}
     </div>
diff --git a/app/Index.hs b/app/Index.hs
index d37a7bf..59addfb 100644
--- a/app/Index.hs
+++ b/app/Index.hs
@@ -10,9 +10,7 @@ import Page (Page, PageSetting (Description, EmbedImage, EmbedText, Route))
 import Section (section)
 
 intro :: Html
-intro =
-  section
-    [hsx|
+intro = section [hsx|
     Welcome to my home page, returning visitors might notice that the same layout that i always use is still present, and yes the site is still written in Haskell.
     <br><br>
     I was using the whole IHP development suite to work on the site originally, but i have a problem with that framework: its huge and very overkill for what i'm trying to do.
@@ -42,30 +40,29 @@ intro =
 
 page :: IO Html
 page = do
-  visits <- show . length <$> getVisits
-  return
-    [hsx|
-    <h1>Skademaskinen</h1>
-    <img src="/static/icon.png" style="border-radius:50%">
-    <br>
-    <hr>
-    {intro}
-    Visitors: <p id="visits">{visits}</p>
-    <script>
-        fetch("/api/visits/new", {
-            method: "post",
-            body: getCookie("visitId")
-        }).then(res => res.json().then(data => setCookie("visitId="+data.uuid)))
-    </script>
-|]
+    visits <- show . length <$> getVisits
+    return [hsx|
+        <h1>Skademaskinen</h1>
+        <img src="/static/icon.png" style="border-radius:50%">
+        <br>
+        <hr>
+        {intro}
+        Visitors: <p id="visits">{visits}</p>
+        <script>
+            fetch("/api/visits/new", {
+                method: "post",
+                body: getCookie("visitId")
+            }).then(res => res.json().then(data => setCookie("visitId="+data.uuid)))
+        </script>
+    |]
 
 settings :: [PageSetting]
-settings =
-  [ Route "/"
-  , Description "This is the front page for Skademaskinen, a server built as a passion project."
-  , EmbedImage "/static/icon.png"
-  , EmbedText "Skademaskinen - Index"
-  ]
+settings = [
+    Route "/",
+    Description "This is the front page for Skademaskinen, a server built as a passion project.",
+    EmbedImage "/static/icon.png",
+    EmbedText "Skademaskinen - Index"
+    ]
 
 index :: Page
 index = (settings, const $ layout <$> page)
diff --git a/app/Layout.hs b/app/Layout.hs
index 176adcd..1f070c7 100644
--- a/app/Layout.hs
+++ b/app/Layout.hs
@@ -7,8 +7,7 @@ import Footer (footer)
 import Header (header)
 
 layout :: Html -> Html
-layout content =
-  [hsx|
+layout content = [hsx|
     <!DOCTYPE html>
     <html>
         <head>
diff --git a/app/Main.hs b/app/Main.hs
index eef9699..a504a97 100644
--- a/app/Main.hs
+++ b/app/Main.hs
@@ -49,94 +49,72 @@ serve content = responseBuilder status200 [("Content-Type", "text/html")] $ copy
 
 autoContentType :: String -> (HeaderName, ByteString)
 autoContentType path = ("Content-Type", mime extension)
- where
-  extension = last (splitOn "." path)
-  mime "js" = "application/javascript"
-  mime "png" = "image/png"
-  mime "svg" = "image/svg+xml"
-  mime "css" = "text/css"
-  mime _ = "text/plain"
+  where
+      extension = last (splitOn "." path)
+      mime "js" = "application/javascript"
+      mime "png" = "image/png"
+      mime "svg" = "image/svg+xml"
+      mime "css" = "text/css"
+      mime _ = "text/plain"
 
 serveFile :: String -> IO Response
 serveFile path = do
-  info "Serving file"
-  exists <- doesFileExist path
-  if exists
-    then do
-      info "File exists"
-
-      return $ responseFile status200 [autoContentType path] path Nothing
+    info "Serving file"
+    exists <- doesFileExist path
+    if exists then do
+        info "File exists"
+        return $ responseFile status200 [autoContentType path] path Nothing
     else do
-      warning "No file found!"
-      return $ responseLBS status404 [("Content-Type", "text/json")] $ encode [aesonQQ|{"error":"Error, file not found"}|]
+        warning "No file found!"
+        return $ responseLBS status404 [("Content-Type", "text/json")] $ encode [aesonQQ|{"error":"Error, file not found"}|]
 
 app :: Request -> (Response -> IO b) -> IO b
 app request respond = do
-  let xs = map unpack $ pathInfo request
-  let x = if null xs then "" else head xs
-  let args = "/" ++ intercalate "/" xs
-  response <-
-    if x == "static"
-      then do
+    let xs = map unpack $ pathInfo request
+    let x = if null xs then "" else head xs
+    let args = "/" ++ intercalate "/" xs
+    response <- if x == "static" then do
         -- If the requested content is a file
         serveFile $ intercalate "/" xs
-      else
-        if x == "favicon.ico"
-          then do
-            -- If the requested file is the icon file
-            serveFile "static/favicon.ico"
-          else
-            if x == "api"
-              then do
-                -- If the request is to the API
-                (status, value, headers) <- api request
-                return $ responseBuilder status headers $ copyByteString (fromString value)
-              else do
-                -- If the content is to the HTML Frontend
-                let (settings, page) = findPage args
-                result <- page request
-                let image =
-                      if embedImage settings /= ""
-                        then
-                          [hsx|
+    else if x == "favicon.ico" then do
+        -- If the requested file is the icon file
+        serveFile "static/favicon.ico"
+    else if x == "api" then do
+        -- If the request is to the API
+        (status, value, headers) <- api request
+        return $ responseBuilder status headers $ copyByteString (fromString value)
+    else do
+        -- If the content is to the HTML Frontend
+        let (settings, page) = findPage args
+        result <- page request
+        let image = if embedImage settings /= "" then [hsx|
             <meta content={embedImage settings} property="og:image">
-        |]
-                        else [hsx||]
-                let text =
-                      if embedText settings /= ""
-                        then
-                          [hsx|
+        |] else [hsx||]
+        let text = if embedText settings /= "" then [hsx|
             <meta content={embedText settings} property="og:title">
-        |]
-                        else [hsx||]
-                let desc =
-                      if description settings /= ""
-                        then
-                          [hsx|
+        |] else [hsx||]
+        let desc = if description settings /= "" then [hsx|
             <meta content={description settings} property="og:description">
-        |]
-                        else [hsx||]
+        |] else [hsx||]
 
-                return $ serve (mconcat [result, image, text, desc])
+        return $ serve (mconcat [result, image, text, desc])
 
-  logger request response
-  respond response
+    logger request response
+    respond response
 
 main :: IO ()
 main = do
-  port <- getPort
-  info $ "Listening on " ++ show port
-  putStrLn $ "+" ++ mconcat (replicate 65 "-") ++ "+"
-  putStrLn $ tableify ["METHOD", "STATUS", "PATH"]
-  putStrLn $ "+" ++ mconcat (replicate 65 "-") ++ "+"
-  migrate <- getMigrate
-  if migrate
-    then
-      doMigration
+    port <- getPort
+    info $ "Listening on " ++ show port
+    putStrLn $ "+" ++ mconcat (replicate 65 "-") ++ "+"
+    putStrLn $ tableify ["METHOD", "STATUS", "PATH"]
+    putStrLn $ "+" ++ mconcat (replicate 65 "-") ++ "+"
+    migrate <- getMigrate
+    if migrate then
+        doMigration
     else do
-      cliState <- getCliState
-      if cliState
-        then do
-          forkIO $ run port app
-          repl
+        cliState <- getCliState
+        if cliState then do
+            forkIO $ run port app
+            repl
         else run port app
diff --git a/app/Pages/Admin/Admin.hs b/app/Pages/Admin/Admin.hs
index 9fb0ad3..7dee943 100644
--- a/app/Pages/Admin/Admin.hs
+++ b/app/Pages/Admin/Admin.hs
@@ -10,15 +10,13 @@ import Page (Page, PageSetting (Description, Route), getArgs)
 import Text.Blaze.Html (Html)
 
 nameRow :: [String] -> Html
-nameRow names =
-  [hsx|
+nameRow names = [hsx|
     <tr>
         {mconcat $ map element names}
     </tr>
 |]
- where
-  element name =
-    [hsx|
+    where
+        element name = [hsx|
             <th class="common-table-element" style="color: red;">
                 {name}
             </th>
@@ -26,18 +24,16 @@ nameRow names =
 
 visitsTable :: IO Html
 visitsTable = do
-  rows <- getVisits
-  return
-    [hsx|
+    rows <- getVisits
+    return [hsx|
         <h2>Visits</h2>
         <table class="common-table">
             {nameRow ["id", "timestamp", "uuid"]}
             {mconcat $ map makeRow rows}
         </table>
     |]
- where
-  makeRow (Visit id timestamp uuid) =
-    [hsx|
+    where
+        makeRow (Visit id timestamp uuid) = [hsx|
             <tr class="common-table-row">
                 <th class="common-table-element">{id}</th>
                 <th class="common-table-element">{timestamp}</th>
@@ -47,18 +43,16 @@ visitsTable = do
 
 guestbookTable :: IO Html
 guestbookTable = do
-  rows <- getGuestbookEntries
-  return
-    [hsx|
+    rows <- getGuestbookEntries
+    return [hsx|
         <h2>Guestbook</h2>
         <table class="common-table">
             {nameRow ["id", "timestamp", "name", "content", "parentId"]}
             {mconcat $ map makeRow rows}
         </table>
     |]
- where
-  makeRow (GuestbookEntry id timestamp name content parent) =
-    [hsx|
+    where
+        makeRow (GuestbookEntry id timestamp name content parent) = [hsx|
             <tr class="common-table-row">
                 <th class="common-table-element">{id}</th>
                 <th class="common-table-element">{timestamp}</th>
@@ -70,18 +64,16 @@ guestbookTable = do
 
 snakeTable :: IO Html
 snakeTable = do
-  rows <- getLeaderboard
-  return
-    [hsx|
+    rows <- getLeaderboard
+    return [hsx|
         <h2>Snake Leaderboard</h2>
         <table class="common-table">
             {nameRow ["id", "timestamp", "name", "score", "speed", "fruits"]}
             {mconcat $ map makeRow rows}
         </table>
     |]
- where
-  makeRow (Snake id timestamp name score speed fruits) =
-    [hsx|
+    where
+        makeRow (Snake id timestamp name score speed fruits) = [hsx|
             <tr class="common-table-row">
                 <th class="common-table-element">{id}</th>
                 <th class="common-table-element">{timestamp}</th>
@@ -94,18 +86,16 @@ snakeTable = do
 
 usersTable :: IO Html
 usersTable = do
-  rows <- getUsers
-  return
-    [hsx|
+    rows <- getUsers
+    return [hsx|
         <h2>Users</h2>
         <table class="common-table">
             {nameRow ["id", "username", "password"]}
             {mconcat $ map makeRow rows}
         </table>
     |]
- where
-  makeRow (User id username password) =
-    [hsx|
+    where
+        makeRow (User id username password) = [hsx|
             <tr class="common-table-row">
                 <th class="common-table-element">{id}</th>
                 <th class="common-table-element">{username}</th>
@@ -115,18 +105,16 @@ usersTable = do
 
 validTokensTable :: IO Html
 validTokensTable = do
-  rows <- getTokens
-  return
-    [hsx|
+    rows <- getTokens
+    return [hsx|
         <h2>Valid Tokens</h2>
         <table class="common-table">
             {nameRow ["id", "token", "username"]}
             {mconcat $ map makeRow rows}
         </table>
     |]
- where
-  makeRow (Token id token username) =
-    [hsx|
+    where
+        makeRow (Token id token username) = [hsx|
             <tr class="common-table-row">
                 <th class="common-table-element">{id}</th>
                 <th class="common-table-element">{token}</th>
@@ -136,43 +124,40 @@ validTokensTable = do
 
 page :: [String] -> IO Html
 page ["summary", token] = do
-  validity <- validateToken token
-  if validity
-    then do
-      username <- tokenToUsername token
-      return
-        [hsx|
+    validity <- validateToken token
+    if validity then do
+        username <- tokenToUsername token
+        return [hsx|
             <h1>Welcome {username}!</h1>
             Schema:
-            {codeBlock "txt" prettyPrintSchema}
-            <h2>Database tables</h2>
-            <a href={"/admin/dump/visits/"++token}>Visits</a><br>
-            <a href={"/admin/dump/guestbook/"++token}>Guestbook</a><br>
-            <a href={"/admin/dump/snake/"++token}>Snake</a><br>
-            <a href={"/admin/dump/users/"++token}>Users</a><br>
-            <a href={"/admin/dump/tokens/"++token}>Valid tokens</a><br>
-            <a href={"/admin/dump/all/"++token}>All</a>
+                {codeBlock "txt" prettyPrintSchema}
+                <h2>Database tables</h2>
+                <a href={"/admin/dump/visits/"++token}>Visits</a><br>
+                <a href={"/admin/dump/guestbook/"++token}>Guestbook</a><br>
+                <a href={"/admin/dump/snake/"++token}>Snake</a><br>
+                <a href={"/admin/dump/users/"++token}>Users</a><br>
+                <a href={"/admin/dump/tokens/"++token}>Valid tokens</a><br>
+                <a href={"/admin/dump/all/"++token}>All</a>
         |]
     else
-      page []
+        page []
 page ["dump", table, token] = do
-  validity <- validateToken token
-  if validity
-    then showTable table
+    validity <- validateToken token
+    if validity then 
+        showTable table
     else
-      page []
- where
-  showTable "visits" = visitsTable
-  showTable "guestbook" = guestbookTable
-  showTable "snake" = snakeTable
-  showTable "users" = usersTable
-  showTable "tokens" = validTokensTable
-  showTable "all" = mconcat [visitsTable, guestbookTable, snakeTable, usersTable, validTokensTable]
-  showTable _ = [hsx||]
+        page []
+    where
+        showTable "visits" = visitsTable
+        showTable "guestbook" = guestbookTable
+        showTable "snake" = snakeTable
+        showTable "users" = usersTable
+        showTable "tokens" = validTokensTable
+        showTable "all" = mconcat [visitsTable, guestbookTable, snakeTable, usersTable, validTokensTable]
+        showTable _ = [hsx||]
 page x = do
-  print x
-  return
-    [hsx|
+    print x
+    return [hsx|
         <script>
             function login() {
                 var username = document.getElementById("username").value
@@ -209,15 +194,13 @@ page x = do
     |]
 
 settings :: [PageSetting]
-settings =
-  [ Route "/admin"
-  , Description "Database Admin panel"
-  ]
+settings = [ 
+    Route "/admin",
+    Description "Database Admin panel"
+    ]
 
 admin :: Page
-admin =
-  ( settings
-  , \req -> do
-      let (_ : xs) = getArgs req
-      layout <$> page xs
-  )
+admin = (settings, \req -> do
+    let (_ : xs) = getArgs req
+    layout <$> page xs
+    )
diff --git a/app/Pages/Contact/Contact.hs b/app/Pages/Contact/Contact.hs
index fdc3522..f491ace 100644
--- a/app/Pages/Contact/Contact.hs
+++ b/app/Pages/Contact/Contact.hs
@@ -8,17 +8,16 @@ import Page (Page, PageSetting (Description, EmbedImage, EmbedText, Route))
 import Utils (linkImage, row)
 
 rows :: [Html]
-rows =
-  [ row [[hsx|Type|], [hsx|Address|]]
-  , row [[hsx|Email|], [hsx|<a href="mailto://mast3r@skade.dev">mast3r@skade.dev</a>|]]
-  , row [[hsx|University Email|], [hsx|<a href="mailto://tjen19@student.aau.dk">tjen19@student.aau.dk</a>|]]
-  , row [[hsx|Matrix|], [hsx|@mast3r:skade.dev|]]
-  , row [[hsx|Discord|], [hsx|mast3r_waf1z|]]
-  ]
+rows = [ 
+    row [[hsx|Type|], [hsx|Address|]], 
+    row [[hsx|Email|], [hsx|<a href="mailto://mast3r@skade.dev">mast3r@skade.dev</a>|]], 
+    row [[hsx|University Email|], [hsx|<a href="mailto://tjen19@student.aau.dk">tjen19@student.aau.dk</a>|]], 
+    row [[hsx|Matrix|], [hsx|@mast3r:skade.dev|]], 
+    row [[hsx|Discord|], [hsx|mast3r_waf1z|]]
+    ]
 
 page :: Html
-page =
-  [hsx|
+page = [hsx|
     <h1>Contact me</h1>
         Here's my various contact addresses
         <br>
@@ -40,12 +39,12 @@ page =
 |]
 
 settings :: [PageSetting]
-settings =
-  [ Route "/contact"
-  , EmbedText "Skademaskinen - Contact me"
-  , EmbedImage "/static/icon.png"
-  , Description "My contact information, and where to find me"
-  ]
+settings = [
+    Route "/contact", 
+    EmbedText "Skademaskinen - Contact me", 
+    EmbedImage "/static/icon.png", 
+    Description "My contact information, and where to find me"
+    ]
 
 contact :: Page
 contact = (settings, const $ return $ layout page)
diff --git a/app/Pages/Guestbook/Guestbook.hs b/app/Pages/Guestbook/Guestbook.hs
index de82aa0..24d34f2 100644
--- a/app/Pages/Guestbook/Guestbook.hs
+++ b/app/Pages/Guestbook/Guestbook.hs
@@ -21,43 +21,38 @@ toPosix :: Int -> POSIXTime
 toPosix n = read (show n ++ "s") :: POSIXTime
 
 prettifyGuestbook :: [Tree GuestbookEntry] -> Html
-prettifyGuestbook ((Tree (GuestbookEntry id timestamp name content parent) children) : xs) =
-  mconcat
-    [ section
-        [hsx|
-    <h3>{name} said: </h3>
-    Posted: <span style="color: #ff0000">{formatTime defaultTimeLocale "%c" $ posixSecondsToUTCTime (toPosix timestamp)}</span>
-    <br>
-    <div style="background-color: #111111; border: 1px solid #111111; border-radius: 5px; padding: 10px;">
-        <table>
-            <tr>
-                <th style="background-color: #303030; width: 2px;"></th>
-                <th>
-                    <div style="white-space: pre;">
-                    {content}
-                    </div>
-                </th>
-            </tr>
-        </table>
-    </div>
-    {prettifyGuestbook $ children} 
-    {guestbookInput id True}
-    <br><br>
-|]
-    , prettifyGuestbook xs
+prettifyGuestbook ((Tree (GuestbookEntry id timestamp name content parent) children) : xs) = mconcat [
+    section [hsx|
+        <h3>{name} said: </h3>
+        Posted: <span style="color: #ff0000">{formatTime defaultTimeLocale "%c" $ posixSecondsToUTCTime (toPosix timestamp)}</span>
+        <br>
+        <div style="background-color: #111111; border: 1px solid #111111; border-radius: 5px; padding: 10px;">
+            <table>
+                <tr>
+                    <th style="background-color: #303030; width: 2px;"></th>
+                    <th>
+                        <div style="white-space: pre;">
+                        {content}
+                        </div>
+                    </th>
+                </tr>
+            </table>
+        </div>
+        {prettifyGuestbook $ children} 
+        {guestbookInput id True}
+        <br><br>
+    |], prettifyGuestbook xs
     ]
 prettifyGuestbook [] = [hsx||]
 
 guestbookInput :: Int -> Bool -> Html
-guestbookInput parent False =
-  [hsx|
+guestbookInput parent False = [hsx|
     <textarea class="guestbook-text" id={"guestbook-text::"++show parent} type="text"></textarea>
     <br>
     Name: <input id={"guestbook-name::"++show parent} class="guestbook-name" type="text">
     <button id={show parent} onclick="post(this.id)">Post</button>
 |]
-guestbookInput parent True =
-  [hsx|
+guestbookInput parent True = [hsx|
     <button id={show parent} onclick="guestbookToggleInput(this.id)">New reply</button>
     <br>
     <div style="display:none;" id={"guestbook-reply::"++show parent}>
@@ -66,9 +61,8 @@ guestbookInput parent True =
 |]
 
 page = do
-  guestbook <- getGuestbook
-  return
-    [hsx|
+    guestbook <- getGuestbook
+    return [hsx|
         <script>
             function guestbookToggleInput(id) {
                 var reply = document.getElementById("guestbook-reply::"+id)
@@ -109,10 +103,10 @@ page = do
     |]
 
 settings :: [PageSetting]
-settings =
-  [ Route "/guestbook"
-  , Description "A Guestbook where you can send me a message"
-  ]
+settings = [
+    Route "/guestbook", 
+    Description "A Guestbook where you can send me a message"
+    ]
 
 guestbook :: Page
 guestbook = (settings, const $ layout <$> page)
diff --git a/app/Pages/Pages.hs b/app/Pages/Pages.hs
index 15ed844..a691339 100644
--- a/app/Pages/Pages.hs
+++ b/app/Pages/Pages.hs
@@ -26,35 +26,32 @@ import Text.Blaze.Html.Renderer.String (renderHtml)
 import Text.Regex (Regex, matchRegex, mkRegex)
 
 page404 :: [String] -> Html
-page404 args =
-  layout
-    [hsx|
+page404 args = layout [hsx|
     <h1>404 - Page not found</h1><br>
     params: {args}
 |]
 
 pages :: [Page]
-pages =
-  [ search pages
-  , admin
-  , contact
-  , sources
-  , guestbook
-  , projects
-  , leaderboard
-  , testPage
-  , index
-  ]
+pages = [ 
+    search pages,
+    admin,
+    contact,
+    sources,
+    guestbook,
+    projects,
+    leaderboard,
+    testPage,
+    index
+    ]
 
 findPage :: String -> Page
-findPage addr = case find
-  ( \(settings, _) -> case do
-      if route settings == "/" && addr /= "/"
-        then Nothing
+findPage addr = case find (_findPage addr) pages of
+    (Just page) -> page
+    Nothing -> ([], \req -> return $ page404 (map unpack $ pathInfo req))
+    where
+        _findPage :: String -> Page -> Bool
+        _findPage addr (settings, _) = case if route settings == "/" && addr /= "/" then
+            Nothing
         else matchRegex (mkRegex (route settings)) addr of
-      Nothing -> False
-      _ -> True
-  )
-  pages of
-  (Just page) -> page
-  Nothing -> ([], \req -> return $ page404 (map unpack $ pathInfo req))
+            Nothing -> False
+            _ -> True
diff --git a/app/Pages/Projects/Brainfuck.hs b/app/Pages/Projects/Brainfuck.hs
index 1020a40..f59c8b8 100644
--- a/app/Pages/Projects/Brainfuck.hs
+++ b/app/Pages/Projects/Brainfuck.hs
@@ -7,34 +7,31 @@ import Text.Blaze.Html (Html)
 import CodeBlock (codeBlock)
 
 convertSymbols :: String -> String
-convertSymbols ('+' : xs) = "(*ptr)++;\n" ++ convertSymbols xs
-convertSymbols ('-' : xs) = "(*ptr)--;\n" ++ convertSymbols xs
-convertSymbols ('>' : xs) = "ptr++;\n" ++ convertSymbols xs
-convertSymbols ('<' : xs) = "ptr--;\n" ++ convertSymbols xs
-convertSymbols ('[' : xs) = "while(*ptr) {\n" ++ convertSymbols xs
-convertSymbols (']' : xs) = "}\n" ++ convertSymbols xs
-convertSymbols ('.' : xs) = "printf(\"%c\", (*ptr));\n" ++ convertSymbols xs
-convertSymbols (',' : xs) = "scanf(\"%c\", ptr);\n" ++ convertSymbols xs
+convertSymbols ('+':xs) = "(*ptr)++;\n" ++ convertSymbols xs
+convertSymbols ('-':xs) = "(*ptr)--;\n" ++ convertSymbols xs
+convertSymbols ('>':xs) = "ptr++;\n" ++ convertSymbols xs
+convertSymbols ('<':xs) = "ptr--;\n" ++ convertSymbols xs
+convertSymbols ('[':xs) = "while(*ptr) {\n" ++ convertSymbols xs
+convertSymbols (']':xs) = "}\n" ++ convertSymbols xs
+convertSymbols ('.':xs) = "printf(\"%c\", (*ptr));\n" ++ convertSymbols xs
+convertSymbols (',':xs) = "scanf(\"%c\", ptr);\n" ++ convertSymbols xs
 convertSymbols (x : xs) = convertSymbols xs
 convertSymbols [] = []
 
 code :: String -> String
-code input =
-  intercalate
-    "\n"
-    [ "#include <stdio.h>"
-    , "#include <stdint.h>"
-    , "#include <inttypes.h>"
-    , "char buffer[30000] = {0};"
-    , "char* ptr = buffer;"
-    , "int main () {"
-    , convertSymbols input
-    , "}"
+code input = intercalate "\n" [
+    "#include <stdio.h>",
+    "#include <stdint.h>",
+    "#include <inttypes.h>",
+    "char buffer[30000] = {0};",
+    "char* ptr = buffer;",
+    "int main () {",
+    convertSymbols input, 
+    "}"
     ]
 
 brainfuck :: Html
-brainfuck =
-  [hsx|
+brainfuck = [hsx|
     Write some brainfuck code, and you will receive the equivalent in C code.<br>
     <script>
         function download(file, text) {
diff --git a/app/Pages/Projects/Projects.hs b/app/Pages/Projects/Projects.hs
index ceea5c4..6c14f9e 100644
--- a/app/Pages/Projects/Projects.hs
+++ b/app/Pages/Projects/Projects.hs
@@ -18,203 +18,116 @@ import Layout (layout)
 import Page (Page, PageSetting (Description, Route), getArgs)
 
 defaultProject :: (String, Html)
-defaultProject =
-  ( ""
-  , section
-      [hsx|
+defaultProject = ("", section [hsx|
     Use the sidebar to find a project :)<br><br>
 
     This page is inspired by my friend Mohamad, his site is available below<br><br>
     <a href="https://mohamaddalal.github.io/">Mohamad's site</a>
-|]
-  )
+|])
 
 projectsTree :: Tree (String, Html)
-projectsTree =
-  Tree
-    defaultProject
-    [ Tree
-        ( "Semester Projects"
-        , section
-            [hsx|
+projectsTree = Tree defaultProject [
+    Tree ("Semester Projects", section [hsx|
         Here's all the projects i've done at Aalborg University, they're defined as Pn where n is the semester they were done at. for example, P6 and P10 is my bachelor and master's projects respectively.
-    |]
-        )
-        [ Tree
-            ( "P1"
-            , section
-                [hsx|
+    |]) [
+        Tree ("P1", section [hsx|
             P1 was about Random Linear Network Coding
             <br>
             It was cool
-        |]
-            )
-            []
-        , Tree
-            ( "P2"
-            , section
-                [hsx|
+        |])[], 
+        Tree ("P2", section [hsx|
             A Project about adaptive cruise control in cars
-        |]
-            )
-            []
-        , Tree
-            ( "P3"
-            , section
-                [hsx|
+        |]) [],
+        Tree ("P3", section [hsx|
             We made a satellite ground station to be full duplex, as the previous implementation could only send data one way at a time, would be cool to use two channels.
-        |]
-            )
-            []
-        , Tree
-            ( "P4"
-            , section
-                [hsx|
+        |]) [],
+        Tree ("P4", section [hsx|
             Detecting fires on a map, it wasn't particularly interesting.
-        |]
-            )
-            []
-        , Tree
-            ( "P5"
-            , section
-                [hsx|
+        |]) [],
+        Tree ("P5", section [hsx|
             Testing TCP performance using NS3, we learned a bit of C++, it was nice.
-        |]
-            )
-            []
-        , Tree
-            ( "P6"
-            , section
-                [hsx|
+        |]) [],
+        Tree ("P6", section [hsx|
             Modeling a testbed for edge nodes for measurement in real world scenarios<br><br>
 
             It was a pretty interesting project, as we designed our own dataframe instead of using like HTTP, it made it very fast, but as could be read in our semester report, our system could be even faster if we optimized language and protocols. <br><br>
                 
             It would probably be beyond our expectations if we went and implemented our own solution at the data-link layer of networking instead of at the routing layer (or whatever its called again in TCP/IP)
-        |]
-            )
-            []
-        , Tree
-            ( "P7"
-            , section
-                [hsx|
+        |])[], 
+        Tree ("P7", section [hsx|
             The semester we learned haskell! Honestly i think i spent more time in my free time in total on haskell than i did thinking about this project. The project was about measuring the amount of people in a room using IoT devices and bluetooth.<br><br>
                 
             The coolest part of this project was definitely with fidding with low-level promisquous mode on an IoT device.
-        |]
-            )
-            []
-        , Tree
-            ( "P8"
-            , section
-                [hsx|
+        |]) [], 
+        Tree ("P8", section [hsx|
             This was a project about conducting a user-study, measuring people's stress and questioning them through an app on a mobile phone.
             <br>
             (this project was very, very bad imo, but i learned more C++)
-        |]
-            )
-            []
-        ]
-    , Tree
-        ( "Personal Projects"
-        , section
-            [hsx|
+        |]) []
+    ], Tree ("Personal Projects", section [hsx|
         I find it fun coding in my free time, i do it a lot and as such this website was also born!
-    |]
-        )
-        [ Tree ("Snake", snake) []
-        , Tree ("Brainfuck Transpiler", brainfuck) []
-        , Tree
-            ( "Website"
-            , mconcat
-                [ section
-                    [hsx|
-            <div style="max-width: 100%">
-                Written in Haskell using IHP-HSX as the primary library, and sqlite-simple as the database implementation.<br>
-
-                The database is actually pretty cool, its implemented as a list of table objects, and since i'm writing html directly inside my haskell code i can easily print the database structure inline here:<br><br>
-                {codeBlock "txt" $ show defs}
-                Its not particularly nice looking in this way, so i'll print it properly below :P
-                {codeBlock "txt" prettyPrintSchema}<br>
-                Still in haskell, but the beauty of haskell is that stuff like that is a short oneliner<br><br>
-
-                <span style="color: red">DISCLAIMER:</span> there might be extra tables in this list that shows up without a corresponding feature, i am actually generating it on the fly.
-
-                <br><br>
-                This page about projects is actually also pretty cool, its defined as a tree data structure, so i can also easily print it:
-                {codeBlock "haskell" $ show (Tree ("projects", "<html>") [Tree ("page2", "<html>") [], Tree ("page3", "<html>") [], Tree ("page4", "<html>") []])}
-                <h2>Versions</h2>
-                In the sidebar, or below you can choose to read about each version of this website.
-            </div>
-        |]
-                , [hsx|<h3>Version 1</h3>|]
-                , snd (findItem ["", "Personal Projects", "Website", "Version 1"] projectsTree)
-                , [hsx|<h3>Version 2</h3>|]
-                , snd (findItem ["", "Personal Projects", "Website", "Version 2"] projectsTree)
-                , [hsx|<h3>Version 3</h3>|]
-                , snd (findItem ["", "Personal Projects", "Website", "Version 3"] projectsTree)
-                , [hsx|<h3>Version 4</h3>|]
-                , snd (findItem ["", "Personal Projects", "Website", "Version 4"] projectsTree)
-                ]
-            )
-            [ Tree
-                ( "Version 1"
-                , section
-                    [hsx|
+    |]) [
+        Tree ("Snake", snake) [], 
+        Tree ("Brainfuck Transpiler", brainfuck) [],
+        Tree ("Website", mconcat [
+            section [hsx|
+                <div style="max-width: 100%">
+                    Written in Haskell using IHP-HSX as the primary library, and sqlite-simple as the database implementation.<br>
+
+                    The database is actually pretty cool, its implemented as a list of table objects, and since i'm writing html directly inside my haskell code i can easily print the database structure inline here:<br><br>
+                    {codeBlock "txt" $ show defs}
+                    Its not particularly nice looking in this way, so i'll print it properly below :P
+                    {codeBlock "txt" prettyPrintSchema}<br>
+                    Still in haskell, but the beauty of haskell is that stuff like that is a short oneliner<br><br>
+
+                    <span style="color: red">DISCLAIMER:</span> there might be extra tables in this list that shows up without a corresponding feature, i am actually generating it on the fly.
+
+                    <br><br>
+                    This page about projects is actually also pretty cool, its defined as a tree data structure, so i can also easily print it:
+                    {codeBlock "haskell" $ show (Tree ("projects", "<html>") [Tree ("page2", "<html>") [], Tree ("page3", "<html>") [], Tree ("page4", "<html>") []])}
+                    <h2>Versions</h2>
+                    In the sidebar, or below you can choose to read about each version of this website.
+                </div>
+            |], 
+            [hsx|<h3>Version 1</h3>|],
+            snd (findItem ["", "Personal Projects", "Website", "Version 1"] projectsTree),
+            [hsx|<h3>Version 2</h3>|],
+            snd (findItem ["", "Personal Projects", "Website", "Version 2"] projectsTree),
+            [hsx|<h3>Version 3</h3>|],
+            snd (findItem ["", "Personal Projects", "Website", "Version 3"] projectsTree),
+            [hsx|<h3>Version 4</h3>|],
+            snd (findItem ["", "Personal Projects", "Website", "Version 4"] projectsTree)
+        ]) [
+            Tree ("Version 1", section [hsx|
                 Was written on github pages using markdown<br>
                 barely had any content.
-            |]
-                )
-                []
-            , Tree
-                ( "Version 2"
-                , section
-                    [hsx|
+            |]) [],
+            Tree ("Version 2", section [hsx|
                 Was written in html, css and javascript, had a lot of client side javascript and is still available at <a href="https://about.skademaskinen.win">https://about.skademaskinen.win</a><br>
                 The guestbook and the interests page was my main goal and i finished both of them.<br>
                 Source code is available at <a href="https://github.com/Skademaskinen/Frontend">https://github.com/Skademaskinen/Frontend</a><br>
                 <br>
                 Additionally as there was non-static elements on this website, i needed an external backend that took http requests as well, this worked pretty well, and it circumvented that the server it was hosted on didn't have full port access. (it took HTTP on port 11034) with the actual website being served from github pages. The backend was written in python and the source code is available at <a href="https://github.com/Skademaskinen/Backend">https://github.com/Skademaskinen/Backend</a>
-            |]
-                )
-                []
-            , Tree
-                ( "Version 3"
-                , section
-                    [hsx|
+            |]) [],
+            Tree ("Version 3", section [hsx|
                 This was written in haskell using the full IHP framework, it was a lot of framework to code around compared to the older sites, ofc this made it possible to write more functionality with less code, but with such a feature also comes a lot of restrictions, such as the database being very hard to implement, and dependencies being less easily managed and coding an API using raw HTTP was very restrictive. hence version 4.<br>
                 Source code is available at <a href="https://github.com/Skademaskinen/F3">https://github.com/Skademaskinen/F3</a>
-            |]
-                )
-                []
-            , Tree
-                ( "Version 4"
-                , section
-                    [hsx|
+            |]) [],
+            Tree ("Version 4", section [hsx|
                 This version is also written in haskell, but this time also using Warp directly to translate HSX to blaze and parse blaze to a bytestring. Its this current site and doesn't require a link :P<br>
                 Source code is available at <a href="https://github.com/Mast3rwaf1z/homepage">https://github.com/Mast3rwaf1z/homepage</a>
                 <br>
                 The best feature of this rewrite is that i've combined the backend and the frontend into one, and since HSX allows me to put IO code directly inline with my html, i can access the database directly instead of the frontend sending a million HTTP requests. This means that the website is A LOT faster than the first few iterations, and instead of a lot of content loading at different times, its all loaded at once at the server side, with as little javascript as possible.
-            |]
-                )
-                []
-            ]
-        , Tree
-            ( "Skademaskinen"
-            , section
-                [hsx|
+            |]) []
+        ],
+        Tree ("Skademaskinen", section [hsx|
             This is about my server, it hosts a lot of things, but the things accessible from HTTP is available at:
             <br>
             <div style="text-align:center;">
                 {services}
             </div>
-        |]
-            )
-            []
-        , Tree
-            ( "Discord bots"
-            , section
-                [hsx|
+        |]) [],
+        Tree ("Discord bots", section [hsx|
             I have written a few bots for discord, all of them were in Java using the dv8tion JDA (java bindings for the discord API). The first version was Mør Bot. It provided commands before slash commands that could play music from youtube and soundcloud, attached an emote to random messages, and showed a leaderboard for these emotes. It also allowed for setting roles.
             <br>
             <a href="https://github.com/Mast3rwaf1z/Moer-bot">https://github.com/Mast3rwaf1z/Moer-bot</a>
@@ -228,48 +141,37 @@ projectsTree =
             Additionally it was written with a lot more tests and proper CI, to make sure it computes word counts and stuff correctly.
             <br>
             <a href="https://github.com/Skademaskinen/rp-utils">https://github.com/Skademaskinen/rp-utils</a>
-        |]
-            )
-            []
-        ]
+        |]) []
+    ]
     ]
 
 services :: Html
-services =
-  mconcat $
-    map
-      ( \(name, d) ->
-          [hsx|
+services = mconcat $ map (\(name, d) -> [hsx|
     <button id={d} onclick="go_to(this.id)">{name}</button>
-|]
-      )
-      srv
- where
-  srv :: [(String, String)]
-  srv = [("Nextcloud", "cloud"), ("Jupyter", "jupyter"), ("Matrix", "matrix"), ("Website", "api"), ("Taoshi", "taoshi")]
+|]) srv
+    where
+        srv :: [(String, String)]
+        srv = [("Nextcloud", "cloud"), ("Jupyter", "jupyter"), ("Matrix", "matrix"), ("Website", "api"), ("Taoshi", "taoshi")]
 
 makeIndent :: Int -> Html
 makeIndent n = forEach [0 .. n] (\_ -> [hsx|&emsp;|])
 
 buildSidebarSection :: [Tree (String, Html)] -> Int -> String -> Html
-buildSidebarSection (x : xs) indent path =
-  [hsx|
+buildSidebarSection (x : xs) indent path = [hsx|
     {buildSidebarItem x indent path}
     {buildSidebarSection xs indent path}
 |]
 buildSidebarSection [] _ _ = [hsx||]
 
 buildSidebarItem :: Tree (String, Html) -> Int -> String -> Html
-buildSidebarItem (Tree (name, _) children) indent path =
-  [hsx|
+buildSidebarItem (Tree (name, _) children) indent path = [hsx|
     {makeIndent indent}<a href={"/projects/"++path++name}>{name}</a>
     <br>
     {buildSidebarSection children (indent+1) (path++name++"/")}
 |]
 
 sidebar :: Html
-sidebar =
-  [hsx|
+sidebar = [hsx|
     <div style="background-color: #111111; border: 1px solid #ff5500; border-radius: 5px;text-align: left;">
         {buildSidebarItem projectsTree (-1) ""}
         <br>
@@ -279,29 +181,27 @@ sidebar =
 findItem_ :: [String] -> Tree (String, Html) -> Tree (String, Html)
 findItem_ [] _ = return defaultProject
 findItem_ [target] tree = do
-  (name, html) <- tree
-  if name == target
-    then
-      return (name, html)
+    (name, html) <- tree
+    if name == target then
+        return (name, html)
     else
-      return defaultProject
+        return defaultProject
 findItem_ (target : xs) (Tree value children) = do
-  (name, html) <- Tree value children
-  if name == target
-    then case find (\(x, _) -> x /= fst defaultProject) $ map (findItem xs) children of
-      Nothing -> return defaultProject
-      (Just result) -> return result
+    (name, html) <- Tree value children
+    if name == target then 
+        case find (\(x, _) -> x /= fst defaultProject) $ map (findItem xs) children of
+            Nothing -> return defaultProject
+            (Just result) -> return result
     else
-      return defaultProject
+        return defaultProject
 
 findItem :: [String] -> Tree (String, Html) -> (String, Html)
 findItem target tree = result
- where
-  (Tree result _) = findItem_ target tree
+    where
+        (Tree result _) = findItem_ target tree
 
 mainView :: [String] -> Html
-mainView target =
-  [hsx|
+mainView target = [hsx|
     <table style="width: 100%;">
         <tr>
             <th style="width:15%; text-align: left; vertical-align: top;line-height:30px;">{sidebar}</th>
@@ -312,26 +212,23 @@ mainView target =
         </tr>
     </table>
 |]
- where
-  (title, content) = findItem target projectsTree
+    where
+        (title, content) = findItem target projectsTree
 
-page target =
-  [hsx|
+page target = [hsx|
     <div style="width=100%;">
         {mainView target}
     </div>
 |]
 
 settings :: [PageSetting]
-settings =
-  [ Route "/projects"
-  , Description "List of all projects i have done"
-  ]
+settings = [
+    Route "/projects",
+    Description "List of all projects i have done"
+    ]
 
 projects :: Page
-projects =
-  ( settings
-  , \req -> do
-      let (_ : project) = getArgs req
-      return $ layout $ page project
-  )
+projects = (settings, \req -> do
+    let (_ : project) = getArgs req
+    return $ layout $ page project
+    )
diff --git a/app/Pages/Projects/Snake.hs b/app/Pages/Projects/Snake.hs
index 9b5b415..e8c4e02 100644
--- a/app/Pages/Projects/Snake.hs
+++ b/app/Pages/Projects/Snake.hs
@@ -10,14 +10,12 @@ import Page (Page, PageSetting (Description, Route))
 import Utils (forEach)
 
 tile :: Int -> Html
-tile id =
-  [hsx|
+tile id = [hsx|
     <span class="tile" id={"tile-" ++ (show id)}></span>
 |]
 
 tileRow :: Int -> Html
-tileRow offset =
-  [hsx|
+tileRow offset = [hsx|
     <div>
         {forEach [(offset*20)..19+(offset*20)] tile}
     </div>
@@ -25,20 +23,17 @@ tileRow offset =
 |]
 
 grid :: Html
-grid =
-  [hsx|
+grid = [hsx|
     {forEach [0..19] tileRow}
 |]
 
 fire :: Int -> Html
-fire _ =
-  [hsx|
+fire _ = [hsx|
     <img src="/static/projects/fire.gif" width="50%">
 |]
 
 snake :: Html
-snake =
-  [hsx|
+snake = [hsx|
     <link rel="stylesheet" href="/static/projects/snake.css">
     <div style="text-align:center;">
         <div class="snake">
@@ -90,14 +85,12 @@ snake =
 |]
 
 leaderboardField :: String -> Html
-leaderboardField value =
-  [hsx|
+leaderboardField value = [hsx|
     <th style="width:100px">{value}</th>
 |]
 
 leaderboardEntry :: Snake -> Html
-leaderboardEntry (Snake id timestamp name score speed fruits) =
-  [hsx|
+leaderboardEntry (Snake id timestamp name score speed fruits) = [hsx|
     <tr>
         {mconcat $ map leaderboardField [name, show timestamp, show score, show speed, show fruits]}
     </tr>
@@ -105,9 +98,8 @@ leaderboardEntry (Snake id timestamp name score speed fruits) =
 
 page :: IO Html
 page = do
-  l <- getLeaderboard
-  return
-    [hsx|
+    l <- getLeaderboard
+    return [hsx|
         <table>
             <tr>
                 <th>Name</th>
@@ -121,10 +113,10 @@ page = do
     |]
 
 settings :: [PageSetting]
-settings =
-  [ Route "/snake-leaderboard"
-  , Description "Leaderboard of my snake project"
-  ]
+settings = [
+    Route "/snake-leaderboard",
+    Description "Leaderboard of my snake project"
+    ]
 
 leaderboard :: Page
 leaderboard = (settings, const $ layout <$> page)
diff --git a/app/Pages/Search/Search.hs b/app/Pages/Search/Search.hs
index 7f98add..08002a4 100644
--- a/app/Pages/Search/Search.hs
+++ b/app/Pages/Search/Search.hs
@@ -10,39 +10,35 @@ import Text.Regex (Regex, matchRegex, mkRegex)
 
 findPage :: [Page] -> Regex -> [(String, String)]
 findPage ((settings, _) : xs) regex = case matchRegex regex (route settings) of
-  Nothing -> findPage xs regex
-  _ -> (route settings, description settings) : findPage xs regex
+    Nothing -> findPage xs regex
+    _ -> (route settings, description settings) : findPage xs regex
 findPage [] _ = []
 
-page pages query =
-  [hsx|
+page pages query = [hsx|
     <h1>Search Results: [query={query}]</h1>
     {section $ makeResults 1 $ findPage pages $ mkRegex query}
 |]
- where
-  makeResults :: Int -> [(String, String)] -> Html
-  makeResults index ((x, description) : xs) =
-    [hsx|
+    where
+        makeResults :: Int -> [(String, String)] -> Html
+        makeResults index ((x, description) : xs) = [hsx|
             <h2>{index} - {title}</h2>
             <a href={x}>{x}</a>
             <p>{description}</p>
             <br>
             {makeResults (index+1) xs}
         |]
-   where
-    (_ : title) = x
-  makeResults _ [] = [hsx||]
+            where
+                (_ : title) = x
+        makeResults _ [] = [hsx||]
 
 settings :: [PageSetting]
-settings =
-  [ Route "/search"
-  , Description "Search for pages"
-  ]
+settings = [
+    Route "/search",
+    Description "Search for pages"
+    ]
 
 search :: [Page] -> Page
-search pages =
-  ( settings
-  , \req -> do
-      let [_, query] = getArgs req
-      return $ layout $ page pages query
-  )
+search pages = (settings, \req -> do
+    let [_, query] = getArgs req
+    return $ layout $ page pages query
+    )
diff --git a/app/Pages/Sources/Repo.hs b/app/Pages/Sources/Repo.hs
index 0aa952a..bc28d24 100644
--- a/app/Pages/Sources/Repo.hs
+++ b/app/Pages/Sources/Repo.hs
@@ -14,61 +14,48 @@ import Control.Applicative
 import Data.Text (Text)
 import qualified Data.Yaml as Yaml
 
-newtype Author = Author
-  { date :: Text
-  }
+newtype Author = Author { date :: Text }
 
-data Commit = Commit
-  { message :: Text
-  , author :: Author
-  }
+data Commit = Commit { message :: Text, author :: Author }
 
-data CommitData = CommitData
-  { url :: Text
-  , commit :: Commit
-  }
+data CommitData = CommitData { url :: Text, commit :: Commit }
 
 instance FromJSON CommitData where
-  parseJSON (Object v) =
-    CommitData
-      <$> v .: "html_url"
-      <*> v .: "commit"
-  parseJSON _ = empty
+    parseJSON (Object v) = CommitData
+        <$> v .: "html_url"
+        <*> v .: "commit"
+    parseJSON _ = empty
 
 instance FromJSON Commit where
-  parseJSON (Object v) =
-    Commit
-      <$> v .: "message"
-      <*> v .: "author"
-  parseJSON _ = empty
+    parseJSON (Object v) = Commit
+        <$> v .: "message"
+        <*> v .: "author"
+    parseJSON _ = empty
 
 instance FromJSON Author where
-  parseJSON (Object v) =
-    Author
-      <$> v .: "date"
-  parseJSON _ = empty
+    parseJSON (Object v) = Author
+        <$> v .: "date"
+    parseJSON _ = empty
 
 get :: IO [CommitData]
 get = do
-  initialRequest <- parseRequest "https://api.github.com/repos/Mast3rwaf1z/homepage/commits"
-  let request = initialRequest{method = "GET", requestHeaders = [("User-Agent", "Website")]}
-  response <- httpJSON request
-  return (getResponseBody response :: [CommitData])
+    initialRequest <- parseRequest "https://api.github.com/repos/Mast3rwaf1z/homepage/commits"
+    let request = initialRequest{method = "GET", requestHeaders = [("User-Agent", "Website")]}
+    response <- httpJSON request
+    return (getResponseBody response :: [CommitData])
 
 repo :: IO Html
 repo = do
-  result <- handleCommits <$> get
-  return
-    [hsx|
-            <hr>
-            Commit History:<br>
-            <table style="display:inline-block;border:1px solid white; padding:5px; overflow-y: scroll; max-height: 500px;">
-            {result}
-            </table>
-        |]
- where
-  handleCommits ((CommitData url (Commit message (Author date))) : xs) =
-    [hsx|
+    result <- handleCommits <$> get
+    return [hsx|
+        <hr>
+        Commit History:<br>
+        <table style="display:inline-block;border:1px solid white; padding:5px; overflow-y: scroll; max-height: 500px;">
+        {result}
+        </table>
+    |]
+    where
+        handleCommits ((CommitData url (Commit message (Author date))) : xs) = [hsx|
             <tr>
                 <th style="width:500px; height: 50px;">
                     <a href={url}>{message}</a>
@@ -79,4 +66,4 @@ repo = do
             </tr>
             {handleCommits xs}
         |]
-  handleCommits [] = [hsx||]
+        handleCommits [] = [hsx||]
diff --git a/app/Pages/Sources/Sources.hs b/app/Pages/Sources/Sources.hs
index 7aeb75b..d2ff115 100644
--- a/app/Pages/Sources/Sources.hs
+++ b/app/Pages/Sources/Sources.hs
@@ -10,29 +10,28 @@ import Utils (linkImage)
 
 page :: IO Html
 page = do
-  commitHistory <- repo
-  return
-    [hsx|
-    <h2 style="text-align:center;">Sources</h2>
-    <div class="section" style="text-align:center;">
-        This website is written using the following software:<br>
-        {linkImage "IHP" "https://ihp.digitallyinduced.com/ihp.svg" "https://ihp.digitallyinduced.com/"}
-        {linkImage "Haskell" "https://wiki.haskell.org/wikiupload/4/4a/HaskellLogoStyPreview-1.png" "https://haskell.org"}
-        {linkImage "Nix" "https://raw.githubusercontent.com/NixOS/nixos-artwork/53ea652ec7d8af5d21fd2b79b6c49cb39078ddfb/logo/nix-snowflake-colours.svg" "https://nixos.org"}
-        <br>
-        Source code: <a href="https://github.com/Mast3rwaf1z/homepage">
-            <img src="/static/github.svg" height="20">
-        </a>
-        <br>
-        {commitHistory}
-    </div>
-|]
+    commitHistory <- repo
+    return [hsx|
+        <h2 style="text-align:center;">Sources</h2>
+        <div class="section" style="text-align:center;">
+            This website is written using the following software:<br>
+            {linkImage "IHP" "https://ihp.digitallyinduced.com/ihp.svg" "https://ihp.digitallyinduced.com/"}
+            {linkImage "Haskell" "https://wiki.haskell.org/wikiupload/4/4a/HaskellLogoStyPreview-1.png" "https://haskell.org"}
+            {linkImage "Nix" "https://raw.githubusercontent.com/NixOS/nixos-artwork/53ea652ec7d8af5d21fd2b79b6c49cb39078ddfb/logo/nix-snowflake-colours.svg" "https://nixos.org"}
+            <br>
+            Source code: <a href="https://github.com/Mast3rwaf1z/homepage">
+                <img src="/static/github.svg" height="20">
+            </a>
+            <br>
+            {commitHistory}
+        </div>
+    |]
 
 settings :: [PageSetting]
-settings =
-  [ Route "/sources"
-  , Description "Sources for this website and my source code"
-  ]
+settings = [
+    Route "/sources",
+    Description "Sources for this website and my source code"
+    ]
 
 sources :: Page
 sources = (settings, const $ layout <$> page)
diff --git a/lib/CodeBlock.hs b/lib/CodeBlock.hs
index b3e486b..2698352 100644
--- a/lib/CodeBlock.hs
+++ b/lib/CodeBlock.hs
@@ -4,8 +4,7 @@ import IHP.HSX.QQ (hsx)
 import Text.Blaze.Html (Html)
 
 codeBlock :: String -> String -> Html
-codeBlock language code =
-  [hsx|
+codeBlock language code = [hsx|
     <pre>
         <code class={"language-" ++ language}>
             {code}
@@ -15,42 +14,26 @@ codeBlock language code =
 |]
 
 hsxIntroCodeBlock :: Html
-hsxIntroCodeBlock =
-  codeBlock "haskell" $
-    mconcat
-      [ "view :: Html\n"
-      , "view = "
-      , rB
-      , "hsx"
-      , vl
-      , "\n"
-      , "\t<span>Hello, </span>\n"
-      , vl
-      , lB
-      , "\n\n"
-      , "index :: Html\n"
-      , "index = "
-      , rB
-      , "hsx"
-      , vl
-      , "\n"
-      , "\t{view}\n"
-      , "\t<span>World!</span>\n"
-      , vl
-      , lB
-      ]
+hsxIntroCodeBlock = codeBlock "haskell" $ mconcat [
+    "view :: Html\n", 
+    "view = ", rB, "hsx", vl, "\n", 
+    "\t<span>Hello, </span>\n",
+    vl, lB, "\n\n", 
+    "index :: Html\n",
+    "index = ", rB, "hsx", vl, "\n",
+    "\t{view}\n",
+    "\t<span>World!</span>\n",
+    vl, lB
+    ]
 
 introCodeView :: Html
-introCodeView =
-  [hsx|
+introCodeView = [hsx|
     <span>Hello, </span>
 |]
 introCodeIndex :: Html
-introCodeIndex =
-  [hsx|
+introCodeIndex = [hsx|
     {introCodeView}
     <span>World!</span>
-
 |]
 
 rB :: String
@@ -61,8 +44,7 @@ vl :: String
 vl = "|"
 
 wrapHsxCode :: Html -> Html
-wrapHsxCode code =
-  [hsx|
+wrapHsxCode code = [hsx|
     {rB}hsx{vl}
         {code}
     {vl}{lB}
diff --git a/lib/Database/Database.hs b/lib/Database/Database.hs
index 04336a3..3407468 100644
--- a/lib/Database/Database.hs
+++ b/lib/Database/Database.hs
@@ -19,18 +19,14 @@ import Tree (Tree (Tree))
 
 connectInfo :: IO ConnectInfo
 connectInfo = do
-  db <- getDatabaseName
-  user <- getDatabaseUser
-  return
-    defaultConnectInfo
-      { connectDatabase = db
-      , connectUser = user
-      }
+    db <- getDatabaseName
+    user <- getDatabaseUser
+    return defaultConnectInfo { connectDatabase = db, connectUser = user }
 
 runDb :: SqlPersistT (NoLoggingT IO) a -> IO a
 runDb cmd = do
-  info <- connectInfo
-  runNoLoggingT . withMySQLConn info . runSqlConn $ cmd
+    info <- connectInfo
+    runNoLoggingT . withMySQLConn info . runSqlConn $ cmd
 
 doMigration :: IO ()
 doMigration = runDb $ runMigration migrateAll
@@ -43,72 +39,61 @@ guestbookToTree entries targetParent = [Tree (GuestbookEntry id timestamp name c
 
 getVisits :: IO [Visit]
 getVisits = do
-  visits <- runDb $ selectList [] []
-  return $ map (\(Entity _ u) -> u) visits
+    visits <- runDb $ selectList [] []
+    return $ map (\(Entity _ u) -> u) visits
 
 getGuestbook :: IO [Tree GuestbookEntry]
 getGuestbook = do
-  entries <- runDb $ selectList [] [] :: IO [Entity GuestbookEntry]
-  return $ guestbookToTree (map (\(Entity _ entry) -> entry) entries) (-1)
+    entries <- runDb $ selectList [] [] :: IO [Entity GuestbookEntry]
+    return $ guestbookToTree (map (\(Entity _ entry) -> entry) entries) (-1)
 
 getGuestbookEntries :: IO [GuestbookEntry]
 getGuestbookEntries = do
-  entries <- runDb $ selectList [] []
-  return $ map (\(Entity _ e) -> e) entries
+    entries <- runDb $ selectList [] []
+    return $ map (\(Entity _ e) -> e) entries
 
 getLeaderboard :: IO [Snake]
 getLeaderboard = do
-  entries <- runDb $ selectList [] []
-  return $ map (\(Entity _ e) -> e) entries
+    entries <- runDb $ selectList [] []
+    return $ map (\(Entity _ e) -> e) entries
 
 getUsers :: IO [User]
 getUsers = do
-  entries <- runDb $ selectList [] []
-  return $ map (\(Entity _ e) -> e) entries
+    entries <- runDb $ selectList [] []
+    return $ map (\(Entity _ e) -> e) entries
 
 getTokens :: IO [Token]
 getTokens = do
-  entries <- runDb $ selectList [] []
-  return $ map (\(Entity _ e) -> e) entries
+    entries <- runDb $ selectList [] []
+    return $ map (\(Entity _ e) -> e) entries
 
 uuidExists :: String -> IO Bool
 uuidExists uuid = do
-  visits <- runDb $ selectList [Filter VisitUuid (FilterValue uuid) (BackendSpecificFilter "LIKE")] [] :: IO [Entity Visit]
-  print visits
-  return (null visits)
+    visits <- runDb $ selectList [Filter VisitUuid (FilterValue uuid) (BackendSpecificFilter "LIKE")] [] :: IO [Entity Visit]
+    print visits
+    return (null visits)
 
 tokenToUsername :: String -> IO String
 tokenToUsername token = do
-  (Entity _ token : _) <- runDb $ selectList [Filter TokenToken (FilterValue token) (BackendSpecificFilter "LIKE")] []
-  return $ tokenName token
+    (Entity _ token : _) <- runDb $ selectList [Filter TokenToken (FilterValue token) (BackendSpecificFilter "LIKE")] []
+    return $ tokenName token
 
 -- schema
 prettyPrintSchema :: String
 prettyPrintSchema =
-  intercalate "\n" $
-    map
-      ( \(def :: EntityDef) ->
-          dbName def
-            ++ unwords
-              ( map
-                  ( \(field :: FieldDef) ->
-                      "\n\t" ++ fieldName field ++ replicate (20 - length (fieldName field)) ' ' ++ fieldType field
-                  )
-                  $ getEntityFields def
-              )
-      )
-      defs
- where
-  dbName :: EntityDef -> String
-  dbName entity = unpack $ unEntityNameDB $ getEntityDBName entity
-  fieldName :: FieldDef -> String
-  fieldName field = unpack $ unFieldNameHS $ fieldHaskell field
-  fieldType :: FieldDef -> String
-  fieldType field = show $ fieldSqlType field
+    intercalate "\n" $ map (\(def :: EntityDef) -> 
+        dbName def ++ unwords (map (\(field :: FieldDef) ->
+            "\n\t" ++ fieldName field ++ replicate (20 - length (fieldName field)) ' ' ++ fieldType field
+        ) $ getEntityFields def)
+    ) defs
+    where
+        dbName entity = unpack $ unEntityNameDB $ getEntityDBName entity
+        fieldName field = unpack $ unFieldNameHS $ fieldHaskell field
+        fieldType field = show $ fieldSqlType field
 
 validateToken :: String -> IO Bool
 validateToken token = do
-  tokens <- getTokens
-  case tokens of
-    [] -> return False
-    _ -> return True
+    tokens <- getTokens
+    case tokens of
+        [] -> return False
+        _ -> return True
diff --git a/lib/Database/Schema.hs b/lib/Database/Schema.hs
index cf84aa0..8113abc 100644
--- a/lib/Database/Schema.hs
+++ b/lib/Database/Schema.hs
@@ -18,9 +18,7 @@ module Database.Schema where
 
 import Database.Persist.TH (mkEntityDefList, mkMigrate, mkPersist, persistLowerCase, share, sqlSettings)
 
-share
-  [mkPersist sqlSettings, mkMigrate "migrateAll", mkEntityDefList "defs"]
-  [persistLowerCase|
+share [mkPersist sqlSettings, mkMigrate "migrateAll", mkEntityDefList "defs"] [persistLowerCase|
     Visit                                   sql=visits
         rid                      Int         sql=id
         timestamp               Int         sql=timestamp
@@ -50,4 +48,5 @@ share
         rid                      Int         sql=id
         token                   String      sql=token
         name                    String      sql=username
+        deriving Eq Show
 |]
diff --git a/lib/Logger.hs b/lib/Logger.hs
index d09ddca..4243a2b 100644
--- a/lib/Logger.hs
+++ b/lib/Logger.hs
@@ -11,10 +11,9 @@ import System.IO (hFlush, stdout)
 import Utils (unpackBS)
 
 colorStatus :: Int -> String
-colorStatus code
-  | code < 300 = "\ESC[38;2;0;255;0m" ++ show code ++ "\ESC[0m"
-  | code < 400 = "\ESC[38;2;255;255;0m" ++ show code ++ "\ESC[0m"
-  | otherwise = "\ESC[38;2;255;0;0m" ++ show code ++ "\ESC[0m"
+colorStatus code    | code < 300    = "\ESC[38;2;0;255;0m" ++ show code ++ "\ESC[0m"
+                    | code < 400    = "\ESC[38;2;255;255;0m" ++ show code ++ "\ESC[0m"
+                    | otherwise     = "\ESC[38;2;255;0;0m" ++ show code ++ "\ESC[0m"
 
 getPath :: Request -> String
 getPath request = intercalate "/" $ map unpack $ pathInfo request
@@ -43,54 +42,54 @@ clearLine = "\ESC[0K"
 
 tableify :: [String] -> String
 tableify (x : xs) = "| " ++ x ++ replicate (20 - l) ' ' ++ tableify xs
- where
-  l = length x
+    where
+        l = length x
 tableify [] = "|"
 
 info :: String -> IO ()
 info input = do
-  loglevel <- getLogLevel
-  case loglevel of
-    Info -> putStrLn input
-    _ -> return ()
-  hFlush stdout
+    loglevel <- getLogLevel
+    case loglevel of
+        Info -> putStrLn input
+        _ -> return ()
+    hFlush stdout
 
 warning :: String -> IO ()
 warning input = do
-  loglevel <- getLogLevel
-  case loglevel of
-    Warning -> putStrLn input
-    Info -> putStrLn input
-    _ -> return ()
-  hFlush stdout
+    loglevel <- getLogLevel
+    case loglevel of
+        Warning -> putStrLn input
+        Info -> putStrLn input
+        _ -> return ()
+    hFlush stdout
 
 error :: String -> IO ()
 error msg = do
-  putStrLn msg
-  hFlush stdout
+    putStrLn msg
+    hFlush stdout
 
 logger :: Request -> Response -> IO ()
 logger request (ResponseBuilder status _ _) = do
-  let method = unpackBS (requestMethod request)
-  let path = getPath request
-  cliState <- getCliState
-  when cliState $ putStr $ "\r" ++ clearEnd
-  putStrLn $ tableify [method, show $ statusCode status, path]
-  when cliState $ putStr "> "
-  hFlush stdout
+    let method = unpackBS (requestMethod request)
+    let path = getPath request
+    cliState <- getCliState
+    when cliState $ putStr $ "\r" ++ clearEnd
+    putStrLn $ tableify [method, show $ statusCode status, path]
+    when cliState $ putStr "> "
+    hFlush stdout
 logger request (ResponseFile status _ _ _) = do
-  let method = unpackBS (requestMethod request)
-  let path = getPath request
-  cliState <- getCliState
-  when cliState $ putStr $ "\r" ++ clearEnd
-  putStrLn $ tableify [method, show $ statusCode status, path]
-  when cliState $ putStr "> "
-  hFlush stdout
+    let method = unpackBS (requestMethod request)
+    let path = getPath request
+    cliState <- getCliState
+    when cliState $ putStr $ "\r" ++ clearEnd
+    putStrLn $ tableify [method, show $ statusCode status, path]
+    when cliState $ putStr "> "
+    hFlush stdout
 logger request x = do
-  let method = unpackBS (requestMethod request)
-  let path = getPath request
-  cliState <- getCliState
-  when cliState $ putStr $ "\r" ++ clearEnd
-  putStrLn $ tableify [method, path]
-  when cliState $ putStr "> "
-  hFlush stdout
+    let method = unpackBS (requestMethod request)
+    let path = getPath request
+    cliState <- getCliState
+    when cliState $ putStr $ "\r" ++ clearEnd
+    putStrLn $ tableify [method, path]
+    when cliState $ putStr "> "
+    hFlush stdout
diff --git a/lib/Page.hs b/lib/Page.hs
index 380270a..c5bf547 100644
--- a/lib/Page.hs
+++ b/lib/Page.hs
@@ -6,34 +6,33 @@ import Text.Blaze.Html (Html)
 
 type Page = ([PageSetting], Request -> IO Html)
 
-data PageSetting
-  = EmbedText String
-  | EmbedImage String
-  | Description String
-  | Route String
+data PageSetting    = EmbedText String
+                    | EmbedImage String
+                    | Description String
+                    | Route String
 
 route :: [PageSetting] -> String
 route (x : xs) = case x of
-  Route r -> r
-  _ -> route xs
+    Route r -> r
+    _ -> route xs
 route [] = "/"
 
 description :: [PageSetting] -> String
 description (x : xs) = case x of
-  Description d -> d
-  _ -> description xs
+    Description d -> d
+    _ -> description xs
 description [] = ""
 
 embedText :: [PageSetting] -> String
 embedText (x : xs) = case x of
-  EmbedText t -> t
-  _ -> embedText xs
+    EmbedText t -> t
+    _ -> embedText xs
 embedText [] = ""
 
 embedImage :: [PageSetting] -> String
 embedImage (x : xs) = case x of
-  EmbedImage i -> i
-  _ -> embedImage xs
+    EmbedImage i -> i
+    _ -> embedImage xs
 embedImage [] = ""
 
 getArgs :: Request -> [String]
diff --git a/lib/Repl.hs b/lib/Repl.hs
index b95239f..ea181df 100644
--- a/lib/Repl.hs
+++ b/lib/Repl.hs
@@ -14,48 +14,48 @@ import System.IO (hFlush, stdout)
 
 resetCursor :: Int -> IO ()
 resetCursor n = do
-  putStr $ mconcat [up n]
+    putStr $ mconcat [up n]
 
 doCommand :: [String] -> IO ()
 doCommand ("help" : _) = do
-  putStrLn $ intercalate "\n" help
-  resetCursor $ length help + 1
-  repl
- where
-  help =
-    [ "Homepage CLI command list:"
-    , ""
-    , "exit:" ++ right 10 ++ "Exits the program"
-    , "help:" ++ right 10 ++ "Shows help about the CLI"
-    , "drop:" ++ right 10 ++ "Deletes a table and reruns init schema :: REMOVED"
-    , "adduser:" ++ right 7 ++ "Adds a user to the users table"
-    , "removeuser:" ++ right 4 ++ "removes a user from the users table"
-    ]
+    putStrLn $ intercalate "\n" help
+    resetCursor $ length help + 1
+    repl
+    where
+        help = [
+            "Homepage CLI command list:", 
+            "",
+            "exit:" ++ right 10 ++ "Exits the program", 
+            "help:" ++ right 10 ++ "Shows help about the CLI", 
+            "drop:" ++ right 10 ++ "Deletes a table and reruns init schema :: REMOVED",
+            "adduser:" ++ right 7 ++ "Adds a user to the users table",
+            "removeuser:" ++ right 4 ++ "removes a user from the users table"
+            ]
 doCommand ("exit" : _) = do
-  putStrLn "Exiting"
-  exitSuccess
+    putStrLn "Exiting"
+    exitSuccess
 doCommand ["adduser", username, password] = do
-  let pass = mkPassword $ pack password
-  (PasswordHash hash) <- hashPassword pass
-  runDb $ insertEntity $ User 0 username $ unpack hash
-  putStrLn "Successfully added user"
-  resetCursor 2
-  repl
+    let pass = mkPassword $ pack password
+    (PasswordHash hash) <- hashPassword pass
+    runDb $ insertEntity $ User 0 username $ unpack hash
+    putStrLn "Successfully added user"
+    resetCursor 2
+    repl
 doCommand ["removeuser", username] = do
-  runDb $ deleteWhere [UserName ==. username]
-  putStrLn "Successfully removed user"
-  resetCursor 2
-  repl
+    runDb $ deleteWhere [UserName ==. username]
+    putStrLn "Successfully removed user"
+    resetCursor 2
+    repl
 doCommand x = do
-  putStrLn $ "Error, no such command: [" ++ unwords x ++ "]"
-  resetCursor 2
-  repl
+    putStrLn $ "Error, no such command: [" ++ unwords x ++ "]"
+    resetCursor 2
+    repl
 
 repl :: IO ()
 repl = do
-  putStr $ "> " ++ clearLine
-  hFlush stdout
-  line <- getLine
-  putStr clearEnd
-  hFlush stdout
-  doCommand $ words line
+    putStr $ "> " ++ clearLine
+    hFlush stdout
+    line <- getLine
+    putStr clearEnd
+    hFlush stdout
+    doCommand $ words line
diff --git a/lib/Scripts.hs b/lib/Scripts.hs
index 7eba990..ba6e7a6 100644
--- a/lib/Scripts.hs
+++ b/lib/Scripts.hs
@@ -5,26 +5,23 @@ import Page (Page, PageSetting (Route))
 import Text.Blaze.Html (Html)
 
 createStorage :: Html
-createStorage =
-  [hsx|
+createStorage = [hsx|
     <script>
         var storage = {}
     </script>
 |]
 
 initStorage :: String -> Html
-initStorage label =
-  [hsx|
+initStorage label = [hsx|
     <script data-label={label}>
         storage[document.currentScript.dataset.label] = {}
     </script>
 |]
 
 fetchGet :: String -> String -> (String -> Html) -> Html
-fetchGet label url callback =
-  [hsx|
-        {initStorage label}
-        {callback label}
+fetchGet label url callback = [hsx|
+    {initStorage label}
+    {callback label}
     <script data-label={label} data-url={url}>
         var label = document.currentScript.dataset.label
         var url = document.currentScript.dataset.url
@@ -40,9 +37,8 @@ fetchGet label url callback =
 
 alertRequestApi :: String -> Html
 alertRequestApi url = fetchGet "temp" url callback
- where
-  callback _ =
-    [hsx|
+    where
+        callback _ = [hsx|
             <script>
                 storage.temp.callback = text => alert(text)
             </script>
@@ -50,9 +46,8 @@ alertRequestApi url = fetchGet "temp" url callback
 
 showText :: String -> String -> Html
 showText label url = fetchGet label url callback
- where
-  callback label =
-    [hsx|
+    where
+        callback label = [hsx|
             <div id={label}></div>
             <script data-label={label}>
                 var label = document.currentScript.dataset.label
@@ -61,17 +56,16 @@ showText label url = fetchGet label url callback
         |]
 
 page :: Html
-page =
-  [hsx|
+page = [hsx|
     {createStorage}
     {alertRequestApi "/api/hello"}
     {showText "apitext" "/api/guestbook/get"}
 |]
 
 settings :: [PageSetting]
-settings =
-  [ Route "/test"
-  ]
+settings = [ 
+    Route "/test"
+    ]
 
 testPage :: Page
 testPage = (settings, const $ return page)
diff --git a/lib/Section.hs b/lib/Section.hs
index 2b31c6f..721ba6d 100644
--- a/lib/Section.hs
+++ b/lib/Section.hs
@@ -4,8 +4,7 @@ import IHP.HSX.QQ (hsx)
 import Text.Blaze.Html (Html)
 
 section :: Html -> Html
-section content =
-  [hsx|
+section content = [hsx|
     <div class="section">
         {content}
     </div>
diff --git a/lib/Settings.hs b/lib/Settings.hs
index 97cd41d..99d3ae1 100644
--- a/lib/Settings.hs
+++ b/lib/Settings.hs
@@ -9,25 +9,25 @@ import System.Environment (getArgs, lookupEnv)
 
 argOrEnvOrDefault :: String -> String -> String -> IO String
 argOrEnvOrDefault arg env def = do
-  args <- getArgs
-  case find (isInfixOf (pack arg)) [pack arg | arg <- args] of
-    (Just x) -> return $ splitOn "=" (unpack x) !! 1
-    _ -> do
-      var <- lookupEnv env
-      return $ case var of
-        (Just a) -> a
-        _ -> def
+    args <- getArgs
+    case find (isInfixOf (pack arg)) [pack arg | arg <- args] of
+        (Just x) -> return $ splitOn "=" (unpack x) !! 1
+        _ -> do
+            var <- lookupEnv env
+            return $ case var of
+                (Just a) -> a
+                _ -> def
 
 argOrEnvOrBool :: String -> String -> IO Bool
 argOrEnvOrBool arg env = do
-  args <- getArgs
-  case find (== arg) args of
-    (Just _) -> return True
-    _ -> do
-      var <- lookupEnv env
-      return $ case var of
-        (Just "1") -> True
-        _ -> False
+    args <- getArgs
+    case find (== arg) args of
+        (Just _) -> return True
+        _ -> do
+            var <- lookupEnv env
+            return $ case var of
+                (Just "1") -> True
+                _ -> False
 
 getDatabaseName :: IO String
 getDatabaseName = argOrEnvOrDefault "--db" "HOMEPAGE_DB" "homepage"
@@ -37,19 +37,19 @@ getDatabaseUser = argOrEnvOrDefault "--dbuser" "HOMEPAGE_DB_USER" "homepage"
 
 getPort :: IO Int
 getPort = do
-  var <- argOrEnvOrDefault "--port" "HOMEPAGE_PORT" "8000"
-  return $ read var
+    var <- argOrEnvOrDefault "--port" "HOMEPAGE_PORT" "8000"
+    return $ read var
 
 data LogLevel = Error | Warning | Info
 
 getLogLevel :: IO LogLevel
 getLogLevel = do
-  var <- argOrEnvOrDefault "--loglevel" "HOMEPAGE_LOGLEVEL" "error"
-  return $ case var of
-    "info" -> Info
-    "warning" -> Warning
-    "error" -> Error
-    _ -> Error
+    var <- argOrEnvOrDefault "--loglevel" "HOMEPAGE_LOGLEVEL" "error"
+    return $ case var of
+        "info" -> Info
+        "warning" -> Warning
+        "error" -> Error
+        _ -> Error
 
 getCliState :: IO Bool
 getCliState = argOrEnvOrBool "--cli" "HOMEPAGE_CLI"
diff --git a/lib/Tables.hs b/lib/Tables.hs
index 07b6671..91b9155 100644
--- a/lib/Tables.hs
+++ b/lib/Tables.hs
@@ -4,50 +4,43 @@ import Control.Applicative
 import Data.Aeson
 import Data.ByteString.Lazy (fromStrict)
 
-data GuestbookEntry
-  = GuestbookEntry
-      { name :: String
-      , content :: String
-      , parent :: Int
-      }
-  | EmptyGuestbook
-  deriving (Show)
+data GuestbookEntry = GuestbookEntry {
+    name :: String, 
+    content :: String, 
+    parent :: Int
+} | EmptyGuestbook
+    deriving (Show)
 
 instance FromJSON GuestbookEntry where
-  parseJSON (Object v) =
-    GuestbookEntry
-      <$> v .: "name"
-      <*> v .: "content"
-      <*> v .: "parentId"
-  parseJSON _ = empty
+    parseJSON (Object v) = GuestbookEntry
+        <$> v .: "name"
+        <*> v .: "content"
+        <*> v .: "parentId"
+    parseJSON _ = empty
 
 instance ToJSON GuestbookEntry where
-  toJSON (GuestbookEntry name content parent) = object ["name" .= name, "content" .= content, "parent" .= parent]
-
-data LeaderboardEntry
-  = LeaderboardEntry
-      { lname :: String
-      , score :: Int
-      , speed :: Int
-      , fruits :: Int
-      }
-  | EmptyLeaderboard
-  deriving (Show)
+    toJSON (GuestbookEntry name content parent) = object ["name" .= name, "content" .= content, "parent" .= parent]
+
+data LeaderboardEntry = LeaderboardEntry {
+    lname :: String,
+    score :: Int,
+    speed :: Int,
+    fruits :: Int
+} | EmptyLeaderboard
+    deriving (Show)
 
 instance FromJSON LeaderboardEntry where
-  parseJSON (Object v) =
-    LeaderboardEntry
-      <$> v .: "name"
-      <*> v .: "score"
-      <*> v .: "speed"
-      <*> v .: "fruits"
-  parseJSON _ = empty
+    parseJSON (Object v) = LeaderboardEntry
+        <$> v .: "name"
+        <*> v .: "score"
+        <*> v .: "speed"
+        <*> v .: "fruits"
+    parseJSON _ = empty
 
 data Credentials = EmptyCredentials | Credentials String String
 
 instance FromJSON Credentials where
-  parseJSON (Object v) =
-    Credentials
-      <$> v .: "username"
-      <*> v .: "password"
-  parseJSON _ = empty
+    parseJSON (Object v) = Credentials
+        <$> v .: "username"
+        <*> v .: "password"
+    parseJSON _ = empty
diff --git a/lib/Tree.hs b/lib/Tree.hs
index a852f9c..0735395 100644
--- a/lib/Tree.hs
+++ b/lib/Tree.hs
@@ -1,32 +1,29 @@
 module Tree where
 
 data Tree a = Tree a [Tree a]
-  deriving (Show)
+    deriving (Show)
 
 instance Functor Tree where
-  -- fmap :: (a -> b) -> Tree a -> Tree b
-  fmap f (Tree a xs) = Tree (f a) $ map (fmap f) xs
+    -- fmap :: (a -> b) -> Tree a -> Tree b
+    fmap f (Tree a xs) = Tree (f a) $ map (fmap f) xs
 
 instance Applicative Tree where
-  pure a = Tree a []
-  (Tree a xs) <*> (Tree b ys) = Tree (a b) $ zipWith (<*>) xs ys
+    pure a = Tree a []
+    (Tree a xs) <*> (Tree b ys) = Tree (a b) $ zipWith (<*>) xs ys
 
 instance Monad Tree where
-  return = pure
-  (Tree x xs) >>= f = Tree y $ fmap (>>= f) xs ++ ys
-   where
-    (Tree y ys) = f x
+    return = pure
+    (Tree x xs) >>= f = Tree y $ fmap (>>= f) xs ++ ys
+        where
+            (Tree y ys) = f x
 
 findInChildren :: (a -> Bool) -> [Tree a] -> Maybe a
-findInChildren f ((Tree value []) : xs)
-  | f value = Just value
-  | otherwise = findInChildren f xs
-findInChildren f ((Tree value children) : xs)
-  | f value = Just value
-  | otherwise = findInChildren f children
+findInChildren f ((Tree value []) : xs) | f value   = Just value
+                                        | otherwise = findInChildren f xs
+findInChildren f ((Tree value children) : xs)   | f value   = Just value
+                                                | otherwise = findInChildren f children
 findInChildren _ [] = Nothing
 
 findInTree :: (a -> Bool) -> Tree a -> Maybe a
-findInTree f (Tree value children)
-  | f value = Just value
-  | otherwise = findInChildren f children
+findInTree f (Tree value children)  | f value   = Just value
+                                    | otherwise = findInChildren f children
diff --git a/lib/Utils.hs b/lib/Utils.hs
index 89572ec..58443b7 100644
--- a/lib/Utils.hs
+++ b/lib/Utils.hs
@@ -12,8 +12,7 @@ forEach (x : xs) f = mconcat [f x, forEach xs f]
 forEach [] _ = [hsx||]
 
 linkImage :: String -> String -> String -> Html
-linkImage label image url =
-  [hsx|
+linkImage label image url = [hsx|
     <div class="inline_container">
         <a href={url}>
             <img src={image} width="100" height="100" style="padding: 1px;">
@@ -24,19 +23,12 @@ linkImage label image url =
 |]
 
 items :: [Html] -> Html
-items values =
-  mconcat $
-    map
-      ( \value ->
-          [hsx|
+items values = mconcat $ map (\value -> [hsx|
     <th style="width:100px">{value}</th>
-|]
-      )
-      values
+|]) values
 
 row :: [Html] -> Html
-row values =
-  [hsx|
+row values = [hsx|
     <tr>
         {items values}
     </tr>
@@ -47,5 +39,5 @@ unpackBS = unpack . decodeUtf8
 
 getDefault :: a -> Maybe a -> a
 getDefault def a = case a of
-  (Just v) -> v
-  Nothing -> def
+    (Just v) -> v
+    Nothing -> def