sort imported items and align equal signs

Author: itchyny

src/File.hs

@@ -6,12 +6,12 @@ import Control.Monad (guard, when)
 import Data.ByteString.Lazy qualified as ByteString
 import Data.ByteString.Lazy.Char8 qualified as Char8
 import Data.Char (isSpace)
-import Data.List.NonEmpty (NonEmpty((:|)), (<|), head, tail,
-                           uncons, prependList, toList)
+import Data.List.NonEmpty (NonEmpty((:|)), head, prependList, tail, toList,
+                           uncons, (<|))
 import Data.Tuple.Extra (second)
-import Prelude hiding (head, tail)
 import System.Exit (exitFailure)
 import System.IO
+import Prelude hiding (head, tail)
 
 import Option
 
@@ -40,11 +40,11 @@ readFromFile opts handle = do
   return (columns, body)
   where joinMultiLines (cs:ds:css) | valid True cs = cs <| joinMultiLines (ds:css)
                                    | otherwise = joinMultiLines $ (cs ++ "\n" ++ ds) : css
-          where valid False ('"':'"':xs) = valid False xs
+          where valid False ('"':'"':xs)  = valid False xs
                 valid False ('\\':'"':xs) = valid False xs
-                valid b ('"':xs) = valid (not b) xs
-                valid b (_:xs) = valid b xs
-                valid b "" = b
+                valid b ('"':xs)          = valid (not b) xs
+                valid b (_:xs)            = valid b xs
+                valid b ""                = b
         joinMultiLines (cs:css) = cs :| css
         joinMultiLines [] = "" :| []
 

src/Main.hs

@@ -1,14 +1,14 @@
 module Main where
 
 import Control.Applicative ((<|>))
-import Control.Monad (forM_, guard, when, unless)
+import Control.Monad (forM_, guard, unless, when)
 import Data.Char (isSpace)
-import Data.List (isSuffixOf, intercalate, transpose)
+import Data.List (intercalate, isSuffixOf, transpose)
 import Data.Map qualified as Map
 import Data.Maybe (fromMaybe, isJust)
-import Data.Set as Set ((\\), fromList, union)
+import Data.Set as Set (fromList, union, (\\))
 import Database.SQLite.Simple qualified as SQLite
-import Options.Applicative (execParser, helper, info, fullDesc, header)
+import Options.Applicative (execParser, fullDesc, header, helper, info)
 import System.Exit (exitFailure)
 import System.IO
 import Text.Read (readMaybe)
@@ -56,7 +56,7 @@ fetchQuery opts = do
     hPutStrLn stderr "Can't provide both a query file and a query on the command line."
     exitFailure
   query <- fromMaybe "" <$> case opts.query of
-                                 Just q -> return (Just q)
+                                 Just q  -> return (Just q)
                                  Nothing -> mapM readFile opts.queryFile
   when (all isSpace query) $ do
     hPutStrLn stderr "Query cannot be empty."

src/Option.hs

@@ -8,18 +8,18 @@ import Paths_qhs qualified as QHS
 -- | Command options
 data Option =
   Option {
-    skipHeader :: Bool,
-    outputHeader :: Bool,
-    delimiter :: Maybe String,
-    tabDelimited :: Bool,
-    pipeDelimited :: Bool,
-    outputDelimiter :: Maybe String,
-    tabDelimitedOutput :: Bool,
-    pipeDelimitedOutput :: Bool,
+    skipHeader            :: Bool,
+    outputHeader          :: Bool,
+    delimiter             :: Maybe String,
+    tabDelimited          :: Bool,
+    pipeDelimited         :: Bool,
+    outputDelimiter       :: Maybe String,
+    tabDelimitedOutput    :: Bool,
+    pipeDelimitedOutput   :: Bool,
     keepLeadingWhiteSpace :: Bool,
-    gzipped :: Bool,
-    queryFile :: Maybe String,
-    query :: Maybe String
+    gzipped               :: Bool,
+    queryFile             :: Maybe String,
+    query                 :: Maybe String
   }
 
 -- | Option parser

src/Parser.hs

@@ -67,7 +67,7 @@ extractTableNames :: String -> FilePath -> Either Parse.ParseError [String]
 extractTableNames query path = everything (++) ([] `mkQ` tableNames)
                             <$> Parse.parseQueryExpr Dialect.mysql (Text.pack path) Nothing (Text.pack query)
   where tableNames (Syntax.TRSimple (name:_)) = fromName name
-        tableNames _ = []
+        tableNames _                          = []
         fromName (Syntax.Name _ name) = [Text.unpack name]
 
 errorString :: Parse.ParseError -> String

src/SQL.hs

@@ -1,6 +1,6 @@
 module SQL (open, close, createTable, insertRow, execute) where
 
-import Control.Exception (try, SomeException)
+import Control.Exception (SomeException, try)
 import Control.Monad (forM)
 import Data.List (intercalate)
 import Data.String (fromString)

src/SQLType.hs

@@ -16,11 +16,11 @@ data SQLType = SQLChar | SQLInt
 
 instance Show SQLType where
   show SQLChar = "CHAR"
-  show SQLInt = "INTEGER"
+  show SQLInt  = "INTEGER"
 
 instance ToField (SQLType, String) where
   toField (SQLChar, cs) = SQLText $ Text.pack cs
-  toField (SQLInt, cs) = maybe SQLNull SQLFloat $ readMaybe cs
+  toField (SQLInt, cs)  = maybe SQLNull SQLFloat $ readMaybe cs
 
 data Any = AnyDouble Double | AnyInt Int | AnyString String | AnyNull
          deriving Eq
@@ -40,9 +40,9 @@ instance IsString Any where
 
 instance Show Any where
   show (AnyDouble d) = show d
-  show (AnyInt i) = show i
+  show (AnyInt i)    = show i
   show (AnyString s) = s
-  show AnyNull = ""
+  show AnyNull       = ""
 
 fromColumnsAndEntries :: [String] -> [[String]] -> ([String], [[Any]])
 fromColumnsAndEntries columns xs = (columns, map (map fromString) xs)