Use ImportQualifiedPost

Also fixed the `./script/check-stylish.sh` script.

.stylish-haskell.yaml

@@ -191,6 +191,25 @@ steps:
       # Default: false
       space_surround: false
 
+      # Post qualify option moves any qualifies found in import declarations
+      # to the end of the declaration. This also adjust padding for any
+      # unqualified import declarations.
+      #
+      # - true: Qualified as <module name> is moved to the end of the
+      #   declaration.
+      #
+      #   > import Data.Bar
+      #   > import Data.Foo qualified as F
+      #
+      # - false: Qualified remains in the default location and unqualified
+      #   imports are padded to align with qualified imports.
+      #
+      #   > import           Data.Bar
+      #   > import qualified Data.Foo as F
+      #
+      # Default: false
+      post_qualify: true
+
   # Language pragmas
   - language_pragmas:
       # We can generate different styles of language pragma lists.

io-classes-mtl/io-classes-mtl.cabal

@@ -50,3 +50,4 @@ library
 
     hs-source-dirs:   src
     default-language: Haskell2010
+    default-extensions:  ImportQualifiedPost

io-classes/io-classes.cabal

@@ -65,6 +65,7 @@ library
                        Control.Monad.Class.MonadTimer
                        Control.Monad.Class.MonadTest
   default-language:    Haskell2010
+  default-extensions:  ImportQualifiedPost
   other-extensions:    CPP
                        DataKinds
                        DefaultSignatures

io-classes/src/Control/Concurrent/Class/MonadMVar.hs

@@ -8,13 +8,13 @@ module Control.Concurrent.Class.MonadMVar
   , MonadInspectMVar (..)
   ) where
 
-import qualified Control.Concurrent.MVar as IO
-import           Control.Monad.Class.MonadThrow
+import Control.Concurrent.MVar qualified as IO
+import Control.Monad.Class.MonadThrow
 
-import           Control.Monad.Reader (ReaderT (..))
-import           Control.Monad.Trans (lift)
+import Control.Monad.Reader (ReaderT (..))
+import Control.Monad.Trans (lift)
 
-import           Data.Kind (Type)
+import Data.Kind (Type)
 
 
 class Monad m => MonadMVar m where

io-classes/src/Control/Concurrent/Class/MonadSTM.hs

@@ -4,11 +4,11 @@ module Control.Concurrent.Class.MonadSTM
   (module STM)
   where
 
-import           Control.Monad.Class.MonadSTM              as STM
-import           Control.Concurrent.Class.MonadSTM.TVar    as STM
-import           Control.Concurrent.Class.MonadSTM.TMVar   as STM
-import           Control.Concurrent.Class.MonadSTM.TChan   as STM
-import           Control.Concurrent.Class.MonadSTM.TQueue  as STM
-import           Control.Concurrent.Class.MonadSTM.TBQueue as STM
-import           Control.Concurrent.Class.MonadSTM.TArray  as STM
+import Control.Monad.Class.MonadSTM              as STM
+import Control.Concurrent.Class.MonadSTM.TVar    as STM
+import Control.Concurrent.Class.MonadSTM.TMVar   as STM
+import Control.Concurrent.Class.MonadSTM.TChan   as STM
+import Control.Concurrent.Class.MonadSTM.TQueue  as STM
+import Control.Concurrent.Class.MonadSTM.TBQueue as STM
+import Control.Concurrent.Class.MonadSTM.TArray  as STM
 

io-classes/src/Control/Concurrent/Class/MonadSTM/TArray.hs

@@ -4,4 +4,4 @@
 --
 module Control.Concurrent.Class.MonadSTM.TArray (type TArray) where
 
-import           Control.Monad.Class.MonadSTM.Internal
+import Control.Monad.Class.MonadSTM.Internal

io-classes/src/Control/Concurrent/Class/MonadSTM/TBQueue.hs

@@ -25,4 +25,4 @@ module Control.Concurrent.Class.MonadSTM.TBQueue
   , traceTBQueueIO
   ) where
 
-import           Control.Monad.Class.MonadSTM.Internal
+import Control.Monad.Class.MonadSTM.Internal

io-classes/src/Control/Concurrent/Class/MonadSTM/TChan.hs

@@ -23,4 +23,4 @@ module Control.Concurrent.Class.MonadSTM.TChan
   , isEmptyTChan
   ) where
 
-import           Control.Monad.Class.MonadSTM.Internal
+import Control.Monad.Class.MonadSTM.Internal

io-classes/src/Control/Concurrent/Class/MonadSTM/TMVar.hs

@@ -25,4 +25,4 @@ module Control.Concurrent.Class.MonadSTM.TMVar
   , traceTMVarIO
   ) where
 
-import           Control.Monad.Class.MonadSTM.Internal
+import Control.Monad.Class.MonadSTM.Internal

io-classes/src/Control/Concurrent/Class/MonadSTM/TQueue.hs

@@ -23,4 +23,4 @@ module Control.Concurrent.Class.MonadSTM.TQueue
   , traceTQueueIO
   ) where
 
-import           Control.Monad.Class.MonadSTM.Internal
+import Control.Monad.Class.MonadSTM.Internal

io-classes/src/Control/Concurrent/Class/MonadSTM/TSem.hs

@@ -17,4 +17,4 @@ module Control.Concurrent.Class.MonadSTM.TSem
   , traceTSemIO
   ) where
 
-import           Control.Monad.Class.MonadSTM.Internal
+import Control.Monad.Class.MonadSTM.Internal

io-classes/src/Control/Concurrent/Class/MonadSTM/TVar.hs

@@ -23,4 +23,4 @@ module Control.Concurrent.Class.MonadSTM.TVar
   , traceTVarIO
   ) where
 
-import           Control.Monad.Class.MonadSTM.Internal
+import Control.Monad.Class.MonadSTM.Internal

io-classes/src/Control/Monad/Class/MonadAsync.hs

@@ -31,30 +31,30 @@ module Control.Monad.Class.MonadAsync
   , Concurrently (..)
   ) where
 
-import           Prelude hiding (read)
+import Prelude hiding (read)
 
 #if MIN_VERSION_base(4,18,0)
-import           Control.Applicative (Alternative (..))
+import Control.Applicative (Alternative (..))
 #else
-import           Control.Applicative (Alternative (..), liftA2)
+import Control.Applicative (Alternative (..), liftA2)
 #endif
-import           Control.Monad (forever)
-import           Control.Monad.Class.MonadFork
-import           Control.Monad.Class.MonadSTM
-import           Control.Monad.Class.MonadThrow
-import           Control.Monad.Class.MonadTimer
-
-import           Control.Monad.Reader (ReaderT (..))
-import           Control.Monad.Trans (lift)
-
-import           Control.Concurrent.Async (AsyncCancelled (..))
-import qualified Control.Concurrent.Async as Async
-import qualified Control.Exception as E
-
-import           Data.Bifunctor (first)
-import           Data.Foldable (fold)
-import           Data.Functor (void)
-import           Data.Kind (Type)
+import Control.Monad (forever)
+import Control.Monad.Class.MonadFork
+import Control.Monad.Class.MonadSTM
+import Control.Monad.Class.MonadThrow
+import Control.Monad.Class.MonadTimer
+
+import Control.Monad.Reader (ReaderT (..))
+import Control.Monad.Trans (lift)
+
+import Control.Concurrent.Async (AsyncCancelled (..))
+import Control.Concurrent.Async qualified as Async
+import Control.Exception qualified as E
+
+import Data.Bifunctor (first)
+import Data.Foldable (fold)
+import Data.Functor (void)
+import Data.Kind (Type)
 
 class ( MonadSTM m
       , MonadThread m

io-classes/src/Control/Monad/Class/MonadEventlog.hs

@@ -1,10 +1,8 @@
-module Control.Monad.Class.MonadEventlog
-  ( MonadEventlog (..)
-  ) where
+module Control.Monad.Class.MonadEventlog (MonadEventlog (..)) where
 
-import           Control.Monad.Reader
+import Control.Monad.Reader
 
-import qualified Debug.Trace as IO (traceEventIO, traceMarkerIO)
+import Debug.Trace qualified as IO (traceEventIO, traceMarkerIO)
 
 class Monad m => MonadEventlog m where
 

io-classes/src/Control/Monad/Class/MonadFork.hs

@@ -13,11 +13,12 @@ module Control.Monad.Class.MonadFork
   , MonadFork (..)
   ) where
 
-import qualified Control.Concurrent as IO
-import           Control.Exception (AsyncException (ThreadKilled), Exception, SomeException)
-import           Control.Monad.Reader (ReaderT (..), lift)
-import           Data.Kind (Type)
-import qualified GHC.Conc.Sync as IO (labelThread)
+import Control.Concurrent qualified as IO
+import Control.Exception (AsyncException (ThreadKilled), Exception,
+           SomeException)
+import Control.Monad.Reader (ReaderT (..), lift)
+import Data.Kind (Type)
+import GHC.Conc.Sync qualified as IO (labelThread)
 
 
 class (Monad m, Eq   (ThreadId m),

io-classes/src/Control/Monad/Class/MonadST.hs

@@ -1,9 +1,9 @@
 {-# LANGUAGE RankNTypes #-}
 module Control.Monad.Class.MonadST (MonadST (..)) where
 
-import           Control.Monad.Reader
+import Control.Monad.Reader
 
-import           Control.Monad.ST (ST, stToIO)
+import Control.Monad.ST (ST, stToIO)
 
 
 -- | This class is for abstracting over 'stToIO' which allows running 'ST'

io-classes/src/Control/Monad/Class/MonadSTM.hs

@@ -1,15 +1,15 @@
 -- | This module corresponds to "Control.Monad.STM" in "stm" package
 --
-{-# LANGUAGE DataKinds                  #-}
-{-# LANGUAGE DerivingStrategies         #-}
-{-# LANGUAGE FlexibleContexts           #-}
-{-# LANGUAGE GADTs                      #-}
-{-# LANGUAGE MultiParamTypeClasses      #-}
-{-# LANGUAGE RankNTypes                 #-}
-{-# LANGUAGE ScopedTypeVariables        #-}
+{-# LANGUAGE DataKinds             #-}
+{-# LANGUAGE DerivingStrategies    #-}
+{-# LANGUAGE FlexibleContexts      #-}
+{-# LANGUAGE GADTs                 #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE RankNTypes            #-}
+{-# LANGUAGE ScopedTypeVariables   #-}
 -- undecidable instances needed for 'WrappedSTM' instances of 'MonadThrow' and
 -- 'MonadCatch' type classes.
-{-# LANGUAGE UndecidableInstances       #-}
+{-# LANGUAGE UndecidableInstances  #-}
 module Control.Monad.Class.MonadSTM
   ( MonadSTM (STM, atomically, retry, orElse, check)
   , throwSTM
@@ -22,7 +22,7 @@ module Control.Monad.Class.MonadSTM
   , MonadInspectSTM (..)
   ) where
 
-import           Control.Monad.Class.MonadSTM.Internal
+import Control.Monad.Class.MonadSTM.Internal
 
 -- $non-standard-extensions
 --

io-classes/src/Control/Monad/Class/MonadSTM/Internal.hs

@@ -99,35 +99,35 @@ module Control.Monad.Class.MonadSTM.Internal
   , labelTChanDefault
   ) where
 
-import           Prelude hiding (read)
-
-import qualified Control.Concurrent.STM.TArray as STM
-import qualified Control.Concurrent.STM.TBQueue as STM
-import qualified Control.Concurrent.STM.TChan as STM
-import qualified Control.Concurrent.STM.TMVar as STM
-import qualified Control.Concurrent.STM.TQueue as STM
-import qualified Control.Concurrent.STM.TSem as STM
-import qualified Control.Concurrent.STM.TVar as STM
-import           Control.Monad (unless, when)
-import qualified Control.Monad.STM as STM
-
-import           Control.Monad.Reader (ReaderT (..))
-import           Control.Monad.Trans (lift)
-
-import qualified Control.Monad.Class.MonadThrow as MonadThrow
-
-import           Control.Exception
-import           Data.Array (Array, bounds)
-import qualified Data.Array as Array
-import           Data.Array.Base (IArray (numElements), MArray (..),
-                     arrEleBottom, listArray, unsafeAt)
-import           Data.Foldable (traverse_)
-import           Data.Ix (Ix, rangeSize)
-import           Data.Kind (Type)
-import           Data.Proxy (Proxy (..))
-import           Data.Typeable (Typeable)
-import           GHC.Stack
-import           Numeric.Natural (Natural)
+import Prelude hiding (read)
+
+import Control.Concurrent.STM.TArray qualified as STM
+import Control.Concurrent.STM.TBQueue qualified as STM
+import Control.Concurrent.STM.TChan qualified as STM
+import Control.Concurrent.STM.TMVar qualified as STM
+import Control.Concurrent.STM.TQueue qualified as STM
+import Control.Concurrent.STM.TSem qualified as STM
+import Control.Concurrent.STM.TVar qualified as STM
+import Control.Monad (unless, when)
+import Control.Monad.STM qualified as STM
+
+import Control.Monad.Reader (ReaderT (..))
+import Control.Monad.Trans (lift)
+
+import Control.Monad.Class.MonadThrow qualified as MonadThrow
+
+import Control.Exception
+import Data.Array (Array, bounds)
+import Data.Array qualified as Array
+import Data.Array.Base (IArray (numElements), MArray (..), arrEleBottom,
+           listArray, unsafeAt)
+import Data.Foldable (traverse_)
+import Data.Ix (Ix, rangeSize)
+import Data.Kind (Type)
+import Data.Proxy (Proxy (..))
+import Data.Typeable (Typeable)
+import GHC.Stack
+import Numeric.Natural (Natural)
 
 
 -- $default-implementations
@@ -436,7 +436,7 @@ class MonadInspectSTM m
   -- This is supported by 'IOSim' (and 'IOSimPOR'); 'IO' has a trivial instance.
   --
   -- The simplest example is:
-  -- 
+  --
   -- >
   -- > traceTVar (Proxy @m) tvar (\_ -> TraceString . show)
   -- >

io-classes/src/Control/Monad/Class/MonadSay.hs

@@ -1,7 +1,7 @@
 module Control.Monad.Class.MonadSay where
 
-import           Control.Monad.Reader
-import qualified Data.ByteString.Char8 as BSC
+import Control.Monad.Reader
+import Data.ByteString.Char8 qualified as BSC
 
 class Monad m => MonadSay m where
   say :: String -> m ()

io-classes/src/Control/Monad/Class/MonadTest.hs

@@ -1,6 +1,6 @@
 module Control.Monad.Class.MonadTest (MonadTest (..)) where
 
-import           Control.Monad.Reader
+import Control.Monad.Reader
 
 -- | A helper monad for /IOSimPOR/.
 class Monad m => MonadTest m where

io-classes/src/Control/Monad/Class/MonadThrow.hs

@@ -25,14 +25,14 @@ module Control.Monad.Class.MonadThrow
   , catches
   ) where
 
-import           Control.Exception (Exception (..), MaskingState, SomeException)
-import qualified Control.Exception as IO
-import           Control.Monad (liftM)
+import Control.Exception (Exception (..), MaskingState, SomeException)
+import Control.Exception qualified as IO
+import Control.Monad (liftM)
 
-import           Control.Monad.Reader (ReaderT (..), runReaderT, lift)
+import Control.Monad.Reader (ReaderT (..), lift, runReaderT)
 
-import           Control.Monad.STM (STM)
-import qualified Control.Monad.STM as STM
+import Control.Monad.STM (STM)
+import Control.Monad.STM qualified as STM
 
 -- | Throwing exceptions, and resource handling in the presence of exceptions.
 --

io-classes/src/Control/Monad/Class/MonadTime.hs

@@ -14,13 +14,12 @@ module Control.Monad.Class.MonadTime
   , NominalDiffTime
   ) where
 
-import           Control.Monad.Reader
+import Control.Monad.Reader
 
-import           Data.Time.Clock (NominalDiffTime, UTCTime,
-                     addUTCTime, diffUTCTime)
-import qualified Data.Time.Clock as Time
-import           Data.Word (Word64)
-import qualified GHC.Clock as IO (getMonotonicTimeNSec)
+import Data.Time.Clock (NominalDiffTime, UTCTime, addUTCTime, diffUTCTime)
+import Data.Time.Clock qualified as Time
+import Data.Word (Word64)
+import GHC.Clock qualified as IO (getMonotonicTimeNSec)
 
 
 class Monad m => MonadMonotonicTimeNSec m where

io-classes/src/Control/Monad/Class/MonadTimer.hs

@@ -13,14 +13,14 @@ module Control.Monad.Class.MonadTimer
   , MonadTimer (..)
   ) where
 
-import qualified Control.Concurrent as IO
-import           Control.Concurrent.Class.MonadSTM
-import qualified Control.Concurrent.STM.TVar as STM
+import Control.Concurrent qualified as IO
+import Control.Concurrent.Class.MonadSTM
+import Control.Concurrent.STM.TVar qualified as STM
 
-import           Control.Monad.Reader (ReaderT (..))
-import           Control.Monad.Trans (lift)
+import Control.Monad.Reader (ReaderT (..))
+import Control.Monad.Trans (lift)
 
-import qualified System.Timeout as IO
+import System.Timeout qualified as IO
 
 -- | A typeclass to delay current thread.
 class Monad m => MonadDelay m where