1 files changed, 22 insertions, 21 deletions
diff --git a/src/Language/SimpleShell/Parser/Expr.hs b/src/Language/SimpleShell/Parser/Expr.hs
index dddc82a..672bb05 100644
--- a/src/Language/SimpleShell/Parser/Expr.hs
+++ b/src/Language/SimpleShell/Parser/Expr.hs
@@ -44,7 +44,6 @@ import qualified Text.Megaparsec.Char.Lexer as L (charLiteral, decimal)
 
 
 type ExprParser = ReaderT ExprContext RootParser
-type Parser = ExprParser
 
 
 data ExprContext = ExprContext
@@ -63,14 +62,14 @@ runExprParser decls p =
     vars = Map.fromList $ map swap decls
 
 
-lookupVar :: VarName -> Parser SimpleType
+lookupVar :: VarName -> ExprParser SimpleType
 lookupVar varname = do
   mt <- Map.lookup varname . ctxVars <$> ask
   case mt of
     Just t  -> return t
     Nothing -> fail $ "Undeclared variable $" ++ unpack varname
 
-lookupFun :: FunName -> Parser FunSig
+lookupFun :: FunName -> ExprParser FunSig
 lookupFun fname = do
   msig <- Map.lookup fname . ctxFuns <$> ask
   case msig of
@@ -78,18 +77,18 @@ lookupFun fname = do
     Nothing  -> fail $ "Undefined function " ++ unpack fname
 
 
-exprP :: Parser TypedExpr
+exprP :: ExprParser TypedExpr
 exprP
    =  makeExprParser weakTermP binaryOperatorTable
 
-weakTermP :: Parser TypedExpr
+weakTermP :: ExprParser TypedExpr
 weakTermP
    =  strongTermP
   <|> unaryOpP
   <|> builtinUnaryFunP
   <|> funP
 
-strongTermP :: Parser TypedExpr
+strongTermP :: ExprParser TypedExpr
 strongTermP
    =  literalP
   <|> varP
@@ -97,7 +96,7 @@ strongTermP
 
 -- | Parse a strong term--assuming its correctness--without yielding a result.
 --   This basically only checks for matching parentheses.
-strongTermP_ :: Parser ()
+strongTermP_ :: ExprParser ()
 strongTermP_
    =  void literalP
   <|> varP_
@@ -109,7 +108,7 @@ strongTermP_
     --    * string literals
     --    * comments
 
-    tok :: Parser ()
+    tok :: ExprParser ()
     tok
        =  void strLitP
       <|> symbol "(" *> void (many tok) <* symbol ")"
@@ -121,11 +120,11 @@ strongTermP_
 
 
 -- | Parse strong term with fixed type.
-strongTermP' :: String -> SimpleType -> Parser Expr
+strongTermP' :: String -> SimpleType -> ExprParser Expr
 strongTermP' errMsg t = forceType t strongTermP <|> fail errMsg
 
 
-literalP :: Parser TypedExpr
+literalP :: ExprParser TypedExpr
 literalP
    =  (IntType,)  . IntLiteral  <$> lexeme L.decimal
   <|> (StrType,)  . StrLiteral  <$> strLitP
@@ -135,20 +134,20 @@ literalP
        =  True  <$ keyword "true"
       <|> False <$ keyword "false"
 
-strLitP :: Parser String
+strLitP :: ExprParser String
 strLitP = lexeme $ char '"' *> manyTill L.charLiteral (char '"')
 
-varP :: Parser TypedExpr
+varP :: ExprParser TypedExpr
 varP = do
   _ <- char '$'
   x <- nameP
   t <- lookupVar x
   return (t, Var x)
 
-varP_ :: Parser ()
+varP_ :: ExprParser ()
 varP_ = void (char '$') <* nameP
 
-funP :: Parser TypedExpr
+funP :: ExprParser TypedExpr
 funP = do
   fname <- nameP
   (t', ts) <- lookupFun fname
@@ -161,7 +160,7 @@ funP = do
 type BinaryFun = Expr -> Expr -> Expr
 type BinarySig = SimpleType -> SimpleType -> Maybe SimpleType
 
-binaryOperatorTable :: [[Operator Parser TypedExpr]]
+binaryOperatorTable :: [[Operator ExprParser TypedExpr]]
 binaryOperatorTable =
   [ [ binary AssocR "||" Or  $ sameSig BoolType
     ]
@@ -192,7 +191,7 @@ binaryOperatorTable =
     intCmpSig IntType IntType = Just BoolType
     intCmpSig _       _       = Nothing
 
-    addP :: Parser (TypedExpr -> TypedExpr -> Maybe TypedExpr)
+    addP :: ExprParser (TypedExpr -> TypedExpr -> Maybe TypedExpr)
     addP = do
       symbol "+"
       return $ \(t1, x1) (t2, x2) ->
@@ -206,7 +205,7 @@ binaryOperatorTable =
 
     binary
       :: Associativity -> Text -> BinaryFun -> BinarySig
-      -> Operator Parser TypedExpr
+      -> Operator ExprParser TypedExpr
     binary assoc symb op sig = Binary assoc $ do
       symbol symb
       return $ \(t1, e1) (t2, e2) -> fmap (, op e1 e2) $ sig t1 t2
@@ -216,7 +215,7 @@ binaryOperatorTable =
 
 type UnaryFun = Expr -> Expr
 type UnarySig = SimpleType -> Maybe SimpleType
-type UnaryParser = Parser (TypedExpr -> Maybe TypedExpr)
+type UnaryParser = ExprParser (TypedExpr -> Maybe TypedExpr)
 
 unaryOperators, builtinUnaryFuns :: [UnaryParser]
 (unaryOperators, builtinUnaryFuns) =
@@ -240,18 +239,20 @@ unaryOperators, builtinUnaryFuns :: [UnaryParser]
     unaryFun :: Text -> UnaryFun -> UnarySig -> UnaryParser
     unaryFun = unary keyword
 
-    unary :: (Text -> Parser ()) -> Text -> UnaryFun -> UnarySig -> UnaryParser
+    unary
+      :: (Text -> ExprParser ()) -> Text -> UnaryFun -> UnarySig -> UnaryParser
     unary symbPF symb op sig = do
       symbPF symb
       return $ \(t, e) -> fmap (, op e) $ sig t
 
-unaryOpP, builtinUnaryFunP :: Parser TypedExpr
+unaryOpP, builtinUnaryFunP :: ExprParser TypedExpr
 (unaryOpP, builtinUnaryFunP) =
   ( asum $ map (aux "unary operator"         weakTermP  ) unaryOperators
   , asum $ map (aux "builtin unary function" strongTermP) builtinUnaryFuns
   )
   where
-    aux :: String -> Parser TypedExpr -> UnaryParser -> Parser TypedExpr
+    aux
+      :: String -> ExprParser TypedExpr -> UnaryParser -> ExprParser TypedExpr
     aux desc argP p = do
       f <- p
       x <- argP