From 54bcc4595f28ba76384b5f018d72bca353cd88d3 Mon Sep 17 00:00:00 2001
From: tzlil <tzlils@protonmail.com>
Date: Sat, 15 Apr 2023 01:54:47 +0300
Subject: fourmolu formatting

---
 src/Parse.hs | 55 +++++++++++++++++++++++++++++--------------------------
 1 file changed, 29 insertions(+), 26 deletions(-)

(limited to 'src/Parse.hs')

diff --git a/src/Parse.hs b/src/Parse.hs
index 748bd98..c06b20a 100644
--- a/src/Parse.hs
+++ b/src/Parse.hs
@@ -7,17 +7,17 @@ module Parse (parse, tryParse) where
 import qualified AST as A
 
 import Text.Megaparsec (
-  MonadParsec (..),
-  Parsec,
-  errorBundlePretty,
-  noneOf,
-  runParser,
-  some,
-  (<?>),
-  (<|>),
-  between
+    MonadParsec (..),
+    Parsec,
+    between,
+    errorBundlePretty,
+    noneOf,
+    runParser,
+    some,
+    (<?>),
+    (<|>),
  )
-import Text.Megaparsec.Char( space1 )
+import Text.Megaparsec.Char (space1)
 import qualified Text.Megaparsec.Char.Lexer as L
 
 import Control.Monad (void)
@@ -32,8 +32,9 @@ parse = either error id . tryParse
 
 -- | Parse some code 'String' into an 'L.Expr' or an error message.
 tryParse :: String -> Either String A.Expr
-tryParse = first errorBundlePretty .
-           runParser (pSpace >> pExpr <* eof) "<input>"
+tryParse =
+    first errorBundlePretty
+        . runParser (pSpace >> pExpr <* eof) "<input>"
 
 {- * Expression parser
 
@@ -48,13 +49,13 @@ pExpr = pBody <?> "expression"
 -- | Parse expressions at the lowest level of precedence, i.e., lambdas.
 pBody :: Parser A.Expr
 pBody = pLam <|> pApp
- where
-  pLam = do
-    pToken "\\"
-    bs <- some pIdent <?> "lambda binders"
-    pToken "."
-    body <- pBody <?> "lambda body"
-    return $ foldr A.Lam body bs
+  where
+    pLam = do
+        pToken "\\"
+        bs <- some pIdent <?> "lambda binders"
+        pToken "."
+        body <- pBody <?> "lambda body"
+        return $ foldr A.Lam body bs
 
 -- | Parse juxtaposition as application.
 pApp :: Parser A.Expr
@@ -63,8 +64,8 @@ pApp = foldl1 A.App <$> some pAtom <?> "term application"
 -- | Parse expressions at the highest precedence, including parenthesized terms
 pAtom :: Parser A.Expr
 pAtom = A.Var <$> pVar <|> pParens pExpr
- where
-  pVar = pIdent <?> "variable"
+  where
+    pVar = pIdent <?> "variable"
 
 -- * Megaparsec boilerplate and helpers
 
@@ -73,7 +74,7 @@ type Parser = Parsec Void String
 
 -- | Parse an identifier, possible surrounded by spaces
 pIdent :: Parser String
-pIdent = L.lexeme pSpace (some $ noneOf ['\\','.','(',')',' ','\n','\r','\t','-'])
+pIdent = L.lexeme pSpace (some $ noneOf ['\\', '.', '(', ')', ' ', '\n', '\r', '\t', '-'])
 
 -- | Consume a token defined by a string, possibly surrounded by spaces
 pToken :: String -> Parser ()
@@ -85,7 +86,9 @@ pParens = between (pToken "(") (pToken ")")
 
 -- | Consumes whitespace and comments.
 pSpace :: Parser ()
-pSpace = label "whitespace" $ L.space
-    space1
-    (L.skipLineComment "--")
-    (L.skipBlockCommentNested "{-" "-}")
+pSpace =
+    label "whitespace" $
+        L.space
+            space1
+            (L.skipLineComment "--")
+            (L.skipBlockCommentNested "{-" "-}")
-- 
cgit 1.4.1