Format imports

.vscode/settings.json

@@ -1,5 +1,5 @@
 {
-    "purple-yolk.brittany.command": "false",
+    "purple-yolk.brittany.command": "cabal exec -- brittany --write-mode inplace",
     "purple-yolk.ghci.command": "cabal repl --repl-options -ddump-json",
     "purple-yolk.hlint.command": "false",
     "purple-yolk.hlint.onSave": false

brittany.yaml

@@ -0,0 +1,4 @@
+conf_layout:
+  lconfig_columnAlignMode:
+    tag: ColumnAlignModeDisabled
+  lconfig_indentPolicy: IndentPolicyLeft

source/library/Language/Haskell/Brittany.hs

@@ -16,13 +16,9 @@ module Language.Haskell.Brittany
   , CForwardOptions(..)
   , CPreProcessorConfig(..)
   , BrittanyError(..)
-  )
+  ) where
-where
-
-
-
 
 import Language.Haskell.Brittany.Internal
-import           Language.Haskell.Brittany.Internal.Types
-import           Language.Haskell.Brittany.Internal.Config.Types
 import Language.Haskell.Brittany.Internal.Config
+import Language.Haskell.Brittany.Internal.Config.Types
+import Language.Haskell.Brittany.Internal.Types

source/library/Language/Haskell/Brittany/Internal.hs

@@ -12,66 +12,52 @@ module Language.Haskell.Brittany.Internal
   , parseModuleFromString
   , extractCommentConfigs
   , getTopLevelDeclNameMap
-  )
+  ) where
-where
 
-
+import Control.Monad.Trans.Except
-
-import Language.Haskell.Brittany.Internal.Prelude
-import Language.Haskell.Brittany.Internal.PreludeUtils
 import qualified Control.Monad.Trans.MultiRWS.Strict as MultiRWSS
 import qualified Data.ByteString.Char8
+import Data.CZipWith
+import Data.Char (isSpace)
+import Data.HList.HList
 import qualified Data.Map as Map
 import qualified Data.Maybe
 import qualified Data.Semigroup as Semigroup
 import qualified Data.Sequence as Seq
 import qualified Data.Text as Text
 import qualified Data.Text.Lazy as TextL
-import qualified GHC.OldList as List
-
--- brittany { lconfig_importAsColumn: 60, lconfig_importColumn: 60 }
-import qualified Language.Haskell.GHC.ExactPrint         as ExactPrint
-import qualified Language.Haskell.GHC.ExactPrint.Types   as ExactPrint
-import qualified Language.Haskell.GHC.ExactPrint.Parsers as ExactPrint.Parsers
-
-import           Control.Monad.Trans.Except
-import           Data.HList.HList
-import qualified Data.Yaml
-import           Data.CZipWith
-import qualified UI.Butcher.Monadic                      as Butcher
-
 import qualified Data.Text.Lazy.Builder as Text.Builder
-
+import qualified Data.Yaml
-import           Language.Haskell.Brittany.Internal.Types
+import qualified GHC hiding (parseModule)
-import           Language.Haskell.Brittany.Internal.Config.Types
+import GHC (GenLocated(L))
-import           Language.Haskell.Brittany.Internal.Config
-import           Language.Haskell.Brittany.Internal.LayouterBasics
-
-import           Language.Haskell.Brittany.Internal.Layouters.Decl
-import           Language.Haskell.Brittany.Internal.Layouters.Module
-import           Language.Haskell.Brittany.Internal.Utils
-import           Language.Haskell.Brittany.Internal.Backend
-import           Language.Haskell.Brittany.Internal.BackendUtils
-import           Language.Haskell.Brittany.Internal.ExactPrintUtils
-
-import           Language.Haskell.Brittany.Internal.Transformations.Alt
-import           Language.Haskell.Brittany.Internal.Transformations.Floating
-import           Language.Haskell.Brittany.Internal.Transformations.Par
-import           Language.Haskell.Brittany.Internal.Transformations.Columns
-import           Language.Haskell.Brittany.Internal.Transformations.Indent
-
-import qualified GHC
-                                                   hiding ( parseModule )
-import           GHC.Parser.Annotation                            ( AnnKeywordId(..) )
-import           GHC                                      ( GenLocated(L)
-                                                          )
-import           GHC.Types.SrcLoc                                   ( SrcSpan )
-import           GHC.Hs
 import GHC.Data.Bag
 import qualified GHC.Driver.Session as GHC
+import GHC.Hs
 import qualified GHC.LanguageExtensions.Type as GHC
-
+import qualified GHC.OldList as List
-import           Data.Char                                ( isSpace )
+import GHC.Parser.Annotation (AnnKeywordId(..))
+import GHC.Types.SrcLoc (SrcSpan)
+import Language.Haskell.Brittany.Internal.Backend
+import Language.Haskell.Brittany.Internal.BackendUtils
+import Language.Haskell.Brittany.Internal.Config
+import Language.Haskell.Brittany.Internal.Config.Types
+import Language.Haskell.Brittany.Internal.ExactPrintUtils
+import Language.Haskell.Brittany.Internal.LayouterBasics
+import Language.Haskell.Brittany.Internal.Layouters.Decl
+import Language.Haskell.Brittany.Internal.Layouters.Module
+import Language.Haskell.Brittany.Internal.Prelude
+import Language.Haskell.Brittany.Internal.PreludeUtils
+import Language.Haskell.Brittany.Internal.Transformations.Alt
+import Language.Haskell.Brittany.Internal.Transformations.Columns
+import Language.Haskell.Brittany.Internal.Transformations.Floating
+import Language.Haskell.Brittany.Internal.Transformations.Indent
+import Language.Haskell.Brittany.Internal.Transformations.Par
+import Language.Haskell.Brittany.Internal.Types
+import Language.Haskell.Brittany.Internal.Utils
+import qualified Language.Haskell.GHC.ExactPrint as ExactPrint
+import qualified Language.Haskell.GHC.ExactPrint.Parsers as ExactPrint.Parsers
+import qualified Language.Haskell.GHC.ExactPrint.Types as ExactPrint
+import qualified UI.Butcher.Monadic as Butcher
 
 
 

source/library/Language/Haskell/Brittany/Internal/Backend.hs

@@ -6,10 +6,6 @@
 
 module Language.Haskell.Brittany.Internal.Backend where
 
-
-
-import Language.Haskell.Brittany.Internal.Prelude
-import Language.Haskell.Brittany.Internal.PreludeUtils
 import qualified Control.Monad.Trans.State.Strict as StateS
 import qualified Data.Either as Either
 import qualified Data.Foldable as Foldable
@@ -21,20 +17,18 @@ import qualified Data.Semigroup as Semigroup
 import qualified Data.Sequence as Seq
 import qualified Data.Set as Set
 import qualified Data.Text as Text
+import qualified Data.Text.Lazy.Builder as Text.Builder
 import qualified GHC.OldList as List
-
+import Language.Haskell.Brittany.Internal.BackendUtils
+import Language.Haskell.Brittany.Internal.Config.Types
+import Language.Haskell.Brittany.Internal.LayouterBasics
+import Language.Haskell.Brittany.Internal.Prelude
+import Language.Haskell.Brittany.Internal.PreludeUtils
+import Language.Haskell.Brittany.Internal.Types
+import Language.Haskell.Brittany.Internal.Utils
 import qualified Language.Haskell.GHC.ExactPrint as ExactPrint
 import qualified Language.Haskell.GHC.ExactPrint.Types as ExactPrint.Types
 
-import           Language.Haskell.Brittany.Internal.LayouterBasics
-import           Language.Haskell.Brittany.Internal.BackendUtils
-import           Language.Haskell.Brittany.Internal.Utils
-import           Language.Haskell.Brittany.Internal.Config.Types
-import           Language.Haskell.Brittany.Internal.Types
-
-
-import qualified Data.Text.Lazy.Builder as Text.Builder
-
 
 
 type ColIndex  = Int

source/library/Language/Haskell/Brittany/Internal/BackendUtils.hs

@@ -3,28 +3,22 @@
 
 module Language.Haskell.Brittany.Internal.BackendUtils where
 
-
-import Language.Haskell.Brittany.Internal.Prelude
-import Language.Haskell.Brittany.Internal.PreludeUtils
 import qualified Data.Data
 import qualified Data.Either
 import qualified Data.Map as Map
 import qualified Data.Maybe
 import qualified Data.Semigroup as Semigroup
 import qualified Data.Text as Text
-import qualified GHC.OldList as List
-
-import           Language.Haskell.Brittany.Internal.Types
-import           Language.Haskell.Brittany.Internal.Config.Types
-import           Language.Haskell.GHC.ExactPrint.Types ( AnnKey
-                                                       , Annotation
-                                                       )
-
 import qualified Data.Text.Lazy.Builder as Text.Builder
-import qualified Language.Haskell.GHC.ExactPrint.Types as ExactPrint
-import           Language.Haskell.Brittany.Internal.Utils
-
 import GHC (Located)
+import qualified GHC.OldList as List
+import Language.Haskell.Brittany.Internal.Config.Types
+import Language.Haskell.Brittany.Internal.Prelude
+import Language.Haskell.Brittany.Internal.PreludeUtils
+import Language.Haskell.Brittany.Internal.Types
+import Language.Haskell.Brittany.Internal.Utils
+import Language.Haskell.GHC.ExactPrint.Types (AnnKey, Annotation)
+import qualified Language.Haskell.GHC.ExactPrint.Types as ExactPrint
 
 
 

source/library/Language/Haskell/Brittany/Internal/Config.hs

@@ -3,36 +3,26 @@
 
 module Language.Haskell.Brittany.Internal.Config where
 
-
-
-import Language.Haskell.Brittany.Internal.Prelude
-import Language.Haskell.Brittany.Internal.PreludeUtils
 import qualified Data.Bool as Bool
 import qualified Data.ByteString as ByteString
 import qualified Data.ByteString.Char8
-import qualified Data.Semigroup as Semigroup
-import qualified GHC.OldList as List
-import qualified System.Directory
-import qualified System.IO
-
-import qualified Data.Yaml
 import Data.CZipWith
-
+import Data.Coerce (coerce)
-import           UI.Butcher.Monadic
+import qualified Data.List.NonEmpty as NonEmpty
-
+import qualified Data.Semigroup as Semigroup
-import qualified System.Console.CmdArgs.Explicit
+import qualified Data.Yaml
-                                               as CmdArgs
+import qualified GHC.OldList as List
-
 import Language.Haskell.Brittany.Internal.Config.Types
 import Language.Haskell.Brittany.Internal.Config.Types.Instances ()
+import Language.Haskell.Brittany.Internal.Prelude
+import Language.Haskell.Brittany.Internal.PreludeUtils
 import Language.Haskell.Brittany.Internal.Utils
-
+import qualified System.Console.CmdArgs.Explicit as CmdArgs
-import           Data.Coerce                    ( coerce
+import qualified System.Directory
-                                                )
-import qualified Data.List.NonEmpty            as NonEmpty
-
 import qualified System.Directory as Directory
 import qualified System.FilePath.Posix as FilePath
+import qualified System.IO
+import UI.Butcher.Monadic
 
 -- brittany-next-binding { lconfig_indentPolicy: IndentPolicyLeft }
 staticDefaultConfig :: Config

source/library/Language/Haskell/Brittany/Internal/Config/Types.hs

@@ -7,22 +7,15 @@
 
 module Language.Haskell.Brittany.Internal.Config.Types where
 
-
+import Data.CZipWith
-
+import Data.Coerce (Coercible, coerce)
+import Data.Data (Data)
+import qualified Data.Semigroup as Semigroup
+import Data.Semigroup (Last)
+import Data.Semigroup.Generic
+import GHC.Generics
 import Language.Haskell.Brittany.Internal.Prelude
 import Language.Haskell.Brittany.Internal.PreludeUtils ()
-import qualified Data.Semigroup as Semigroup
-
-import GHC.Generics
-
-import Data.Data ( Data )
-
-import Data.Coerce ( Coercible, coerce )
-
-import Data.Semigroup.Generic
-import Data.Semigroup ( Last )
-
-import Data.CZipWith
 
 
 

source/library/Language/Haskell/Brittany/Internal/Config/Types/Instances.hs

@@ -18,15 +18,11 @@
 
 module Language.Haskell.Brittany.Internal.Config.Types.Instances where
 
-
-
-import Language.Haskell.Brittany.Internal.Prelude
-
-import Data.Yaml
 import qualified Data.Aeson.Key as Key
 import qualified Data.Aeson.Types as Aeson
-
+import Data.Yaml
 import Language.Haskell.Brittany.Internal.Config.Types
+import Language.Haskell.Brittany.Internal.Prelude
 
 
 

source/library/Language/Haskell/Brittany/Internal/ExactPrintUtils.hs

@@ -7,45 +7,34 @@
 
 module Language.Haskell.Brittany.Internal.ExactPrintUtils where
 
-
+import Control.Exception
-
-import Language.Haskell.Brittany.Internal.Prelude
-import Language.Haskell.Brittany.Internal.PreludeUtils
 import qualified Control.Monad.State.Class as State.Class
 import qualified Control.Monad.Trans.Except as ExceptT
 import qualified Control.Monad.Trans.MultiRWS.Strict as MultiRWSS
+import Data.Data
 import qualified Data.Foldable as Foldable
+import qualified Data.Generics as SYB
+import Data.HList.HList
 import qualified Data.Map as Map
 import qualified Data.Maybe
 import qualified Data.Sequence as Seq
 import qualified Data.Set as Set
-import qualified System.IO
-
-import           Language.Haskell.Brittany.Internal.Config.Types
-import           Data.Data
-import           Data.HList.HList
-
 import GHC (GenLocated(L))
-import qualified GHC.Driver.Session      as GHC
 import qualified GHC hiding (parseModule)
-import qualified GHC.Types.SrcLoc        as GHC
-import qualified GHC.Driver.CmdLine as GHC
-
-import           GHC.Hs
 import GHC.Data.Bag
-
+import qualified GHC.Driver.CmdLine as GHC
-import           GHC.Types.SrcLoc ( SrcSpan, Located )
+import qualified GHC.Driver.Session as GHC
-
+import GHC.Hs
-
+import qualified GHC.Types.SrcLoc as GHC
+import GHC.Types.SrcLoc (Located, SrcSpan)
+import Language.Haskell.Brittany.Internal.Config.Types
+import Language.Haskell.Brittany.Internal.Prelude
+import Language.Haskell.Brittany.Internal.PreludeUtils
 import qualified Language.Haskell.GHC.ExactPrint as ExactPrint
-import qualified Language.Haskell.GHC.ExactPrint.Types      as ExactPrint
-import qualified Language.Haskell.GHC.ExactPrint.Parsers    as ExactPrint
 import qualified Language.Haskell.GHC.ExactPrint.Delta as ExactPrint
-
+import qualified Language.Haskell.GHC.ExactPrint.Parsers as ExactPrint
-import qualified Data.Generics as SYB
+import qualified Language.Haskell.GHC.ExactPrint.Types as ExactPrint
-
+import qualified System.IO
-import           Control.Exception
--- import           Data.Generics.Schemes
 
 
 

source/library/Language/Haskell/Brittany/Internal/LayouterBasics.hs

@@ -6,47 +6,36 @@
 
 module Language.Haskell.Brittany.Internal.LayouterBasics where
 
-
-
-import Language.Haskell.Brittany.Internal.Prelude
-import Language.Haskell.Brittany.Internal.PreludeUtils
 import qualified Control.Monad.Trans.MultiRWS.Strict as MultiRWSS
+import qualified Control.Monad.Writer.Strict as Writer
+import qualified Data.Char as Char
+import Data.Data
 import qualified Data.Map as Map
 import qualified Data.Semigroup as Semigroup
 import qualified Data.Sequence as Seq
 import qualified Data.Set as Set
 import qualified Data.Text as Text
+import qualified Data.Text.Lazy.Builder as Text.Builder
+import DataTreePrint
+import GHC (GenLocated(L), Located, moduleName, moduleNameString)
 import qualified GHC.OldList as List
-
+import GHC.Parser.Annotation (AnnKeywordId(..))
-import qualified Control.Monad.Writer.Strict as Writer
+import GHC.Types.Name (getOccString)
-
+import GHC.Types.Name.Occurrence (occNameString)
+import GHC.Types.Name.Reader (RdrName(..))
+import qualified GHC.Types.SrcLoc as GHC
+import Language.Haskell.Brittany.Internal.Config.Types
+import Language.Haskell.Brittany.Internal.ExactPrintUtils
+import Language.Haskell.Brittany.Internal.Prelude
+import Language.Haskell.Brittany.Internal.PreludeUtils
+import Language.Haskell.Brittany.Internal.Types
+import Language.Haskell.Brittany.Internal.Utils
 import qualified Language.Haskell.GHC.ExactPrint as ExactPrint
 import qualified Language.Haskell.GHC.ExactPrint.Annotate as ExactPrint.Annotate
 import qualified Language.Haskell.GHC.ExactPrint.Types as ExactPrint.Types
 import qualified Language.Haskell.GHC.ExactPrint.Types as ExactPrint
-import qualified Language.Haskell.GHC.ExactPrint.Utils as ExactPrint.Utils
-
 import Language.Haskell.GHC.ExactPrint.Types (AnnKey, Annotation)
-
+import qualified Language.Haskell.GHC.ExactPrint.Utils as ExactPrint.Utils
-import qualified Data.Text.Lazy.Builder as Text.Builder
-
-import Language.Haskell.Brittany.Internal.Config.Types
-import Language.Haskell.Brittany.Internal.Types
-import Language.Haskell.Brittany.Internal.Utils
-import Language.Haskell.Brittany.Internal.ExactPrintUtils
-
-import           GHC.Types.Name.Reader ( RdrName(..) )
-import           GHC ( Located, GenLocated(L), moduleName, moduleNameString )
-import qualified GHC.Types.SrcLoc        as GHC
-import           GHC.Types.Name.Occurrence ( occNameString )
-import           GHC.Types.Name ( getOccString )
-import           GHC.Parser.Annotation ( AnnKeywordId(..) )
-
-import           Data.Data
-
-import qualified Data.Char as Char
-
-import           DataTreePrint
 
 
 

source/library/Language/Haskell/Brittany/Internal/Layouters/DataDecl.hs

@@ -3,24 +3,19 @@
 
 module Language.Haskell.Brittany.Internal.Layouters.DataDecl where
 
-
-
-import Language.Haskell.Brittany.Internal.Prelude
-import Language.Haskell.Brittany.Internal.PreludeUtils
 import qualified Data.Data
 import qualified Data.Semigroup as Semigroup
 import qualified Data.Text as Text
-import qualified GHC.OldList as List
+import GHC (GenLocated(L), Located)
-
-import           Language.Haskell.Brittany.Internal.Types
-import           Language.Haskell.Brittany.Internal.LayouterBasics
-import           Language.Haskell.Brittany.Internal.Config.Types
-
-import           GHC ( Located, GenLocated(L) )
 import qualified GHC
 import GHC.Hs
-
+import qualified GHC.OldList as List
+import Language.Haskell.Brittany.Internal.Config.Types
+import Language.Haskell.Brittany.Internal.LayouterBasics
 import Language.Haskell.Brittany.Internal.Layouters.Type
+import Language.Haskell.Brittany.Internal.Prelude
+import Language.Haskell.Brittany.Internal.PreludeUtils
+import Language.Haskell.Brittany.Internal.Types
 
 
 

source/library/Language/Haskell/Brittany/Internal/Layouters/Decl.hs

@@ -5,46 +5,38 @@
 
 module Language.Haskell.Brittany.Internal.Layouters.Decl where
 
-
-
-import Language.Haskell.Brittany.Internal.Prelude
-import Language.Haskell.Brittany.Internal.PreludeUtils
 import qualified Data.Data
 import qualified Data.Foldable
 import qualified Data.Maybe
 import qualified Data.Semigroup as Semigroup
 import qualified Data.Text as Text
-import qualified GHC.OldList as List
+import GHC (AnnKeywordId(..), GenLocated(L))
-
+import GHC.Data.Bag (bagToList, emptyBag)
-import           Language.Haskell.Brittany.Internal.Types
-import           Language.Haskell.Brittany.Internal.LayouterBasics
-import           Language.Haskell.Brittany.Internal.Config.Types
-import           Language.Haskell.Brittany.Internal.Layouters.Type
-
-import qualified Language.Haskell.GHC.ExactPrint as ExactPrint
-import qualified Language.Haskell.GHC.ExactPrint.Utils as ExactPrint
-import           Language.Haskell.Brittany.Internal.ExactPrintUtils
-
-import           GHC                            ( GenLocated(L)
-                                                , AnnKeywordId(..)
-                                                )
-import           GHC.Types.SrcLoc ( SrcSpan, Located , getLoc, unLoc )
 import qualified GHC.Data.FastString as FastString
 import GHC.Hs
-import           GHC.Types.Basic ( InlinePragma(..)
+import qualified GHC.OldList as List
-                            , Activation(..)
+import GHC.Types.Basic
+  ( Activation(..)
+  , InlinePragma(..)
   , InlineSpec(..)
-                            , RuleMatchInfo(..)
   , LexicalFixity(..)
+  , RuleMatchInfo(..)
   )
-import           Language.Haskell.GHC.ExactPrint.Types ( mkAnnKey )
+import GHC.Types.SrcLoc (Located, SrcSpan, getLoc, unLoc)
-
+import Language.Haskell.Brittany.Internal.Config.Types
-import {-# SOURCE #-} Language.Haskell.Brittany.Internal.Layouters.Expr
+import Language.Haskell.Brittany.Internal.ExactPrintUtils
-import {-# SOURCE #-} Language.Haskell.Brittany.Internal.Layouters.Stmt
+import Language.Haskell.Brittany.Internal.LayouterBasics
-import           Language.Haskell.Brittany.Internal.Layouters.Pattern
 import Language.Haskell.Brittany.Internal.Layouters.DataDecl
-
+import {-# SOURCE #-} Language.Haskell.Brittany.Internal.Layouters.Expr
-import           GHC.Data.Bag ( bagToList, emptyBag )
+import Language.Haskell.Brittany.Internal.Layouters.Pattern
+import {-# SOURCE #-} Language.Haskell.Brittany.Internal.Layouters.Stmt
+import Language.Haskell.Brittany.Internal.Layouters.Type
+import Language.Haskell.Brittany.Internal.Prelude
+import Language.Haskell.Brittany.Internal.PreludeUtils
+import Language.Haskell.Brittany.Internal.Types
+import qualified Language.Haskell.GHC.ExactPrint as ExactPrint
+import Language.Haskell.GHC.ExactPrint.Types (mkAnnKey)
+import qualified Language.Haskell.GHC.ExactPrint.Utils as ExactPrint
 
 
 

source/library/Language/Haskell/Brittany/Internal/Layouters/Expr.hs

@@ -4,31 +4,26 @@
 
 module Language.Haskell.Brittany.Internal.Layouters.Expr where
 
-
-
-import Language.Haskell.Brittany.Internal.Prelude
-import Language.Haskell.Brittany.Internal.PreludeUtils
 import qualified Data.Data
 import qualified Data.Semigroup as Semigroup
 import qualified Data.Sequence as Seq
 import qualified Data.Text as Text
-import qualified GHC.OldList as List
+import GHC (AnnKeywordId(..), GenLocated(L), RdrName(..), SrcSpan)
-
-import           Language.Haskell.Brittany.Internal.Types
-import           Language.Haskell.Brittany.Internal.LayouterBasics
-import           Language.Haskell.Brittany.Internal.Config.Types
-
-import           GHC ( GenLocated(L), SrcSpan, AnnKeywordId(..), RdrName(..) )
-import           GHC.Hs
-import           GHC.Types.Name
 import qualified GHC.Data.FastString as FastString
+import GHC.Hs
+import qualified GHC.OldList as List
 import GHC.Types.Basic
-
+import GHC.Types.Name
-import           Language.Haskell.Brittany.Internal.Utils
+import Language.Haskell.Brittany.Internal.Config.Types
-import           Language.Haskell.Brittany.Internal.Layouters.Pattern
+import Language.Haskell.Brittany.Internal.LayouterBasics
 import Language.Haskell.Brittany.Internal.Layouters.Decl
+import Language.Haskell.Brittany.Internal.Layouters.Pattern
 import Language.Haskell.Brittany.Internal.Layouters.Stmt
 import Language.Haskell.Brittany.Internal.Layouters.Type
+import Language.Haskell.Brittany.Internal.Prelude
+import Language.Haskell.Brittany.Internal.PreludeUtils
+import Language.Haskell.Brittany.Internal.Types
+import Language.Haskell.Brittany.Internal.Utils
 
 
 

source/library/Language/Haskell/Brittany/Internal/Layouters/Expr.hs-boot

@@ -2,13 +2,8 @@
 
 module Language.Haskell.Brittany.Internal.Layouters.Expr where
 
-
-
-import Language.Haskell.Brittany.Internal.Prelude
-
-import           Language.Haskell.Brittany.Internal.Types
-
 import GHC.Hs
+import Language.Haskell.Brittany.Internal.Types
 
 
 

source/library/Language/Haskell/Brittany/Internal/Layouters/IE.hs

@@ -4,23 +4,21 @@
 
 module Language.Haskell.Brittany.Internal.Layouters.IE where
 
-import Language.Haskell.Brittany.Internal.Prelude
 import qualified Data.List.Extra
 import qualified Data.Text as Text
-import qualified GHC.OldList as List
+import GHC
-
+  ( AnnKeywordId(..)
-import           Language.Haskell.Brittany.Internal.Types
-import           Language.Haskell.Brittany.Internal.LayouterBasics
-
-import           GHC     ( unLoc
   , GenLocated(L)
-                         , moduleNameString
-                         , AnnKeywordId(..)
   , Located
   , ModuleName
+  , moduleNameString
+  , unLoc
   )
 import GHC.Hs
-
+import qualified GHC.OldList as List
+import Language.Haskell.Brittany.Internal.LayouterBasics
+import Language.Haskell.Brittany.Internal.Prelude
+import Language.Haskell.Brittany.Internal.Types
 import Language.Haskell.Brittany.Internal.Utils
 
 

source/library/Language/Haskell/Brittany/Internal/Layouters/Import.hs

@@ -2,24 +2,18 @@
 
 module Language.Haskell.Brittany.Internal.Layouters.Import where
 
-import Language.Haskell.Brittany.Internal.Prelude
-import Language.Haskell.Brittany.Internal.PreludeUtils
 import qualified Data.Semigroup as Semigroup
 import qualified Data.Text as Text
-
+import GHC (GenLocated(L), Located, moduleNameString, unLoc)
-import           Language.Haskell.Brittany.Internal.Types
-import           Language.Haskell.Brittany.Internal.LayouterBasics
-import           Language.Haskell.Brittany.Internal.Layouters.IE
-import           Language.Haskell.Brittany.Internal.Config.Types
-
-import           GHC                                      ( unLoc
-                                                          , GenLocated(L)
-                                                          , moduleNameString
-                                                          , Located
-                                                          )
 import GHC.Hs
 import GHC.Types.Basic
 import GHC.Unit.Types (IsBootInterface(..))
+import Language.Haskell.Brittany.Internal.Config.Types
+import Language.Haskell.Brittany.Internal.LayouterBasics
+import Language.Haskell.Brittany.Internal.Layouters.IE
+import Language.Haskell.Brittany.Internal.Prelude
+import Language.Haskell.Brittany.Internal.PreludeUtils
+import Language.Haskell.Brittany.Internal.Types
 
 
 

source/library/Language/Haskell/Brittany/Internal/Layouters/Module.hs

@@ -3,27 +3,22 @@
 
 module Language.Haskell.Brittany.Internal.Layouters.Module where
 
-import Language.Haskell.Brittany.Internal.Prelude
-import Language.Haskell.Brittany.Internal.PreludeUtils
 import qualified Data.Maybe
 import qualified Data.Semigroup as Semigroup
 import qualified Data.Text as Text
+import GHC (AnnKeywordId(..), GenLocated(L), moduleNameString, unLoc)
+import GHC.Hs
 import qualified GHC.OldList as List
-
+import Language.Haskell.Brittany.Internal.Config.Types
-import           Language.Haskell.Brittany.Internal.Types
 import Language.Haskell.Brittany.Internal.LayouterBasics
 import Language.Haskell.Brittany.Internal.Layouters.IE
 import Language.Haskell.Brittany.Internal.Layouters.Import
-import           Language.Haskell.Brittany.Internal.Config.Types
+import Language.Haskell.Brittany.Internal.Prelude
-
+import Language.Haskell.Brittany.Internal.PreludeUtils
-import GHC (unLoc, GenLocated(L), moduleNameString, AnnKeywordId(..))
+import Language.Haskell.Brittany.Internal.Types
-import           GHC.Hs
 import Language.Haskell.GHC.ExactPrint as ExactPrint
 import Language.Haskell.GHC.ExactPrint.Types
-                                                ( DeltaPos(..)
+  (DeltaPos(..), commentContents, deltaRow)
-                                                , deltaRow
-                                                , commentContents
-                                                )
 
 
 

source/library/Language/Haskell/Brittany/Internal/Layouters/Pattern.hs

@@ -3,26 +3,19 @@
 
 module Language.Haskell.Brittany.Internal.Layouters.Pattern where
 
-
-
-import Language.Haskell.Brittany.Internal.Prelude
-import Language.Haskell.Brittany.Internal.PreludeUtils
 import qualified Data.Foldable as Foldable
 import qualified Data.Sequence as Seq
 import qualified Data.Text as Text
-import qualified GHC.OldList as List
+import GHC (GenLocated(L), ol_val)
-
-import           Language.Haskell.Brittany.Internal.Types
-import           Language.Haskell.Brittany.Internal.LayouterBasics
-
-import           GHC                            ( GenLocated(L)
-                                                , ol_val
-                                                )
 import GHC.Hs
+import qualified GHC.OldList as List
 import GHC.Types.Basic
-
+import Language.Haskell.Brittany.Internal.LayouterBasics
 import {-# SOURCE #-} Language.Haskell.Brittany.Internal.Layouters.Expr
 import Language.Haskell.Brittany.Internal.Layouters.Type
+import Language.Haskell.Brittany.Internal.Prelude
+import Language.Haskell.Brittany.Internal.PreludeUtils
+import Language.Haskell.Brittany.Internal.Types
 
 
 

source/library/Language/Haskell/Brittany/Internal/Layouters/Stmt.hs

@@ -4,24 +4,18 @@
 
 module Language.Haskell.Brittany.Internal.Layouters.Stmt where
 
-
-
-import Language.Haskell.Brittany.Internal.Prelude
-import Language.Haskell.Brittany.Internal.PreludeUtils
 import qualified Data.Semigroup as Semigroup
 import qualified Data.Text as Text
-
+import GHC (GenLocated(L))
-import           Language.Haskell.Brittany.Internal.Types
-import           Language.Haskell.Brittany.Internal.LayouterBasics
-import           Language.Haskell.Brittany.Internal.Config.Types
-
-import           GHC                            ( GenLocated(L)
-                                                )
 import GHC.Hs
-
+import Language.Haskell.Brittany.Internal.Config.Types
-import           Language.Haskell.Brittany.Internal.Layouters.Pattern
+import Language.Haskell.Brittany.Internal.LayouterBasics
 import Language.Haskell.Brittany.Internal.Layouters.Decl
 import {-# SOURCE #-} Language.Haskell.Brittany.Internal.Layouters.Expr
+import Language.Haskell.Brittany.Internal.Layouters.Pattern
+import Language.Haskell.Brittany.Internal.Prelude
+import Language.Haskell.Brittany.Internal.PreludeUtils
+import Language.Haskell.Brittany.Internal.Types
 
 
 

source/library/Language/Haskell/Brittany/Internal/Layouters/Stmt.hs-boot

@@ -2,13 +2,8 @@
 
 module Language.Haskell.Brittany.Internal.Layouters.Stmt where
 
-
-
-import Language.Haskell.Brittany.Internal.Prelude
-
-import           Language.Haskell.Brittany.Internal.Types
-
 import GHC.Hs
+import Language.Haskell.Brittany.Internal.Types
 
 
 

source/library/Language/Haskell/Brittany/Internal/Layouters/Type.hs

@@ -3,26 +3,18 @@
 
 module Language.Haskell.Brittany.Internal.Layouters.Type where
 
-
+import qualified Data.Text as Text
-
+import GHC (AnnKeywordId(..), GenLocated(L))
+import GHC.Hs
+import qualified GHC.OldList as List
+import GHC.Types.Basic
+import GHC.Utils.Outputable (ftext, showSDocUnsafe)
+import Language.Haskell.Brittany.Internal.LayouterBasics
 import Language.Haskell.Brittany.Internal.Prelude
 import Language.Haskell.Brittany.Internal.PreludeUtils
-import qualified Data.Text as Text
-import qualified GHC.OldList as List
-
 import Language.Haskell.Brittany.Internal.Types
-import           Language.Haskell.Brittany.Internal.LayouterBasics
 import Language.Haskell.Brittany.Internal.Utils
-                                                ( splitFirstLast
+  (FirstLastView(..), splitFirstLast)
-                                                , FirstLastView(..)
-                                                )
-
-import           GHC ( GenLocated(L)
-                     , AnnKeywordId (..)
-                     )
-import           GHC.Hs
-import           GHC.Utils.Outputable ( ftext, showSDocUnsafe )
-import           GHC.Types.Basic
 
 
 

source/library/Language/Haskell/Brittany/Internal/Obfuscation.hs

@@ -2,16 +2,13 @@
 
 module Language.Haskell.Brittany.Internal.Obfuscation where
 
-
+import Data.Char
-
-import Language.Haskell.Brittany.Internal.Prelude
-import Language.Haskell.Brittany.Internal.PreludeUtils
 import qualified Data.Map as Map
 import qualified Data.Set as Set
 import qualified Data.Text as Text
 import qualified GHC.OldList as List
-
+import Language.Haskell.Brittany.Internal.Prelude
-import           Data.Char
+import Language.Haskell.Brittany.Internal.PreludeUtils
 import System.Random
 
 

source/library/Language/Haskell/Brittany/Internal/Prelude.hs

@@ -1,346 +1,194 @@
-module Language.Haskell.Brittany.Internal.Prelude ( module E ) where
+module Language.Haskell.Brittany.Internal.Prelude
+  ( module E
+  ) where
 
-
+import Control.Applicative as E (Alternative(..), Applicative(..))
-
+import Control.Arrow as E ((&&&), (***), (<<<), (>>>), first, second)
--- rather project-specific stuff:
+import Control.Concurrent as E (forkIO, forkOS, threadDelay)
----------------------------------
-import GHC.Hs.Extension               as E ( GhcPs )
-
-import GHC.Types.Name.Reader          as E ( RdrName )
-
-
--- more general:
-----------------
-
-import Data.Functor.Identity         as E ( Identity(..) )
 import Control.Concurrent.Chan as E (Chan)
-import Control.Concurrent.MVar       as E ( MVar
+import Control.Concurrent.MVar as E
-                                          , newEmptyMVar
+  (MVar, newEmptyMVar, newMVar, putMVar, readMVar, swapMVar, takeMVar)
-                                          , newMVar
+import Control.Exception as E (assert, bracket, evaluate)
-                                          , putMVar
+import Control.Monad as E
-                                          , readMVar
+  ( (<$!>)
-                                          , takeMVar
+  , (<=<)
-                                          , swapMVar
-                                          )
-import Data.Int                      as E ( Int )
-import Data.Word                     as E ( Word
-                                          , Word32
-                                          )
-import Prelude                       as E ( Integer
-                                          , Float
-                                          , Double
-                                          , undefined
-                                          , Eq (..)
-                                          , Ord (..)
-                                          , Enum (..)
-                                          , Bounded (..)
-                                          , (<$>)
-                                          , (.)
-                                          , ($)
-                                          , ($!)
-                                          , Num (..)
-                                          , Integral (..)
-                                          , Fractional (..)
-                                          , Floating (..)
-                                          , RealFrac (..)
-                                          , RealFloat (..)
-                                          , fromIntegral
-                                          , error
-                                          , foldr
-                                          , foldl
-                                          , foldr1
-                                          , id
-                                          , map
-                                          , subtract
-                                          , putStrLn
-                                          , putStr
-                                          , Show (..)
-                                          , print
-                                          , fst
-                                          , snd
-                                          , (++)
-                                          , not
-                                          , (&&)
-                                          , (||)
-                                          , curry
-                                          , uncurry
-                                          , flip
-                                          , const
-                                          , seq
-                                          , reverse
-                                          , otherwise
-                                          , traverse
-                                          , realToFrac
-                                          , or
-                                          , and
-                                          , head
-                                          , any
-                                          , (^)
-                                          , Foldable
-                                          , Traversable
-                                          )
-import Control.Monad.ST              as E ( ST )
-import Data.Bool                     as E ( Bool(..) )
-import Data.Char                     as E ( Char
-                                          , ord
-                                          , chr
-                                          )
-import Data.Either                   as E ( Either(..)
-                                          , either
-                                          )
-import Data.IORef                    as E ( IORef )
-import Data.Maybe                    as E ( Maybe(..)
-                                          , fromMaybe
-                                          , maybe
-                                          , listToMaybe
-                                          , maybeToList
-                                          , catMaybes
-                                          )
-import Data.Monoid                   as E ( Endo(..)
-                                          , All(..)
-                                          , Any(..)
-                                          , Sum(..)
-                                          , Product(..)
-                                          , Alt(..)
-                                          , mconcat
-                                          , Monoid (..)
-                                          )
-import Data.Ord                      as E ( Ordering(..)
-                                          , Down(..)
-                                          , comparing
-                                          )
-import Data.Ratio                    as E ( Ratio
-                                          , Rational
-                                          , (%)
-                                          , numerator
-                                          , denominator
-                                          )
-import Data.String                   as E ( String )
-import Data.Void                     as E ( Void )
-import System.IO                     as E ( IO
-                                          , hFlush
-                                          , stdout
-                                          )
-import Data.Proxy                    as E ( Proxy(..) )
-import Data.Sequence                 as E ( Seq )
-
-import Data.Map                      as E ( Map )
-import Data.Set                      as E ( Set )
-
-import Data.Text                     as E ( Text )
-
-import Data.Function                 as E ( fix
-                                          , (&)
-                                          )
-
-import Data.Foldable                 as E ( foldl'
-                                          , foldr'
-                                          , fold
-                                          , asum
-                                          )
-
-import Data.List                     as E ( partition
-                                          , null
-                                          , elem
-                                          , notElem
-                                          , minimum
-                                          , maximum
-                                          , length
-                                          , all
-                                          , take
-                                          , drop
-                                          , find
-                                          , sum
-                                          , zip
-                                          , zip3
-                                          , zipWith
-                                          , repeat
-                                          , replicate
-                                          , iterate
-                                          , nub
-                                          , filter
-                                          , intersperse
-                                          , intercalate
-                                          , isSuffixOf
-                                          , isPrefixOf
-                                          , dropWhile
-                                          , takeWhile
-                                          , unzip
-                                          , break
-                                          , transpose
-                                          , sortBy
-                                          , mapAccumL
-                                          , mapAccumR
-                                          , uncons
-                                          )
-
-import Data.List.NonEmpty            as E ( NonEmpty(..)
-                                          , nonEmpty
-                                          )
-
-import Data.Tuple                    as E ( swap
-                                          )
-
-import Text.Read                     as E ( readMaybe
-                                          )
-
-import Control.Monad                 as E ( Functor (..)
-                                          , Monad (..)
-                                          , MonadPlus (..)
-                                          , mapM
-                                          , mapM_
-                                          , forM
-                                          , forM_
-                                          , sequence
-                                          , sequence_
   , (=<<)
   , (>=>)
-                                          , (<=<)
+  , Functor(..)
+  , Monad(..)
+  , MonadPlus(..)
+  , filterM
+  , forM
+  , forM_
   , forever
-                                          , void
-                                          , join
-                                          , replicateM
-                                          , replicateM_
   , guard
-                                          , when
+  , join
-                                          , unless
   , liftM
   , liftM2
   , liftM3
   , liftM4
   , liftM5
-                                          , filterM
+  , mapM
-                                          , (<$!>)
+  , mapM_
+  , replicateM
+  , replicateM_
+  , sequence
+  , sequence_
+  , unless
+  , void
+  , when
   )
-
+import Control.Monad.Extra as E
-import Control.Applicative           as E ( Applicative (..)
+  (allM, andM, anyM, ifM, notM, orM, unlessM, whenM)
-                                          , Alternative (..)
+import Control.Monad.IO.Class as E (MonadIO(..))
+import Control.Monad.ST as E (ST)
+import Control.Monad.Trans.Class as E (lift)
+import Control.Monad.Trans.Maybe as E (MaybeT(..))
+import Control.Monad.Trans.MultiRWS as E
+  (MonadMultiReader(..), MonadMultiState(..), MonadMultiWriter(..), mGet)
+import Data.Bifunctor as E (bimap)
+import Data.Bool as E (Bool(..))
+import Data.Char as E (Char, chr, ord)
+import Data.Data as E (toConstr)
+import Data.Either as E (Either(..), either)
+import Data.Foldable as E (asum, fold, foldl', foldr')
+import Data.Function as E ((&), fix)
+import Data.Functor as E (($>))
+import Data.Functor.Identity as E (Identity(..))
+import Data.IORef as E (IORef)
+import Data.Int as E (Int)
+import Data.List as E
+  ( all
+  , break
+  , drop
+  , dropWhile
+  , elem
+  , filter
+  , find
+  , intercalate
+  , intersperse
+  , isPrefixOf
+  , isSuffixOf
+  , iterate
+  , length
+  , mapAccumL
+  , mapAccumR
+  , maximum
+  , minimum
+  , notElem
+  , nub
+  , null
+  , partition
+  , repeat
+  , replicate
+  , sortBy
+  , sum
+  , take
+  , takeWhile
+  , transpose
+  , uncons
+  , unzip
+  , zip
+  , zip3
+  , zipWith
   )
-
+import Data.List.Extra as E (nubOrd, stripSuffix)
+import Data.List.NonEmpty as E (NonEmpty(..), nonEmpty)
+import Data.Map as E (Map)
+import Data.Maybe as E
+  (Maybe(..), catMaybes, fromMaybe, listToMaybe, maybe, maybeToList)
+import Data.Monoid as E
+  ( All(..)
+  , Alt(..)
+  , Any(..)
+  , Endo(..)
+  , Monoid(..)
+  , Product(..)
+  , Sum(..)
+  , mconcat
+  )
+import Data.Ord as E (Down(..), Ordering(..), comparing)
+import Data.Proxy as E (Proxy(..))
+import Data.Ratio as E ((%), Ratio, Rational, denominator, numerator)
+import Data.Semigroup as E ((<>), Semigroup(..))
+import Data.Sequence as E (Seq)
+import Data.Set as E (Set)
+import Data.String as E (String)
+import Data.Text as E (Text)
+import Data.Tree as E (Tree(..))
+import Data.Tuple as E (swap)
+import Data.Typeable as E (Typeable)
+import Data.Version as E (showVersion)
+import Data.Void as E (Void)
+import Data.Word as E (Word, Word32)
+import Debug.Trace as E
+  ( trace
+  , traceIO
+  , traceId
+  , traceM
+  , traceShow
+  , traceShowId
+  , traceShowM
+  , traceStack
+  )
+import Foreign.ForeignPtr as E (ForeignPtr)
 import Foreign.Storable as E (Storable)
 import GHC.Exts as E (Constraint)
-
+import GHC.Hs.Extension as E (GhcPs)
-import Control.Concurrent            as E ( threadDelay
+import GHC.Types.Name.Reader as E (RdrName)
-                                          , forkIO
+import Prelude as E
-                                          , forkOS
+  ( ($)
-                                          )
+  , ($!)
-
+  , (&&)
-import Control.Exception             as E ( evaluate
+  , (++)
-                                          , bracket
+  , (.)
-                                          , assert
+  , (<$>)
-                                          )
+  , Bounded(..)
-
+  , Double
-import Debug.Trace                   as E ( trace
+  , Enum(..)
-                                          , traceId
+  , Eq(..)
-                                          , traceShowId
+  , Float
-                                          , traceShow
+  , Floating(..)
-                                          , traceStack
+  , Foldable
-                                          , traceShowId
+  , Fractional(..)
-                                          , traceIO
+  , Integer
-                                          , traceM
+  , Integral(..)
-                                          , traceShowM
+  , Num(..)
-                                          )
+  , Ord(..)
-
+  , RealFloat(..)
-import Foreign.ForeignPtr            as E ( ForeignPtr
+  , RealFrac(..)
-                                          )
+  , Show(..)
-
+  , Traversable
-import Data.Bifunctor                as E ( bimap )
+  , (^)
-import Data.Functor                  as E ( ($>) )
+  , and
-import Data.Semigroup                as E ( (<>)
+  , any
-                                          , Semigroup(..)
+  , const
-                                          )
+  , curry
-
+  , error
-import Data.Typeable                 as E ( Typeable
+  , flip
-                                          )
+  , foldl
-
+  , foldr
-import Control.Arrow                 as E ( first
+  , foldr1
-                                          , second
+  , fromIntegral
-                                          , (***)
+  , fst
-                                          , (&&&)
+  , head
-                                          , (>>>)
+  , id
-                                          , (<<<)
+  , map
-                                          )
+  , not
-
+  , or
-import Data.Version                  as E ( showVersion
+  , otherwise
-                                          )
+  , print
-
+  , putStr
-import Data.List.Extra               as E ( nubOrd
+  , putStrLn
-                                          , stripSuffix
+  , realToFrac
-                                          )
+  , reverse
-import Control.Monad.Extra           as E ( whenM
+  , seq
-                                          , unlessM
+  , snd
-                                          , ifM
+  , subtract
-                                          , notM
+  , traverse
-                                          , orM
+  , uncurry
-                                          , andM
+  , undefined
-                                          , anyM
+  , (||)
-                                          , allM
-                                          )
-
-import Data.Tree                     as E ( Tree(..)
-                                          )
-
-import Control.Monad.Trans.MultiRWS  as E ( -- MultiRWST (..)
-                                          -- , MultiRWSTNull
-                                          -- , MultiRWS
-                                          -- ,
-                                            MonadMultiReader(..)
-                                          , MonadMultiWriter(..)
-                                          , MonadMultiState(..)
-                                          , mGet
-                                          -- , runMultiRWST
-                                          -- , runMultiRWSTASW
-                                          -- , runMultiRWSTW
-                                          -- , runMultiRWSTAW
-                                          -- , runMultiRWSTSW
-                                          -- , runMultiRWSTNil
-                                          -- , runMultiRWSTNil_
-                                          -- , withMultiReader
-                                          -- , withMultiReader_
-                                          -- , withMultiReaders
-                                          -- , withMultiReaders_
-                                          -- , withMultiWriter
-                                          -- , withMultiWriterAW
-                                          -- , withMultiWriterWA
-                                          -- , withMultiWriterW
-                                          -- , withMultiWriters
-                                          -- , withMultiWritersAW
-                                          -- , withMultiWritersWA
-                                          -- , withMultiWritersW
-                                          -- , withMultiState
-                                          -- , withMultiStateAS
-                                          -- , withMultiStateSA
-                                          -- , withMultiStateA
-                                          -- , withMultiStateS
-                                          -- , withMultiState_
-                                          -- , withMultiStates
-                                          -- , withMultiStatesAS
-                                          -- , withMultiStatesSA
-                                          -- , withMultiStatesA
-                                          -- , withMultiStatesS
-                                          -- , withMultiStates_
-                                          -- , inflateReader
-                                          -- , inflateMultiReader
-                                          -- , inflateWriter
-                                          -- , inflateMultiWriter
-                                          -- , inflateState
-                                          -- , inflateMultiState
-                                          -- , mapMultiRWST
-                                          -- , mGetRawR
-                                          -- , mGetRawW
-                                          -- , mGetRawS
-                                          -- , mPutRawR
-                                          -- , mPutRawW
-                                          -- , mPutRawS
-                                          )
-
-import Control.Monad.IO.Class        as E ( MonadIO (..)
-                                          )
-
-import Control.Monad.Trans.Class     as E ( lift
-                                          )
-import Control.Monad.Trans.Maybe     as E ( MaybeT (..)
-                                          )
-
-import Data.Data                     as E ( toConstr
   )
+import System.IO as E (IO, hFlush, stdout)
+import Text.Read as E (readMaybe)

source/library/Language/Haskell/Brittany/Internal/PreludeUtils.hs

@@ -1,18 +1,15 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
+
 module Language.Haskell.Brittany.Internal.PreludeUtils where
 
-
+import Control.Applicative
-
-import Prelude
-import qualified Data.Strict.Maybe as Strict
-import Debug.Trace
-import Control.Monad
-import System.IO
-
 import Control.DeepSeq (NFData, force)
 import Control.Exception.Base (evaluate)
-
+import Control.Monad
-import Control.Applicative
+import qualified Data.Strict.Maybe as Strict
+import Debug.Trace
+import Prelude
+import System.IO
 
 
 

source/library/Language/Haskell/Brittany/Internal/Transformations/Alt.hs

@@ -9,23 +9,18 @@
 
 module Language.Haskell.Brittany.Internal.Transformations.Alt where
 
-
+import qualified Control.Monad.Memo as Memo
-
-import Language.Haskell.Brittany.Internal.Prelude
-import Language.Haskell.Brittany.Internal.PreludeUtils
 import qualified Control.Monad.Trans.MultiRWS.Strict as MultiRWSS
+import Data.HList.ContainsType
 import qualified Data.List.Extra
 import qualified Data.Semigroup as Semigroup
 import qualified Data.Text as Text
 import qualified GHC.OldList as List
-
-import           Data.HList.ContainsType
-
-import           Language.Haskell.Brittany.Internal.Utils
 import Language.Haskell.Brittany.Internal.Config.Types
+import Language.Haskell.Brittany.Internal.Prelude
+import Language.Haskell.Brittany.Internal.PreludeUtils
 import Language.Haskell.Brittany.Internal.Types
-
+import Language.Haskell.Brittany.Internal.Utils
-import qualified Control.Monad.Memo as Memo
 
 
 

source/library/Language/Haskell/Brittany/Internal/Transformations/Columns.hs

@@ -3,14 +3,10 @@
 
 module Language.Haskell.Brittany.Internal.Transformations.Columns where
 
-
-
-import Language.Haskell.Brittany.Internal.Prelude
-import qualified GHC.OldList as List
-
-import           Language.Haskell.Brittany.Internal.Types
-
 import qualified Data.Generics.Uniplate.Direct as Uniplate
+import qualified GHC.OldList as List
+import Language.Haskell.Brittany.Internal.Prelude
+import Language.Haskell.Brittany.Internal.Types
 
 
 

source/library/Language/Haskell/Brittany/Internal/Transformations/Floating.hs

@@ -3,16 +3,12 @@
 
 module Language.Haskell.Brittany.Internal.Transformations.Floating where
 
-
+import qualified Data.Generics.Uniplate.Direct as Uniplate
-
+import qualified GHC.OldList as List
 import Language.Haskell.Brittany.Internal.Prelude
 import Language.Haskell.Brittany.Internal.PreludeUtils
-import qualified GHC.OldList as List
-
-import           Language.Haskell.Brittany.Internal.Utils
 import Language.Haskell.Brittany.Internal.Types
-
+import Language.Haskell.Brittany.Internal.Utils
-import qualified Data.Generics.Uniplate.Direct as Uniplate
 
 
 

source/library/Language/Haskell/Brittany/Internal/Transformations/Indent.hs

@@ -3,14 +3,10 @@
 
 module Language.Haskell.Brittany.Internal.Transformations.Indent where
 
-
-
-import Language.Haskell.Brittany.Internal.Prelude
-import qualified GHC.OldList as List
-
-import           Language.Haskell.Brittany.Internal.Types
-
 import qualified Data.Generics.Uniplate.Direct as Uniplate
+import qualified GHC.OldList as List
+import Language.Haskell.Brittany.Internal.Prelude
+import Language.Haskell.Brittany.Internal.Types
 
 
 

source/library/Language/Haskell/Brittany/Internal/Transformations/Par.hs

@@ -3,12 +3,9 @@
 
 module Language.Haskell.Brittany.Internal.Transformations.Par where
 
-
-
 import Language.Haskell.Brittany.Internal.Prelude
-
-import           Language.Haskell.Brittany.Internal.Utils
 import Language.Haskell.Brittany.Internal.Types
+import Language.Haskell.Brittany.Internal.Utils
 
 
 

source/library/Language/Haskell/Brittany/Internal/Types.hs

@@ -12,30 +12,20 @@
 
 module Language.Haskell.Brittany.Internal.Types where
 
-
-
-import Language.Haskell.Brittany.Internal.Prelude
 import qualified Control.Monad.Trans.MultiRWS.Strict as MultiRWSS
 import qualified Data.Data
-import qualified Data.Strict.Maybe as Strict
-import qualified Safe
-
-import qualified Language.Haskell.GHC.ExactPrint as ExactPrint
-import qualified Language.Haskell.GHC.ExactPrint.Types as ExactPrint.Types
-
-import qualified Data.Text.Lazy.Builder as Text.Builder
-
-import           GHC ( Located, GenLocated, AnnKeywordId, SrcSpan )
-
-import           Language.Haskell.GHC.ExactPrint ( AnnKey )
-import           Language.Haskell.GHC.ExactPrint.Types ( Anns )
-
-import           Language.Haskell.Brittany.Internal.Config.Types
-
 import Data.Generics.Uniplate.Direct as Uniplate
-
 import qualified Data.Kind as Kind
-
+import qualified Data.Strict.Maybe as Strict
+import qualified Data.Text.Lazy.Builder as Text.Builder
+import GHC (AnnKeywordId, GenLocated, Located, SrcSpan)
+import Language.Haskell.Brittany.Internal.Config.Types
+import Language.Haskell.Brittany.Internal.Prelude
+import qualified Language.Haskell.GHC.ExactPrint as ExactPrint
+import Language.Haskell.GHC.ExactPrint (AnnKey)
+import qualified Language.Haskell.GHC.ExactPrint.Types as ExactPrint.Types
+import Language.Haskell.GHC.ExactPrint.Types (Anns)
+import qualified Safe
 
 
 data PerItemConfig = PerItemConfig

source/library/Language/Haskell/Brittany/Internal/Utils.hs

@@ -7,37 +7,28 @@
 
 module Language.Haskell.Brittany.Internal.Utils where
 
-
+import qualified Data.ByteString as B
-
-import Language.Haskell.Brittany.Internal.Prelude
-import Language.Haskell.Brittany.Internal.PreludeUtils
 import qualified Data.Coerce
-import qualified Data.Semigroup as Semigroup
-import qualified Data.Sequence as Seq
-import qualified GHC.OldList as List
-
-import qualified Language.Haskell.GHC.ExactPrint.Types as ExactPrint.Types
-import qualified Language.Haskell.GHC.ExactPrint.Utils as ExactPrint.Utils
-
 import Data.Data
 import Data.Generics.Aliases
-
-import qualified Text.PrettyPrint as PP
-
-import qualified GHC.Utils.Outputable as GHC
-import qualified GHC.Driver.Session   as GHC
-import qualified GHC.Data.FastString  as GHC
-import qualified GHC.Types.SrcLoc     as GHC
-import           GHC.Types.Name.Occurrence as OccName ( occNameString )
-import qualified Data.ByteString as B
-
-import           DataTreePrint
-
-import           Language.Haskell.Brittany.Internal.Config.Types
-import           Language.Haskell.Brittany.Internal.Types
-
 import qualified Data.Generics.Uniplate.Direct as Uniplate
+import qualified Data.Semigroup as Semigroup
+import qualified Data.Sequence as Seq
+import DataTreePrint
+import qualified GHC.Data.FastString as GHC
+import qualified GHC.Driver.Session as GHC
 import qualified GHC.Hs.Extension as HsExtension
+import qualified GHC.OldList as List
+import GHC.Types.Name.Occurrence as OccName (occNameString)
+import qualified GHC.Types.SrcLoc as GHC
+import qualified GHC.Utils.Outputable as GHC
+import Language.Haskell.Brittany.Internal.Config.Types
+import Language.Haskell.Brittany.Internal.Prelude
+import Language.Haskell.Brittany.Internal.PreludeUtils
+import Language.Haskell.Brittany.Internal.Types
+import qualified Language.Haskell.GHC.ExactPrint.Types as ExactPrint.Types
+import qualified Language.Haskell.GHC.ExactPrint.Utils as ExactPrint.Utils
+import qualified Text.PrettyPrint as PP
 
 
 

source/library/Language/Haskell/Brittany/Main.hs

@@ -4,56 +4,41 @@
 
 module Language.Haskell.Brittany.Main where
 
-
+import Control.Monad (zipWithM)
-
-import Language.Haskell.Brittany.Internal.Prelude
-import Language.Haskell.Brittany.Internal.PreludeUtils
 import qualified Control.Monad.Trans.Except as ExceptT
+import Data.CZipWith
 import qualified Data.Either
 import qualified Data.List.Extra
+import qualified Data.Monoid
 import qualified Data.Semigroup as Semigroup
 import qualified Data.Text as Text
 import qualified Data.Text.IO as Text.IO
 import qualified Data.Text.Lazy as TextL
-import qualified GHC.OldList as List
+import DataTreePrint
-import qualified System.IO
-
--- brittany { lconfig_importAsColumn: 60, lconfig_importColumn: 60 }
-import qualified Language.Haskell.GHC.ExactPrint         as ExactPrint
-import qualified Data.Monoid
-
 import GHC (GenLocated(L))
-import           GHC.Utils.Outputable                               ( Outputable(..)
+import qualified GHC.Driver.Session as GHC
-                                                          , showSDocUnsafe
+import qualified GHC.LanguageExtensions.Type as GHC
-                                                          )
+import qualified GHC.OldList as List
-
+import GHC.Utils.Outputable (Outputable(..), showSDocUnsafe)
-import           Text.Read                                ( Read(..) )
-import qualified Text.ParserCombinators.ReadP            as ReadP
-import qualified Text.ParserCombinators.ReadPrec         as ReadPrec
-
-import           Control.Monad                            ( zipWithM )
-import           Data.CZipWith
-
-import           Language.Haskell.Brittany.Internal.Types
 import Language.Haskell.Brittany.Internal
 import Language.Haskell.Brittany.Internal.Config
 import Language.Haskell.Brittany.Internal.Config.Types
-import           Language.Haskell.Brittany.Internal.Utils
 import Language.Haskell.Brittany.Internal.Obfuscation
-
+import Language.Haskell.Brittany.Internal.Prelude
-import qualified Text.PrettyPrint                        as PP
+import Language.Haskell.Brittany.Internal.PreludeUtils
-
+import Language.Haskell.Brittany.Internal.Types
-import           DataTreePrint
+import Language.Haskell.Brittany.Internal.Utils
-import           UI.Butcher.Monadic
+import qualified Language.Haskell.GHC.ExactPrint as ExactPrint
-
-import qualified System.Exit
-import qualified System.Directory                        as Directory
-import qualified System.FilePath.Posix                   as FilePath
-
-import qualified GHC.Driver.Session                                as GHC
-import qualified GHC.LanguageExtensions.Type             as GHC
-
 import Paths_brittany
+import qualified System.Directory as Directory
+import qualified System.Exit
+import qualified System.FilePath.Posix as FilePath
+import qualified System.IO
+import qualified Text.ParserCombinators.ReadP as ReadP
+import qualified Text.ParserCombinators.ReadPrec as ReadPrec
+import qualified Text.PrettyPrint as PP
+import Text.Read (Read(..))
+import UI.Butcher.Monadic
 
 
 

source/test-suite/Main.hs

@@ -2,36 +2,25 @@
 {-# LANGUAGE MonadComprehensions #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 
-import Language.Haskell.Brittany.Internal.Prelude
+import Data.Coerce (coerce)
+import Data.List (groupBy)
 import qualified Data.Maybe
 import qualified Data.Semigroup as Semigroup
 import qualified Data.Text as Text
+import qualified Data.Text.IO as Text.IO
 import qualified GHC.OldList as List
+import Language.Haskell.Brittany.Internal
+import Language.Haskell.Brittany.Internal.Config
+import Language.Haskell.Brittany.Internal.Config.Types
+import Language.Haskell.Brittany.Internal.Prelude
+import Language.Haskell.Brittany.Internal.PreludeUtils
 import qualified System.Directory
-
+import System.FilePath ((</>))
+import System.Timeout (timeout)
 import Test.Hspec
-
 import qualified Text.Parsec as Parsec
 import Text.Parsec.Text (Parser)
 
-import           Data.List                      ( groupBy )
-
-import           Language.Haskell.Brittany.Internal
-
-import           Language.Haskell.Brittany.Internal.Config.Types
-import           Language.Haskell.Brittany.Internal.Config
-
-import           Data.Coerce                    ( coerce )
-
-import qualified Data.Text.IO                  as Text.IO
-import           System.FilePath                ( (</>) )
-
-import System.Timeout ( timeout )
-
-
-
-import Language.Haskell.Brittany.Internal.PreludeUtils
-
 hush :: Either a b -> Maybe b
 hush = either (const Nothing) Just