refactor: use ormolu (#1193)

src/EvalError.hs

@@ -14,8 +14,8 @@ import Info
 import Obj
 import SymPath
 import TypeError
-import Util
 import Types
+import Util
 
 --------------------------------------------------------------------------------
 -- Data (Evaluation Errors)

src/Qualify.hs

@@ -181,7 +181,8 @@ qualifyFunctionDefinition typeEnv globalEnv env (XObj (Lst [defn@(XObj (Defn _)
   -- It is marked as RecursionEnv basically is the same thing as external to not mess up lookup.
   -- Inside the recursion env is the function env that contains bindings for the arguments of the function.
   -- Note: These inner envs is ephemeral since they are not stored in a module or global scope.
-  do let recursionEnv = Env Map.empty (Just env) (Just (functionName ++ "-recurse-env")) Set.empty RecursionEnv 0
+  do
+    let recursionEnv = Env Map.empty (Just env) (Just (functionName ++ "-recurse-env")) Set.empty RecursionEnv 0
         envWithSelf = extendEnv recursionEnv functionName sym
         functionEnv = Env Map.empty (Just envWithSelf) Nothing Set.empty InternalEnv 0
         envWithArgs = foldl' (\e arg@(XObj (Sym (SymPath _ argSymName) _) _ _) -> extendEnv e argSymName arg) functionEnv argsArr
@@ -192,7 +193,8 @@ qualifyFunctionDefinition _ _ _ xobj = Left $ FailedToQualifyDeclarationName xob
 -- | Qualify the symbols in a lambda body.
 qualifyLambda :: Qualifier
 qualifyLambda typeEnv globalEnv env (XObj (Lst [fn@(XObj (Fn _ _) _ _), args@(XObj (Arr argsArr) _ _), body]) i t) =
-  do let lvl = envFunctionNestingLevel env
+  do
+    let lvl = envFunctionNestingLevel env
         functionEnv = Env Map.empty (Just env) Nothing Set.empty InternalEnv (lvl + 1)
         envWithArgs = foldl' (\e arg@(XObj (Sym (SymPath _ argSymName) _) _ _) -> extendEnv e argSymName arg) functionEnv argsArr
     qualifiedBody <- liftM unQualified (setFullyQualifiedSymbols typeEnv globalEnv envWithArgs body)
@@ -202,14 +204,16 @@ qualifyLambda _ _ _ xobj = Left $ FailedToQualifySymbols xobj
 -- | Qualify the symbols in a The form's body.
 qualifyThe :: Qualifier
 qualifyThe typeEnv globalEnv env (XObj (Lst [the@(XObj The _ _), typeX, value]) i t) =
-  do qualifiedValue <- liftM unQualified (setFullyQualifiedSymbols typeEnv globalEnv env value)
+  do
+    qualifiedValue <- liftM unQualified (setFullyQualifiedSymbols typeEnv globalEnv env value)
     pure (Qualified (XObj (Lst [the, typeX, qualifiedValue]) i t))
 qualifyThe _ _ _ xobj = Left $ FailedToQualifySymbols xobj
 
 -- | Qualify the symbols in a Def form's body.
 qualifyDef :: Qualifier
 qualifyDef typeEnv globalEnv env (XObj (Lst [def@(XObj Def _ _), sym, expr]) i t) =
-  do qualifiedExpr <- liftM unQualified (setFullyQualifiedSymbols typeEnv globalEnv env expr)
+  do
+    qualifiedExpr <- liftM unQualified (setFullyQualifiedSymbols typeEnv globalEnv env expr)
     pure (Qualified (XObj (Lst [def, sym, qualifiedExpr]) i t))
 qualifyDef _ _ _ xobj = Left $ FailedToQualifySymbols xobj
 
@@ -219,7 +223,8 @@ qualifyLet typeEnv globalEnv env (XObj (Lst [letExpr@(XObj Let _ _), bind@(XObj
   | odd (length bindings) = Right $ Qualified $ XObj (Lst [letExpr, bind, body]) i t -- Leave it untouched for the compiler to find the error.
   | not (all isSym (evenIndices bindings)) = Right $ Qualified $ XObj (Lst [letExpr, bind, body]) i t -- Leave it untouched for the compiler to find the error.
   | otherwise =
-    do let Just ii = i
+    do
+      let Just ii = i
           lvl = envFunctionNestingLevel env
           innerEnv = Env Map.empty (Just env) (Just ("let-env-" ++ show (infoIdentifier ii))) Set.empty InternalEnv lvl
       (innerEnv', qualifiedBindings) <- foldM qualifyBinding (innerEnv, []) (pairwise bindings)
@@ -228,7 +233,8 @@ qualifyLet typeEnv globalEnv env (XObj (Lst [letExpr@(XObj Let _ _), bind@(XObj
   where
     qualifyBinding :: (Env, [XObj]) -> (XObj, XObj) -> Either QualificationError (Env, [XObj])
     qualifyBinding (e, bs) (s@(XObj (Sym (SymPath _ binderName) _) _ _), o) =
-      do qualified <- liftM unQualified (setFullyQualifiedSymbols typeEnv globalEnv e o)
+      do
+        qualified <- liftM unQualified (setFullyQualifiedSymbols typeEnv globalEnv e o)
         (pure (extendEnv e binderName s, bs ++ [s, qualified]))
     qualifyBinding _ _ = error "bad let binding"
 qualifyLet _ _ _ xobj = Left $ FailedToQualifySymbols xobj
@@ -238,7 +244,8 @@ qualifyMatch :: Qualifier
 qualifyMatch typeEnv globalEnv env (XObj (Lst (matchExpr@(XObj (Match _) _ _) : expr : casesXObjs)) i t)
   | odd (length casesXObjs) = pure $ Qualified $ XObj (Lst (matchExpr : expr : casesXObjs)) i t -- Leave it untouched for the compiler to find the error.
   | otherwise =
-      do qualifiedExpr <- pure . unQualified =<< setFullyQualifiedSymbols typeEnv globalEnv env expr
+    do
+      qualifiedExpr <- pure . unQualified =<< setFullyQualifiedSymbols typeEnv globalEnv env expr
       qualifiedCases <- pure . map (map unQualified) =<< mapM qualifyCases (pairwise casesXObjs)
       pure (Qualified (XObj (Lst (matchExpr : qualifiedExpr : concat qualifiedCases)) i t))
   where
@@ -248,12 +255,14 @@ qualifyMatch typeEnv globalEnv env (XObj (Lst (matchExpr@(XObj (Match _) _ _) :
     innerEnv = Env Map.empty (Just env) (Just ("case-env-" ++ show (infoIdentifier ii))) Set.empty InternalEnv lvl
     qualifyCases :: (XObj, XObj) -> Either QualificationError [Qualified]
     qualifyCases (l@(XObj (Lst (_ : xs)) _ _), r) =
-      do let innerEnv' = foldl' foldVars innerEnv xs
+      do
+        let innerEnv' = foldl' foldVars innerEnv xs
         qualifiedLHS <- setFullyQualifiedSymbols typeEnv globalEnv env l
         qualifiedRHS <- setFullyQualifiedSymbols typeEnv globalEnv innerEnv' r
         Right [qualifiedLHS, qualifiedRHS]
     qualifyCases (l, r) =
-      do qualifiedLHS <- setFullyQualifiedSymbols typeEnv globalEnv env l
+      do
+        qualifiedLHS <- setFullyQualifiedSymbols typeEnv globalEnv env l
         qualifiedRHS <- setFullyQualifiedSymbols typeEnv globalEnv env r
         Right [qualifiedLHS, qualifiedRHS]
     foldVars :: Env -> XObj -> Env
@@ -276,7 +285,8 @@ qualifyWith _ _ _ xobj = Left $ FailedToQualifySymbols xobj
 qualifyLst :: Qualifier
 qualifyLst typeEnv globalEnv env (XObj (Lst xobjs) i t) =
   -- TODO: Perhaps this general case can be sufficient? No need with all the cases above..?
-  do qualifiedXObjs <- liftM (map unQualified) (mapM (setFullyQualifiedSymbols typeEnv globalEnv env) xobjs)
+  do
+    qualifiedXObjs <- liftM (map unQualified) (mapM (setFullyQualifiedSymbols typeEnv globalEnv env) xobjs)
     pure (Qualified (XObj (Lst qualifiedXObjs) i t))
 qualifyLst _ _ _ xobj = Left $ FailedToQualifySymbols xobj
 
@@ -382,13 +392,15 @@ qualifySym _ _ _ xobj = Left $ FailedToQualifySymbols xobj
 -- | Qualify an Arr form.
 qualifyArr :: Qualifier
 qualifyArr typeEnv globalEnv env (XObj (Arr array) i t) =
-  do qualifiedArr <- liftM (map unQualified) (mapM (setFullyQualifiedSymbols typeEnv globalEnv env) array)
+  do
+    qualifiedArr <- liftM (map unQualified) (mapM (setFullyQualifiedSymbols typeEnv globalEnv env) array)
     pure (Qualified (XObj (Arr qualifiedArr) i t))
 qualifyArr _ _ _ xobj = Left $ FailedToQualifySymbols xobj
 
 -- | Qualify a StaticArr form.
 qualifyStaticArr :: Qualifier
 qualifyStaticArr typeEnv globalEnv env (XObj (StaticArr array) i t) =
-  do qualifiedArr <- liftM (map unQualified) (mapM (setFullyQualifiedSymbols typeEnv globalEnv env) array)
+  do
+    qualifiedArr <- liftM (map unQualified) (mapM (setFullyQualifiedSymbols typeEnv globalEnv env) array)
     pure (Qualified (XObj (StaticArr qualifiedArr) i t))
 qualifyStaticArr _ _ _ xobj = Left $ FailedToQualifySymbols xobj

src/StartingEnv.hs

@@ -367,8 +367,8 @@ dynamicStringModule =
 
 unsafeModule :: Env
 unsafeModule =
-  Env {
-    envBindings = bindings,
+  Env
+    { envBindings = bindings,
       envParent = Nothing,
       envModuleName = Just "Unsafe",
       envUseModules = Set.empty,