Apply stylish-haskell

rzk-lang · May 16, 2023 · 7d42ef6 · 7d42ef6
1 parent 37708d4
commit 7d42ef6
Show file tree

Hide file tree

Showing 6 changed files with 148 additions and 147 deletions.
diff --git a/rzk/src/Free/Scoped.hs b/rzk/src/Free/Scoped.hs
@@ -1,23 +1,23 @@
-{-# LANGUAGE DeriveFoldable    #-}
-{-# LANGUAGE StandaloneDeriving #-}
-{-# LANGUAGE QuantifiedConstraints    #-}
-{-# LANGUAGE UndecidableInstances    #-}
-{-# LANGUAGE DeriveFunctor     #-}
-{-# LANGUAGE DeriveGeneric     #-}
-{-# LANGUAGE DeriveTraversable #-}
-{-# LANGUAGE LambdaCase        #-}
-{-# LANGUAGE PatternSynonyms   #-}
-{-# LANGUAGE RankNTypes        #-}
-{-# LANGUAGE TemplateHaskell   #-}
-{-# LANGUAGE TypeOperators     #-}
+{-# LANGUAGE DeriveFoldable        #-}
+{-# LANGUAGE DeriveFunctor         #-}
+{-# LANGUAGE DeriveGeneric         #-}
+{-# LANGUAGE DeriveTraversable     #-}
+{-# LANGUAGE LambdaCase            #-}
+{-# LANGUAGE PatternSynonyms       #-}
+{-# LANGUAGE QuantifiedConstraints #-}
+{-# LANGUAGE RankNTypes            #-}
+{-# LANGUAGE StandaloneDeriving    #-}
+{-# LANGUAGE TemplateHaskell       #-}
+{-# LANGUAGE TypeOperators         #-}
+{-# LANGUAGE UndecidableInstances  #-}
 module Free.Scoped where
 
 import           Control.Monad      (ap)
-import           Data.Function      (on)
 import           Data.Bifoldable
 import           Data.Bifunctor
 import           Data.Bifunctor.TH
 import           Data.Bitraversable
+import           Data.Function      (on)
 import qualified GHC.Generics       as GHC
 
 data Inc var = Z | S var
@@ -78,7 +78,7 @@ deriveBifoldable ''Empty
 deriveBitraversable ''Empty
 
 data AnnF ann term scope typedTerm = AnnF
-  { annF :: ann typedTerm
+  { annF  :: ann typedTerm
   , termF :: term scope typedTerm
   } deriving (Show, Functor)
 
@@ -113,5 +113,5 @@ pattern ExtE t = Free (InR t)
 substitute :: Bifunctor t => FS t a -> Scope (FS t) a -> FS t a
 substitute t = (>>= f)
   where
-    f Z = t
+    f Z     = t
     f (S y) = Pure y
diff --git a/rzk/src/Free/Scoped/TH.hs b/rzk/src/Free/Scoped/TH.hs
@@ -1,11 +1,11 @@
-{-# LANGUAGE CPP      #-}
+{-# LANGUAGE CPP             #-}
 {-# LANGUAGE LambdaCase      #-}
 {-# LANGUAGE TemplateHaskell #-}
 module Free.Scoped.TH where
 
-import           Control.Monad         (replicateM)
-import           Language.Haskell.TH
+import           Control.Monad       (replicateM)
 import           Free.Scoped
+import           Language.Haskell.TH
 
 mkConP :: Name -> [Pat] -> Pat
 #if __GLASGOW_HASKELL__ >= 902

diff --git a/rzk/src/Language/Rzk/Free/Syntax.hs b/rzk/src/Language/Rzk/Free/Syntax.hs
@@ -1,23 +1,23 @@
 {-# OPTIONS_GHC -fno-warn-missing-pattern-synonym-signatures -fno-warn-missing-signatures -fno-warn-type-defaults #-}
-{-# LANGUAGE TemplateHaskell #-}
-{-# LANGUAGE LambdaCase #-}
-{-# LANGUAGE DeriveFunctor #-}
-{-# LANGUAGE DeriveFoldable #-}
-{-# LANGUAGE DeriveTraversable #-}
-{-# LANGUAGE RecordWildCards #-}
-{-# LANGUAGE PatternSynonyms #-}
-{-# LANGUAGE TypeSynonymInstances    #-}
+{-# LANGUAGE DeriveFoldable       #-}
+{-# LANGUAGE DeriveFunctor        #-}
+{-# LANGUAGE DeriveTraversable    #-}
 {-# LANGUAGE FlexibleInstances    #-}
+{-# LANGUAGE LambdaCase           #-}
+{-# LANGUAGE PatternSynonyms      #-}
+{-# LANGUAGE RecordWildCards      #-}
+{-# LANGUAGE TemplateHaskell      #-}
+{-# LANGUAGE TypeSynonymInstances #-}
 module Language.Rzk.Free.Syntax where
 
-import Data.String
-import Data.Char (chr, ord)
-import Data.Coerce
-import Data.List ((\\))
-import Data.Bifunctor.TH
+import           Data.Bifunctor.TH
+import           Data.Char           (chr, ord)
+import           Data.Coerce
+import           Data.List           ((\\))
+import           Data.String
 
-import Free.Scoped
-import Free.Scoped.TH
+import           Free.Scoped
+import           Free.Scoped.TH
 
 import qualified Language.Rzk.Syntax as Rzk
 
@@ -103,7 +103,7 @@ toScope x bvars = toTerm $ \z -> if x == z then Pure Z else S <$> bvars z
 toScopePattern :: Rzk.Pattern -> (Rzk.VarIdent -> Term a) -> Rzk.Term -> Scope Term a
 toScopePattern pat bvars = toTerm $ \z ->
   case lookup z (bindings pat (Pure Z)) of
-    Just t -> t
+    Just t  -> t
     Nothing -> S <$> bvars z
   where
     bindings (Rzk.PatternWildcard _loc)   _ = []
@@ -176,7 +176,7 @@ toTerm bvars = go
 
 
     patternVar (Rzk.PatternVar _loc x) = Just x
-    patternVar _ = Nothing
+    patternVar _                       = Nothing
 
 fromTerm' :: Term' -> Rzk.Term
 fromTerm' t = fromTermWith' vars (defaultVarIdents \\ vars) t
@@ -185,7 +185,7 @@ fromTerm' t = fromTermWith' vars (defaultVarIdents \\ vars) t
 fromScope' :: Rzk.VarIdent -> [Rzk.VarIdent] -> [Rzk.VarIdent] -> Scope Term Rzk.VarIdent -> Rzk.Term
 fromScope' x used xs = fromTermWith' (x : used) xs . (>>= f)
   where
-    f Z = Pure x
+    f Z     = Pure x
     f (S z) = Pure z
 
 fromTermWith' :: [Rzk.VarIdent] -> [Rzk.VarIdent] -> Term' -> Rzk.Term
@@ -194,7 +194,7 @@ fromTermWith' used vars = go
     withFresh Nothing f =
       case vars of
         x:xs -> f (x, xs)
-        _ -> error "not enough fresh variables!"
+        _    -> error "not enough fresh variables!"
     withFresh (Just z) f = f (z', filter (/= z') vars)    -- FIXME: very inefficient filter
       where
         z' = refreshVar used z
@@ -290,7 +290,7 @@ instance IsString Term' where
   fromString = toTerm' . fromRight . Rzk.parseTerm
     where
       fromRight (Left err) = error ("Parse error: " <> err)
-      fromRight (Right t) = t
+      fromRight (Right t)  = t
 
 instance Show TermT' where
   show var@Pure{} = Rzk.printTree (fromTerm' (untyped var))

diff --git a/rzk/src/Language/Rzk/Syntax.hs b/rzk/src/Language/Rzk/Syntax.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE LambdaCase        #-}
 {-# LANGUAGE OverloadedStrings #-}
 module Language.Rzk.Syntax (
   module Language.Rzk.Syntax.Abs,
@@ -12,15 +12,15 @@ module Language.Rzk.Syntax (
   extractMarkdownCodeBlocks,
 ) where
 
-import qualified Data.List as List
-import Data.Char (isSpace)
+import           Data.Char                  (isSpace)
+import qualified Data.List                  as List
 
-import Language.Rzk.Syntax.Abs
-import Language.Rzk.Syntax.Print (printTree)
+import           Language.Rzk.Syntax.Abs
+import           Language.Rzk.Syntax.Print  (printTree)
 
-import Language.Rzk.Syntax.Lex (tokens)
-import Language.Rzk.Syntax.Par (pModule, pTerm)
-import Language.Rzk.Syntax.Layout (resolveLayout)
+import           Language.Rzk.Syntax.Layout (resolveLayout)
+import           Language.Rzk.Syntax.Lex    (tokens)
+import           Language.Rzk.Syntax.Par    (pModule, pTerm)
 
 parseModule :: String -> Either String Module
 parseModule = pModule . resolveLayout True . tokens . tryExtractMarkdownCodeBlocks "rzk"

diff --git a/rzk/src/Rzk/Main.hs b/rzk/src/Rzk/Main.hs
@@ -1,11 +1,11 @@
 module Rzk.Main where
 
-import System.Exit (exitFailure)
-import System.Environment (getArgs)
-import Control.Monad (forM)
+import           Control.Monad       (forM)
+import           System.Environment  (getArgs)
+import           System.Exit         (exitFailure)
 
 import qualified Language.Rzk.Syntax as Rzk
-import Rzk.TypeCheck
+import           Rzk.TypeCheck
 
 main :: IO ()
 main = do