diff --git a/.travis.yml b/.travis.yml
index 5922f50..a6b4a16 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -180,7 +180,7 @@ before_install:
 - |
   function better_wait() {
     date
-    time "$@" & # send the long living command to background!
+    time $* & # send the long living command to background!
 
     set +x
     MINUTES=0
@@ -196,7 +196,6 @@ before_install:
 
       sleep 60
     done
-    wait $!
     set -x
   }
 
@@ -232,7 +231,7 @@ install:
         echo "cabal build-cache MISS";
         rm -rf $HOME/.cabsnap;
         mkdir -p $HOME/.ghc $HOME/.cabal/lib $HOME/.cabal/share $HOME/.cabal/bin;
-        cabal install -j$JOBS --only-dependencies --enable-tests --enable-benchmarks --ghc-options="-j1 +RTS -M500M -RTS";
+        cabal install -j$JOBS --only-dependencies --enable-tests --enable-benchmarks;
       fi
       
       # snapshot package-db on cache miss
@@ -260,12 +259,12 @@ script:
   set -ex
   case "$BUILD" in
     stack)
-      better_wait stack --no-terminal $ARGS test --bench --no-run-benchmarks --haddock --no-haddock-deps --ghc-options="-j1 +RTS -M500M -RTS"
+      better_wait stack --no-terminal $ARGS test --bench --no-run-benchmarks --haddock --no-haddock-deps
       ;;
     cabal)
       if [ -f configure.ac ]; then autoreconf -i; fi
       cabal configure --enable-tests --enable-benchmarks -v  # -v2 provides useful information for debugging
-      better_wait cabal build -j$JOBS --ghc-options="-j1 +RTS -M500M -RTS" # this builds all libraries and executables (including tests/benchmarks)
+      better_wait cabal build -j$JOBS  # this builds all libraries and executables (including tests/benchmarks)
       cabal test
       ;;
     cabaldist)
@@ -276,12 +275,12 @@ script:
       # If there are no other `.tar.gz` files in `dist`, this can be even simpler:
       # `cabal install --force-reinstalls dist/*-*.tar.gz`
       SRC_TGZ=$(cabal info . | awk '{print $2;exit}').tar.gz &&
-      (cd dist && better_wait cabal install -j$JOBS --force-reinstalls "$SRC_TGZ" --ghc-options="-j1 +RTS -M500M -RTS")
+      (cd dist && better_wait cabal install -j$JOBS --force-reinstalls "$SRC_TGZ")
       ;;
     canew)
       better_wait cabal new-build -j$JOBS --disable-tests --disable-benchmarks
       better_wait cabal new-build -j$JOBS --enable-tests --enable-benchmarks
-      cabal new-test --ghc-options="-j1 +RTS -M500M -RTS"
+      cabal new-test
       ;;
   esac
   set +ex
diff --git a/ChangeLog.md b/ChangeLog.md
index 236a7ad..4d16652 100644
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,18 +1,5 @@
 # Revision history for brittany
 
-## 0.8.0.3  -- September 2017
-
-* Support for ghc-8.2.1
-* Bugfixes:
-    - Fix quadratic performance issue
-    - Fix special "where" indentation with indentAmount /= 2
-    - Fix negative literals in patterns
-    - Support type applications
-* Accept `-h` for `--help` and improve help layouting (via butcher-1.1.0.2)
-* Add continuous integration via travis (cabal, cabal-new, stack)
-  (brittle due compilation time limit)
-* Reduce compilation memory usage a bit
-
 ## 0.8.0.2  -- August 2017
 
 * Add library interface, to be used by `haskell-ide-engine`.
diff --git a/README.md b/README.md
index 5d232a2..c048afa 100644
--- a/README.md
+++ b/README.md
@@ -39,14 +39,13 @@ require fixing:
   be detected and the user will get an error); there are other cases where
   comments are moved slightly; there are also cases where comments result in
   wonky newline insertion (although this should be a purely aesthetic issue.)
-- ~~There is an **open performance issue on large inputs** (due to an
-  accidentally quadratic sub-algorithm); noticable for inputs with >1k loc.~~
-  (fixed in `0.8.0.3`)
+- There is an **open performance issue on large inputs** (due to an
+  accidentally quadratic sub-algorithm); noticable for inputs with >1k loc.
 
 # Other usage notes
 
-- Supports GHC versions `8.0.*` and `8.2.*`.
-- as of November'17, `brittany` is available on stackage nightly.
+- Requires `GHC-8.0.*`; support for 8.2 is on the list, but I haven't even
+  looked at how much the `GHC` API changes.
 - config (file) documentation is lacking.
 - some config values can not be configured via commandline yet.
 - uses/creates user config file in `~/.brittany/config.yaml`;
@@ -110,21 +109,9 @@ require fixing:
       - -XBangPatterns
     ~~~~
 
-# Feature Requests, Contribution, Documentation
+# Implementation/High-level Documentation
 
-This currently is a one-person project in the sense that 90% of the code is
-written by one person. And (unfortunately) it is not my job to keep improving
-this project. Please forgive that as a consequence my time to invest on new
-features is rather limited.
-
-Nonetheless I consider it "in active development" :)
-
-One way of speeding things up is to make your own contributions. There is
-a good amount of high-level documentation at
-
-[the documentation index](doc/implementation/index.md)
-
-Note that most development happens on the `dev` branch of this repository!
+[See the documentation index](doc/implementation/index.md)
 
 # License
 
diff --git a/brittany.cabal b/brittany.cabal
index bf2ba63..07504a0 100644
--- a/brittany.cabal
+++ b/brittany.cabal
@@ -24,7 +24,7 @@ extra-doc-files: {
   doc/implementation/*.md
 }
 extra-source-files: {
-  src-literatetests/*.blt
+  src-literatetests/tests.blt
 }
 
 source-repository head {
@@ -80,6 +80,7 @@ library {
   }
   ghc-options: {
     -Wall
+    -j
     -fno-warn-unused-imports
     -fno-warn-redundant-constraints
   }
@@ -102,7 +103,7 @@ library {
     , pretty >=1.1.3.3 && <1.2
     , bytestring >=0.10.8.1 && <0.11
     , directory >=1.2.6.2 && <1.4
-    , butcher >=1.2 && <1.3
+    , butcher >=1.1.0.0 && <1.2
     , yaml >=0.8.18 && <0.9
     , aeson >=1.0.1.0 && <1.3
     , extra >=1.4.10 && <1.7
@@ -112,6 +113,7 @@ library {
     , unsafe >=0.0 && <0.1
     , safe >=0.3.9 && <0.4
     , deepseq >=1.4.2.0 && <1.5
+    , either >=4.4.1.1 && <4.5
     , semigroups >=0.18.2 && <0.19
     , cmdargs >=0.10.14 && <0.11
     , czipwith >=1.0.0.0 && <1.1
@@ -146,7 +148,7 @@ executable brittany
   other-modules: {
     Paths_brittany
   }
-  -- other-extensions:
+  -- other-extensions:    
   build-depends:
     { brittany
     , base
@@ -174,6 +176,7 @@ executable brittany
     , unsafe
     , safe
     , deepseq
+    , either
     , semigroups
     , cmdargs
     , czipwith
@@ -200,6 +203,7 @@ executable brittany
   }
   ghc-options: {
     -Wall
+    -j
     -fno-spec-constr
     -fno-warn-unused-imports
     -fno-warn-redundant-constraints
@@ -250,6 +254,7 @@ test-suite unittests
     , unsafe
     , safe
     , deepseq
+    , either
     , semigroups
     , cmdargs
     , czipwith
@@ -278,6 +283,7 @@ test-suite unittests
   }
   ghc-options: {
     -Wall
+    -j
     -fno-warn-unused-imports
     -rtsopts
     -with-rtsopts "-M2G"
@@ -321,17 +327,17 @@ test-suite littests
     , unsafe
     , safe
     , deepseq
+    , either
     , semigroups
     , cmdargs
     , czipwith
     , ghc-boot-th
     , hspec >=2.4.1 && <2.5
-    , filepath
     , parsec >=3.1.11 && <3.2
     }
   ghc-options:      -Wall
   main-is:          Main.hs
-  other-modules:
+  other-modules:    
   hs-source-dirs:   src-literatetests
   default-extensions: {
     CPP
@@ -350,6 +356,7 @@ test-suite littests
   }
   ghc-options: {
     -Wall
+    -j
     -fno-warn-unused-imports
     -rtsopts
     -with-rtsopts "-M2G"
@@ -375,7 +382,7 @@ test-suite libinterfacetests
     }
   ghc-options:      -Wall
   main-is:          Main.hs
-  other-modules:
+  other-modules:    
   hs-source-dirs:   src-libinterfacetests
   default-extensions: {
     FlexibleContexts
@@ -388,6 +395,7 @@ test-suite libinterfacetests
   }
   ghc-options: {
     -Wall
+    -j
     -fno-warn-unused-imports
     -rtsopts
     -with-rtsopts "-M2G"
diff --git a/doc/hcar/Brittany.tex b/doc/hcar/Brittany.tex
index f181b2f..5c6760d 100644
--- a/doc/hcar/Brittany.tex
+++ b/doc/hcar/Brittany.tex
@@ -1,6 +1,6 @@
-% Brittany-LB.tex
-\begin{hcarentry}[updated]{Brittany}
-\report{Lennart Spitzner}%11/17
+% Brittany-LE.tex
+\begin{hcarentry}[new]{Brittany}
+\report{Lennart Spitzner}%11/16
 \status{work in progress}
 \makeheader
 
@@ -11,35 +11,44 @@ haskell-src-exts such as hindent or haskell-formatter.
 The goals of the project are to:
 
 \begin{compactitem}
-\item support the full ghc-haskell syntax including syntactic extensions;
-\item retain newlines and comments unmodified (to the degree possible when
-  code around them gets reformatted);
-\item be clever about using horizontal space while not overflowing it if it
-  cannot be avoided;
-\item have linear complexity in the size of the input text / the number of
+\item
+  support the full ghc-haskell syntax including syntactic extensions;
+\item
+  retain newlines and comments unmodified (to the degree possible when code
+  around them gets reformatted);
+\item
+  be clever about using horizontal space while not overflowing it if it cannot
+  be avoided;
+\item
+  have linear complexity in the size of the input text / the number of
   syntactic nodes in the input.
-\item support horizontal alignments (e.g. different equations/pattern matches
-  in the some function's definition).
+\item
+  support horizontal alignments (e.g. different equations/pattern matches in
+  the some function's definition).
 \end{compactitem}
 
-In contrast to other formatters brittany internally works in two steps:
-Firstly transforming the syntax tree into a document tree representation,
-similar to the document representation in general-purpose pretty-printers such
-as the \emph{pretty} package, but much more specialized for the specific
-purpose of handling a Haskell source code document. Secondly this document
-representation is transformed into the output text document. This approach
-allows to handle many different syntactic constructs in a uniform way, making
-it possible to attain the above goals with a manageable amount of work.
+In contrast to other formatters brittany internally works in two steps: Firstly
+transforming the syntax tree into a document tree representation, similar to
+the document representation in general-purpose pretty-printers such as the
+\emph{pretty} package, but much more specialized for the specific purpose of
+handling a Haskell source code document. Secondly this document representation
+is transformed into the output text document. This approach allows to handle
+many different syntactic constructs in a uniform way, making it possible
+to attain the above goals with a manageable amount of work.
 
 Brittany is work in progress; currently only type signatures and function
 bindings are transformed, and not all syntactic constructs are supported.
-Nonetheless Brittany is safe to try/use as there are checks in place to ensure
-that the output is syntactically valid.
+Nonetheless Brittany is safe to try/use as there are checks in place to
+ensure that the output is syntactically valid.
 
-Brittany requires ghc-8.*, and is available on Hackage and on Stackage.
+Brittany requires ghc-8, and is not released on hackage yet; for a description
+of how to build it see the repository README.
 
 \FurtherReading
+{\small
 \begin{compactitem}
-  \item \url{https://github.com/lspitzner/brittany}
+  \item
+    \url{https://github.com/lspitzner/brittany}
 \end{compactitem}
+}
 \end{hcarentry}
diff --git a/src-brittany/Main.hs b/src-brittany/Main.hs
index 046c830..129ee50 100644
--- a/src-brittany/Main.hs
+++ b/src-brittany/Main.hs
@@ -12,12 +12,8 @@ import qualified Language.Haskell.GHC.ExactPrint.Types as ExactPrint.Types
 import qualified Language.Haskell.GHC.ExactPrint.Parsers as ExactPrint.Parsers
 import qualified Data.Map as Map
 
-import           Text.Read (Read(..))
-import qualified Text.ParserCombinators.ReadP as ReadP
-import qualified Text.ParserCombinators.ReadPrec as ReadPrec
 import qualified Data.Text.Lazy.Builder as Text.Builder
 
-import           Control.Monad (zipWithM)
 import           Data.CZipWith
 
 import qualified Debug.Trace as Trace
@@ -43,17 +39,6 @@ import qualified GHC.LanguageExtensions.Type as GHC
 import Paths_brittany
 
 
-data WriteMode = Display | Inplace
-
-instance Read WriteMode where
-  readPrec = val "display" Display <|> val "inplace" Inplace
-   where
-    val iden v = ReadPrec.lift $ ReadP.string iden >> return v
-
-instance Show WriteMode where
-  show Display = "display"
-  show Inplace = "inplace"
-
 
 main :: IO ()
 main = mainFromCmdParserWithHelpDesc mainCmdParser
@@ -62,24 +47,13 @@ helpDoc :: PP.Doc
 helpDoc = PP.vcat $ List.intersperse
   (PP.text "")
   [ parDocW
-    [ "Reformats one or more haskell modules."
-    , "Currently affects only type signatures and function bindings;"
-    , "everything else is left unmodified."
+    [ "Transforms one haskell module by reformatting"
+    , "(parts of) the source code (while preserving the"
+    , "parts not transformed)."
     , "Based on ghc-exactprint, thus (theoretically) supporting all"
     , "that ghc does."
+    , "Currently, only type-signatures and function-bindings are transformed."
     ]
-  , parDoc $ "Example invocations:"
-  , PP.hang (PP.text "") 2 $ PP.vcat
-      [ PP.text "brittany"
-      , PP.hang (PP.text "  ") 2 $ PP.text "read from stdin, output to stdout"
-      ]
-  , PP.hang (PP.text "") 2 $ PP.vcat
-      [ PP.text "brittany --indent=4 --write-mode=inplace *.hs"
-      , PP.nest 2 $ PP.vcat
-        [ PP.text "run on all modules in current directory (no backup!)"
-        , PP.text "4 spaces indentation"
-        ]
-      ]
   , parDocW
     [ "This program is written carefully and contains safeguards to ensure"
     , "the transformation does not change semantics (or the syntax tree at all)"
@@ -129,6 +103,8 @@ mainCmdParser helpDesc = do
   printHelp      <- addSimpleBoolFlag "h" ["help"] mempty
   printVersion   <- addSimpleBoolFlag "" ["version"] mempty
   printLicense   <- addSimpleBoolFlag "" ["license"] mempty
+  inputPaths     <- addFlagStringParams "i" ["input"] "PATH" (flagHelpStr "path to input haskell source file")
+  outputPaths    <- addFlagStringParams "o" ["output"] "PATH" (flagHelpStr "output file path")
   configPaths    <- addFlagStringParams "" ["config-file"] "PATH" (flagHelpStr "path to config file") -- TODO: allow default on addFlagStringParam ?
   cmdlineConfig  <- configParser
   suppressOutput <- addSimpleBoolFlag
@@ -136,20 +112,9 @@ mainCmdParser helpDesc = do
     ["suppress-output"]
     (flagHelp $ parDoc "suppress the regular output, i.e. the transformed haskell source")
   _verbosity <- addSimpleCountFlag "v" ["verbose"] (flagHelp $ parDoc "[currently without effect; TODO]")
-  writeMode  <- addFlagReadParam
-    ""
-    ["write-mode"]
-    "(display|inplace)"
-    Flag
-      { _flag_help    = Just $ PP.vcat
-          [ PP.text "display: output for any input(s) goes to stdout"
-          , PP.text "inplace: override respective input file (without backup!)"
-          ]
-      , _flag_default = Just Display
-      }
-  inputParams <- addParamNoFlagStrings "PATH" (paramHelpStr "paths to input haskell source files")
   reorderStop
-  desc        <- peekCmdDesc
+  inputParam <- addStringParamOpt "PATH" (paramHelpStr "path to input haskell source file")
+  desc       <- peekCmdDesc
   addCmdImpl $ void $ do
     when printLicense $ do
       print licenseDoc
@@ -163,22 +128,29 @@ mainCmdParser helpDesc = do
     when printHelp $ do
       liftIO $ print $ ppHelpShallow desc
       System.Exit.exitSuccess
-
-    let inputPaths  = if null inputParams then [Nothing] else map Just inputParams
-    let outputPaths = case writeMode of
-                      Display -> repeat Nothing
-                      Inplace -> inputPaths
-
+    inputPathM <- case maybeToList inputParam ++ inputPaths of
+      [] -> do
+        return Nothing
+      [x] -> return $ Just x
+      _   -> do
+        putStrErrLn $ "more than one input, aborting"
+        System.Exit.exitWith (System.Exit.ExitFailure 51)
+    outputPathM <- case outputPaths of
+      [] -> do
+        return Nothing
+      [x] -> return $ Just x
+      _   -> do
+        putStrErrLn $ "more than one output, aborting"
+        System.Exit.exitWith (System.Exit.ExitFailure 52)
     config <- runMaybeT (readConfigs cmdlineConfig configPaths) >>= \case
       Nothing -> System.Exit.exitWith (System.Exit.ExitFailure 53)
       Just x  -> return x
     when (confUnpack $ _dconf_dump_config $ _conf_debug $ config) $ do
       trace (showConfigYaml config) $ return ()
-
-    results <- zipWithM (coreIO putStrErrLn config suppressOutput) inputPaths outputPaths
-    case sequence_ results of
-      Left  _ -> System.Exit.exitWith (System.Exit.ExitFailure 1)
-      Right _ -> pure ()
+    eitherErrSucc <- coreIO putStrErrLn config suppressOutput inputPathM outputPathM
+    case eitherErrSucc of
+      Left errNo -> System.Exit.exitWith (System.Exit.ExitFailure errNo)
+      Right ()   -> pure ()
 
 
 -- | The main IO parts for the default mode of operation, and after commandline
@@ -193,8 +165,8 @@ coreIO
   -> Maybe FilePath.FilePath -- ^ input filepath; stdin if Nothing.
   -> Maybe FilePath.FilePath -- ^ output filepath; stdout if Nothing.
   -> IO (Either Int ())      -- ^ Either an errorNo, or success.
-coreIO putErrorLnIO config suppressOutput inputPathM outputPathM = ExceptT.runExceptT $ do
-  let putErrorLn         = liftIO . putErrorLnIO :: String -> ExceptT.ExceptT e IO ()
+coreIO putErrorLnIO config suppressOutput inputPathM outputPathM = EitherT.runEitherT $ do
+  let putErrorLn         = liftIO . putErrorLnIO :: String -> EitherT.EitherT e IO ()
   let ghcOptions         = config & _conf_forward & _options_ghc & runIdentity
   -- there is a good of code duplication between the following code and the
   -- `pureModuleTransform` function. Unfortunately, there are also a good
@@ -234,7 +206,7 @@ coreIO putErrorLnIO config suppressOutput inputPathM outputPathM = ExceptT.runEx
     Left left -> do
       putErrorLn "parse error:"
       putErrorLn $ show left
-      ExceptT.throwE 60
+      EitherT.left 60
     Right (anns, parsedSource, hasCPP) -> do
       when (config & _conf_debug .> _dconf_dump_ast_full .> confUnpack) $ do
         let val = printTreeWithCustom 100 (customLayouterF anns) parsedSource
@@ -300,7 +272,7 @@ coreIO putErrorLnIO config suppressOutput inputPathM outputPathM = ExceptT.runEx
         Nothing -> liftIO $ TextL.IO.putStr $ outLText
         Just p  -> liftIO $ TextL.IO.writeFile p $ outLText
 
-      when hasErrors $ ExceptT.throwE 70
+      when hasErrors $ EitherT.left 70
  where
   addTraceSep conf =
     if or
@@ -320,38 +292,15 @@ coreIO putErrorLnIO config suppressOutput inputPathM outputPathM = ExceptT.runEx
 
 readConfigs :: CConfig Option -> [System.IO.FilePath] -> MaybeT IO Config
 readConfigs cmdlineConfig configPaths = do
-  userBritPathSimple <- liftIO $ Directory.getAppUserDataDirectory "brittany"
-  userBritPathXdg    <- liftIO
-    $ Directory.getXdgDirectory Directory.XdgConfig "brittany"
-  let userConfigPathSimple = userBritPathSimple FilePath.</> "config.yaml"
-  let userConfigPathXdg    = userBritPathXdg FilePath.</> "config.yaml"
-  let
-    findLocalConfig :: MaybeT IO (Maybe (CConfig Option))
-    findLocalConfig = do
-      cwd <- liftIO $ Directory.getCurrentDirectory
-      let dirParts = FilePath.splitDirectories cwd
-      let searchDirs =
-            [ FilePath.joinPath x | x <- reverse $ List.inits dirParts ]
-      -- when cwd is "a/b/c", searchDirs is ["a/b/c", "a/b", "a", "/"]
-      mFilePath <- liftIO $ Directory.findFileWith Directory.doesFileExist
-                                                   searchDirs
-                                                   "brittany.yaml"
-      case mFilePath of
-        Nothing -> pure Nothing
-        Just fp -> readConfig fp
-  configsRead <- case configPaths of
+  let defLocalConfigPath = "brittany.yaml"
+  userBritPath <- liftIO $ Directory.getAppUserDataDirectory "brittany"
+  let defUserConfigPath = userBritPath FilePath.</> "config.yaml"
+  merged <- case configPaths of
     [] -> do
-      localConfig      <- findLocalConfig
-      userConfigSimple <- readConfig userConfigPathSimple
-      userConfigXdg    <- readConfig userConfigPathXdg
-      let userConfig = userConfigSimple <|> userConfigXdg
-      when (Data.Maybe.isNothing userConfig) $ do
-        liftIO $ Directory.createDirectoryIfMissing False userBritPathXdg
-        writeDefaultConfig userConfigPathXdg
-      -- rightmost has highest priority
-      pure $ [userConfig, localConfig]
-    paths -> readConfig `mapM` reverse paths
-                   -- reverse to give highest priority to the first
-  merged <-
-    pure $ Semigroup.mconcat $ catMaybes $ configsRead ++ [Just cmdlineConfig]
+      liftIO $ Directory.createDirectoryIfMissing False userBritPath
+      return cmdlineConfig
+        >>= readMergePersConfig defLocalConfigPath False
+        >>= readMergePersConfig defUserConfigPath  True
+    -- TODO: ensure that paths exist ?
+    paths -> foldl (\prev p -> prev >>= readMergePersConfig p False) (return cmdlineConfig) paths
   return $ cZipWith fromOptionIdentity staticDefaultConfig merged
diff --git a/src-literatetests/10-tests.blt b/src-literatetests/10-tests.blt
deleted file mode 100644
index e04887c..0000000
--- a/src-literatetests/10-tests.blt
+++ /dev/null
@@ -1,546 +0,0 @@
-
-###############################################################################
-###############################################################################
-###############################################################################
-#group type signatures
-###############################################################################
-###############################################################################
-###############################################################################
-
-#test simple001
-func :: a -> a
-
-#test long typeVar
-func
-  :: lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-  -> lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-
-#test keep linebreak mode
-func
-  :: lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-  -> lakjsdlkjasldkj
-  -> lakjsdlkjasldkj
-
-#test simple parens 1
-func :: ((a))
-
-#test simple parens 2
-func :: (a -> a) -> a
-
-#test simple parens 3
-func :: a -> (a -> a)
-
-#test did anyone say parentheses?
-func :: (((((((((())))))))))
-
--- current output is.. funny. wonder if that can/needs to be improved..
-#test give me more!
-#pending
-func :: ((((((((((((((((((((((((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))))
-
-#test unit
-func :: ()
-
-
-###############################################################################
-
-#test paren'd func 1
-func
-  :: (  lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-     -> lakjsdlkjasldkj
-     -> lakjsdlkjasldkj
-     )
-
-#test paren'd func 2
-func
-  :: lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-  -> (lakjsdlkjasldkj -> lakjsdlkjasldkj)
-
-#test paren'd func 3
-func
-  :: (lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd -> lakjsdlkjasldkj)
-  -> lakjsdlkjasldkj
-
-#test paren'd func 4
-func
-  :: (  lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-     -> lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-     )
-  -> lakjsdlkjasldkj
-
-#test paren'd func 5
-func
-  :: ( (  lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-       -> lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-       )
-     )
-
-###############################################################################
-
-#test type application 1
-func :: asd -> Either a b
-
-#test type application 2
-func
-  :: asd
-  -> Either
-       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-
-#test type application 3
-func
-  :: asd
-  -> Trither
-       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-
-#test type application 4
-func
-  :: Trither
-       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-  -> asd
-
-#test type application 5
-func
-  :: Trither
-       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-       (lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd -> asd)
-
-#test type application 6
-func
-  :: Trither
-       asd
-       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-       (  lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-       -> lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-       )
-
-#test type application paren 1
-func
-  :: asd
-  -> ( Trither
-         lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-         lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-         lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-     )
-
-#test type application paren 2
-func
-  :: asd
-  -> ( Trither
-         lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-         lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-     )
-       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-
-#test type application paren 3
-func
-  :: ( Trither
-         lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-         lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-     )
-       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-  -> asd
-
-###############################################################################
-
-#test list simple
-func :: [a -> b]
-
-#test list func
-func
-  :: [  lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-     -> lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-     ]
-
-#test list paren
-func
-  :: [ (  lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-       -> lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-       )
-     ]
-
-################################################################## -- #############
-
-#test tuple type 1
-func :: (a, b, c)
-
-#test tuple type 2
-func :: ((a, b, c), (a, b, c), (a, b, c))
-
-#test tuple type long
-func
-  :: ( lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-     , lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-     , lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-     )
-
-#test tuple type nested
-func
-  :: ( ( lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-       , (lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd)
-       , lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-       )
-     )
-
-#test tuple type function
-func
-  :: [ ( lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-       , lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-       , lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-       )
-     ]
-###############################################################################
-#test type operator stuff
-#pending
-test050 :: a :+: b
-test051 ::  lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-        :+: lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-test052 ::  lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-        ->  lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-        :+: lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-        ->  lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-
-###############################################################################
-
-#test forall oneliner
-{-# LANGUAGE ScopedTypeVariables #-}
-func :: forall (a :: *) b . a -> b
-
-#test forall context multiline
-{-# LANGUAGE ScopedTypeVariables #-}
-func
-  :: forall m
-   . Foo
-  => ColMap2
-  -> ColInfo
-  -> ColInfo
-  -> ColInfo
-  -> ColInfo
-  -> m ()
-
-#test forall no-context multiline
-{-# LANGUAGE ScopedTypeVariables #-}
-func
-  :: forall m
-  .  ColMap2
-  -> ColInfo
-  -> ColInfo
-  -> ColInfo
-  -> ColInfo
-  -> ColInfo
-  -> m ()
-
-#test language pragma issue
-{-# LANGUAGE ScopedTypeVariables #-}
-func :: forall (a :: *) b . a -> b
-
-#test comments 1
-func :: a -> b -- comment
-
-#test comments 2
-funcA :: a -> b -- comment A
-funcB :: a -> b -- comment B
-
-#test comments all
-#pending
--- a
-func -- b
-  :: -- c
-  a -- d
-  -> -- e
-  ( -- f
-  c -- g
-  , -- h
-  d -- i
-  ) -- j
--- k
-
-
-###############################################################################
-###############################################################################
-###############################################################################
-#group type signatures pragmas
-###############################################################################
-###############################################################################
-###############################################################################
-
-#test inline pragma 1
-func = f
- where
-  {-# INLINE f #-}
-  f = id
-
-#test inline pragma 2
-func = ($)
- where
-  {-# INLINE ($) #-}
-  ($) = id
-
-#test inline pragma 3
-func = f
- where
-  {-# INLINE CONLIKE [1] f #-}
-  f = id
-
-#test inline pragma 4
-#pending this does not work with the compiler version we currently use yet (i think). should work with ghc-8.0.2.
-func = f
- where
-  {-# INLINE [~] f #-}
-  f = id
-
-
-###############################################################################
-###############################################################################
-###############################################################################
-#group equation.basic
-###############################################################################
-###############################################################################
-###############################################################################
-## some basic testing of different kinds of equations.
-## some focus on column layouting for multiple-equation definitions.
-## (that part probably is not implemented in any way yet.)
-
-#test basic 1
-func x = x
-
-#test infix 1
-x *** y = x
-
-#test symbol prefix
-(***) x y = x
-
-
-###############################################################################
-###############################################################################
-###############################################################################
-#group equation.patterns
-###############################################################################
-###############################################################################
-###############################################################################
-
-#test wildcard
-func _ = x
-
-#test simple long pattern
-#pending
-func reallyreallyreallyreallyreallyreallyreallyreallyreallyreallylongvariable
-  = x
-
-#test simple multiline pattern
-#pending
-func reallyreallyreallyreallyreallyreallyreallyreallyreallyreallylongvariable
-     reallyreallyreallyreallyreallyreallyreallyreallyreallyreallylongvariable
-  = x
-
-#test another multiline pattern
-#pending
-func reallyreallyreallyreallyreallyreallyreallyreallyreallyreallylongvariable
-     a
-     b
-  = x
-
-#test simple constructor
-func (A a) = a
-
-#test list constructor
-func (x:xr) = x
-
-#test some other constructor symbol
-#pending
-func (x:+:xr) = x
-
-
-###############################################################################
-###############################################################################
-###############################################################################
-#group equation.guards
-###############################################################################
-###############################################################################
-###############################################################################
-#test simple guard
-func | True = x
-
-#test multiple-clauses-1
-func x | x         = simple expression
-       | otherwise = 0
-
-#test multiple-clauses-2
-func x
-  | a somewhat longer guard x = "and a somewhat longer expession that does not"
-  | otherwise                 = "fit without putting the guards in new lines"
-
-#test multiple-clauses-3
-func x
-  | very long guard, another rather long guard that refers to x = nontrivial
-    expression
-    foo
-    bar
-    alsdkjlasdjlasj
-  | otherwise = 0
-
-#test multiple-clauses-4
-func x
-  | very long guard, another rather long guard that refers to x
-  = nontrivialexpression foo bar alsdkjlasdjlasj
-  | otherwise
-  = 0
-
-#test multiple-clauses-5
-func x
-  | very loooooooooooooooooooooooooooooong guard
-  , another rather long guard that refers to x
-  = nontrivial expression foo bar alsdkjlasdjlasj
-  | otherwise
-  = 0
-
-
-###############################################################################
-###############################################################################
-###############################################################################
-#group expression.basic
-###############################################################################
-###############################################################################
-###############################################################################
-
-#test var
-func = x
-
-describe "infix op" $ do
-#test 1
-func = x + x
-
-#test long
-#pending
-func = mweroiuxlskdfjlksjdflkjsdfljksldkjflkjsdflkj
-     + mweroiuxlskdfjlksjdflkjsdfljksldkjflkjsdflkj
-
-#test long keep linemode 1
-#pending
-func = mweroiuxlskdfjlksjdflkjsdfljksldkjflkjsdflkj
-     + mweroiuxlskdfjlksj
-     + mweroiuxlskdfjlksj
-
-#test long keep linemode 2
-#pending
-func = mweroiuxlskdfjlksj
-     + mweroiuxlskdfjlksj
-     + mweroiuxlskdfjlksjdflkjsdfljksldkjflkjsdflkj
-
-#test literals
-func = 1
-func = "abc"
-func = 1.1e5
-func = 'x'
-func = 981409823458910394810928414192837123987123987123
-
-#test lambda
-func = \x -> abc
-
-describe "app" $ do
-#test 1
-func = klajsdas klajsdas klajsdas
-
-#test 2
-func = lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd
-  lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd
-  lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd
-
-#test 3
-func = lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd lakjsdlajsdljas
-                                                     lakjsdlajsdljas
-                                                     lakjsdlajsdljas
-
-###
-#group expression.basic.sections
-###
-
-#test left
-func = (1 +)
-
-#test right
-func = (+ 1)
-
-#test left inf
-func = (1 `abc`)
-
-#test right inf
-func = (`abc` 1)
-
-###
-#group tuples
-###
-
-#test 1
-func = (abc, def)
-
-#test 2
-#pending
-func = (lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd
-  , lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd)
-
-
-
-###############################################################################
-###############################################################################
-###############################################################################
-#group expression.do statements
-###############################################################################
-###############################################################################
-###############################################################################
-
-#test simple
-func = do
-  stmt
-  stmt
-
-#test bind
-func = do
-  x <- stmt
-  stmt x
-
-#test let
-func = do
-  let x = 13
-  stmt x
-
-
-###############################################################################
-###############################################################################
-###############################################################################
-#group expression.lists
-###############################################################################
-###############################################################################
-###############################################################################
-
-#test monad-comprehension-case-of
-func =
-  foooooo
-    $ [ case
-          foooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
-        of
-          _ -> True
-      ]
-
-
-###############################################################################
-###############################################################################
-###############################################################################
-#group stylisticspecialcases
-###############################################################################
-###############################################################################
-###############################################################################
-
-#test operatorprefixalignment-even-with-multiline-alignbreak
-func =
-  foo
-    $  [ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-       , bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
-       ]
-    ++ [ccccccccccccccccccccccccccccccccccccccccccccccccccccccccc]
-
diff --git a/src-literatetests/14-extensions.blt b/src-literatetests/14-extensions.blt
deleted file mode 100644
index 896d105..0000000
--- a/src-literatetests/14-extensions.blt
+++ /dev/null
@@ -1,68 +0,0 @@
-###############################################################################
-###############################################################################
-###############################################################################
-#group extensions
-###############################################################################
-###############################################################################
-###############################################################################
-
-###############################################################################
-## MultiWayIf
-#test multiwayif 1
-{-# LANGUAGE MultiWayIf #-}
-func = if
-  | cond1 -> loooooooooooooooooooooooooooooong expr1
-  | cond2 -> loooooooooooooooooooooooooooooong expr2
-
-#test multiwayif 2
-{-# LANGUAGE MultiWayIf #-}
-func = do
-  foo
-  bar $ if
-    | cond1 -> loooooooooooooooooooooooooooooong expr1
-    | cond2 -> loooooooooooooooooooooooooooooong expr2
-
-
-###############################################################################
-## LambdaCase
-#test lambdacase 1
-{-# LANGUAGE LambdaCase #-}
-func = \case
-  FooBar -> x
-  Baz    -> y
-
-
-
-###############################################################################
-## ImplicitParams
-#test ImplicitParams 1
-{-# LANGUAGE ImplicitParams #-}
-func :: (?asd::Int) -> ()
-
-#test ImplicitParams 2
-{-# LANGUAGE ImplicitParams #-}
-func
-  :: (  ?asd
-     :: lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-     -> lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-     )
-  -> ()
-
-
-###############################################################################
-## RecursiveDo
-#test recursivedo 1
-{-# LANGUAGE RecursiveDo #-}
-foo = do
-  rec a <- f b
-      b <- g a
-  return (a, b)
-
-#test recursivedo 2
-{-# LANGUAGE RecursiveDo #-}
-foo = do
-  rec -- comment
-      a <- f b
-      b <- g a
-  return (a, b)
-
diff --git a/src-literatetests/15-regressions.blt b/src-literatetests/15-regressions.blt
deleted file mode 100644
index 0876dc3..0000000
--- a/src-literatetests/15-regressions.blt
+++ /dev/null
@@ -1,495 +0,0 @@
-###############################################################################
-###############################################################################
-###############################################################################
-#group regression
-###############################################################################
-###############################################################################
-###############################################################################
-
-#test newlines-comment
-func = do
-  abc <- foo
-
---abc
-return ()
-
-#test parenthesis-around-unit
-func = (())
-
-#test let-defs indentation
-func = do
-  let foo True = True
-      foo _    = False
-  return ()
-
-#test record update indentation 1
-func = do
-  s <- mGet
-  mSet $ s { _lstate_indent = _lstate_indent state }
-
-#test record update indentation 2
-func = do
-  s <- mGet
-  mSet $ s { _lstate_indent = _lstate_indent state
-           , _lstate_indent = _lstate_indent state
-           }
-
-#test record update indentation 3
-func = do
-  s <- mGet
-  mSet $ s
-    { _lstate_indent = _lstate_indent lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-    , _lstate_indent = _lstate_indent lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
-    }
-
-#test post-indent comment
-func = do
--- abc
-  -- def
-  return ()
-
-#test post-unindent comment
-func = do
-  do
-    return ()
-    -- abc
-  -- def
-  return ()
-
-#test CPP empty comment case
-#pending CPP parsing needs fixing for roundTripEqual
-{-# LANGUAGE CPP #-}
-module Test where
-func = do
-#if FOO
-  let x = 13
-#endif
-  stmt x
-
-## really, the following should be handled by forcing the Alt to multiline
-## because there are comments. as long as this is not implemented though,
-## we should ensure the trivial solution works.
-#test comment inline placement (temporary)
-func
-  :: Int -- basic indentation amount
-  -> Int -- currently used width in current line (after indent)
-         -- used to accurately calc placing of the current-line
-  -> LayoutDesc
-  -> Int
-
-#test some indentation thingy
-func =
-  ( lkjadljasldjalskdjaldjalsdjkalsdjlaksdjlasjdlajsaldskj
-  $ abc
-  $ def
-  $ ghi
-  $ jkl
-  )
-
-#test parenthesized operator
-buildG bounds0 edges0 = accumArray (flip (:)) [] bounds0 (map reassoc edges0)
-  where reassoc (v, e, w) = (v, (e, w))
-
-#test record pattern matching stuff
-downloadRepoPackage = case repo of
-  RepoLocal {..}    -> return ()
-  RepoLocal { abc } -> return ()
-  RepoLocal{}       -> return ()
-
-#test do let comment indentation level problem
-func = do
-  let (primaryPkg, otherPkgs) = selectPrimaryLocalPackage pwd pkgs'
-      (bproblems, x) = resolveBuildTargets primaryPkg otherPkgs utargets''
-      -- default local dir target if there's no given target
-      utargets'' = "foo"
-  return ()
-
-#test list comprehension comment placement
-func =
-  [ (thing, take 10 alts) --TODO: select best ones
-  | (thing, _got, alts@(_:_)) <- nosuchFooThing
-  , gast                      <- award
-  ]
-
-#test if-then-else comment placement
-func = if x
-  then if y -- y is important
-    then foo
-    else bar
-  else Nothing
-
-#test qualified infix pattern
-#pending "TODO"
-wrapPatPrepend pat prepElem = do
-  patDocs <- layoutPat pat
-  case Seq.viewl patDocs of
-    Seq.EmptyL -> return $ Seq.empty
-    x1 Seq.:< xR -> do
-      x1' <- docSeq [prepElem, return x1]
-      return $ x1' Seq.<| xR
-
-#test type signature multiline forcing issue
-layoutWriteNewlineBlock
-  :: ( MonadMultiWriter Text.Builder.Builder m
-     , MonadMultiState LayoutState m
-     , MonadMultiWriter (Seq String) m
-     )
-  => m ()
-
-#test multiwayif proper indentation
-{-# LANGUAGE MultiWayIf #-}
-readMergePersConfig path shouldCreate conf = do
-  exists <- liftIO $ System.Directory.doesFileExist path
-  if
-    | exists -> do
-      contents <- liftIO $ ByteString.readFile path -- no lazy IO, tyvm.
-      fileConf <- case Data.Yaml.decodeEither contents of
-        Left e -> do
-          liftIO
-            $  putStrErrLn
-            $  "error reading in brittany config from "
-            ++ path
-            ++ ":"
-          liftIO $ putStrErrLn e
-          mzero
-        Right x -> return x
-      return $ fileConf Semigroup.<> conf
-    | shouldCreate -> do
-      liftIO $ ByteString.writeFile path $ Data.Yaml.encode $ cMap
-        (Option . Just . runIdentity)
-        staticDefaultConfig
-      return $ conf
-    | otherwise -> do
-      return conf
-
-#test nested pattern alignment issue"
-func = BuildReport
- where
-  convertInstallOutcome = case result of
-    Left  BR.PlanningFailed      -> PlanningFailed
-    Left  (BR.DependentFailed p) -> DependencyFailed p
-    Left  (BR.DownloadFailed  _) -> DownloadFailed
-    Left  (BR.UnpackFailed    _) -> UnpackFailed
-    Left  (BR.ConfigureFailed _) -> ConfigureFailed
-    Left  (BR.BuildFailed     _) -> BuildFailed
-    Left  (BR.TestsFailed     _) -> TestsFailed
-    Left  (BR.InstallFailed   _) -> InstallFailed
-    Right (BR.BuildOk _ _ _    ) -> InstallOk
-
-#test nested pattern alignment issue"
-func = BuildReport
- where
-  convertInstallOutcome = case result of
-    Left  BR.PlanningFailed      -> PlanningFailed
-    Left  (BR.DependentFailed p) -> DependencyFailed p
-    Left  (BR.DownloadFailed  _) -> DownloadFailed
-    Left  (BR.UnpackFailed    _) -> UnpackFailed
-    Left  (BR.ConfigureFailed _) -> ConfigureFailed
-    Left  (BR.BuildFailed     _) -> BuildFailed
-    Left  (BR.TestsFailed     _) -> TestsFailed
-    Left  (BR.InstallFailed   _) -> InstallFailed
-    Right (BR.BuildOk _ _ _    ) -> InstallOk
-
-#test partially overflowing alignment issue"
-showPackageDetailedInfo pkginfo =
-  renderStyle (style { lineLength = 80, ribbonsPerLine = 1 })
-    $   char '*'
-    $+$ something
-          [ entry "Synopsis" synopsis hideIfNull reflowParagraphs
-          , entry "Versions available"
-                  sourceVersions
-                  (altText null "[ Not available from server ]")
-                  (dispTopVersions 9 (preferredVersions pkginfo))
-          , entry
-            "Versions installed"
-            installedVersions
-            ( altText
-              null
-              (if hasLib pkginfo then "[ Not installed ]" else "[ Unknown ]")
-            )
-            (dispTopVersions 4 (preferredVersions pkginfo))
-          , entry "Homepage"      homepage     orNotSpecified  text
-          , entry "Bug reports"   bugReports   orNotSpecified  text
-          , entry "Description"   description  hideIfNull      reflowParagraphs
-          , entry "Category"      category     hideIfNull      text
-          , entry "License"       license      alwaysShow      disp
-          , entry "Author"        author       hideIfNull      reflowLines
-          , entry "Maintainer"    maintainer   hideIfNull      reflowLines
-          , entry "Source repo"   sourceRepo   orNotSpecified  text
-          , entry "Executables"   executables  hideIfNull      (commaSep text)
-          , entry "Flags" flags hideIfNull (commaSep dispFlag)
-          , entry "Dependencies" dependencies hideIfNull (commaSep dispExtDep)
-          , entry "Documentation" haddockHtml  showIfInstalled text
-          , entry "Cached"        haveTarball  alwaysShow      dispYesNo
-          , if not (hasLib pkginfo)
-            then empty
-            else text "Modules:"
-              $+$ nest 4 (vcat (map disp . sort . modules $ pkginfo))
-          ]
-
-#test issue 7a
-isValidPosition position | validX && validY = Just position
-                         | otherwise        = Nothing
-
-#test issue-6-pattern-linebreak-validity
-## this is ugly, but at least syntactically valid.
-foo = Reflex.runSpiderHost $ ReflexHost.hostApp $ do
-  (inputEvent :: Reflex.Event Reflex.Spider String, inputFire :: String
-    -> IO Bool                                                         ) <-
-    ReflexHost.newExternalEvent
-  liftIO . forkIO . forever $ getLine >>= inputFire
-  ReflexHost.performEvent_ $ fmap (liftIO . putStrLn) inputEvent
-
-#test issue 16
-foldrDesc f z = unSwitchQueue $ \q ->
-  switch (Min.foldrDesc (f unTaggedF) z q) (Min.foldrAsc (f unTaggedF) z q)
-
-#test issue 18
-autocheckCases =
-  [ ("Never Deadlocks"  , representative deadlocksNever)
-  , ("No Exceptions"    , representative exceptionsNever)
-  , ("Consistent Result", alwaysSame) -- already representative
-  ]
-
-#test issue 18b
-autocheckCases =
-  [ ("Never Deadlocks", representative deadlocksNever)
-  , ("No Exceptions"  , representative exceptionsNever)
-  , ( "Consistent Result"
-    , alwaysSame -- already representative
-    )
-  ]
-
-#test issue 18c
-func =
-  [ (abc, (1111, 1111))
-  , (def, (2, 2))
-  , foo -- comment
-  ]
-
-#test issue 26
-foo a b = g a b -- fooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
-  where g a b = b + b * a
-
-#test issue 26b
-foo a b = g a b where g a b = b + b * a -- fooooooooooooooooooooooooooooooooooo
-
-#test aggressive alignment 1
-func = do
-  abc                  <- expr
-  abcccccccccccccccccc <- expr
-  abcccccccccccccccccccccccccccccccccccccccccc <- expr
-  abccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc <- expr
-
-#test example alignment 1
-func (MyLongFoo abc def) = 1
-func (Bar       a   d  ) = 2
-func _                   = 3
-
-#test listcomprehension-case-of
-parserCompactLocation =
-  [ try
-      $ [ ParseRelAbs (Text.Read.read digits) _ _
-        | digits <- many1 digit
-        , rel1 :: Maybe (Either Int (Ratio Int)) <- optionMaybe
-          [ case divPart of
-              Nothing -> Left $ Text.Read.read digits
-              Just ddigits ->
-                Right $ Text.Read.read digits % Text.Read.read ddigits
-          | digits  <- many1 digit
-          , divPart <- optionMaybe (string "/" *> many1 digit)
-          ]
-        ]
-  ]
-
-#test opapp-specialcasing-1
-func = fooooooooooooooooooooooooooooooooo $ foooooooooooooooooooooooooooooooo
-  foooooooooooooooooooooooooooooooo
-  foooooooooooooooooooooooooooooooo
-
-#test opapp-specialcasing-2
-func =
-  fooooooooooooooooooooooooooooooooo
-    + foooooooooooooooooooooooooooooooo foooooooooooooooooooooooooooooooo
-                                        foooooooooooooooooooooooooooooooo
-
-#test opapp-specialcasing-3
-func = fooooooooooooooooooooooooooooooooo + foooooooooooooooooooooooooooooooo
-  [ foooooooooooooooooooooooooooooooo
-  , foooooooooooooooooooooooooooooooo
-  , foooooooooooooooooooooooooooooooo
-  ]
-
-#test opapp-indenting
-parserPrim =
-  [ r
-  | r <-
-    [ SGPPrimFloat $ bool id (0 -) minus $ readGnok "parserPrim"
-                                                    (d1 ++ d2 ++ d3 ++ d4)
-    | d2 <- string "."
-    , d3 <- many1 (oneOf "0123456789")
-    , _  <- string "f"
-    ]
-    <|> [ SGPPrimFloat $ bool id (0 -) minus $ fromIntegral
-            (readGnok "parserPrim" d1 :: Integer)
-        | _ <- string "f"
-        ]
-    <|> [ SGPPrimInt $ bool id (0 -) minus $ fromIntegral
-            (readGnok "parserPrim" d1 :: Integer)
-        | _ <- string "i"
-        ]
-  ]
-
-#test another-parspacing-testcase
-
-samples = (SV.unpackaaaaadat) <&> \f ->
-  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-
-#test recordupd-singleline-bug
-
-runBrittany tabSize text = do
-  let
-    config' = staticDefaultConfig
-    config  = config'
-      { _conf_layout  = (_conf_layout config') { _lconfig_indentAmount = coerce
-                                                 tabSize
-                                               }
-      , _conf_forward = forwardOptionsSyntaxExtsEnabled
-      }
-  parsePrintModule config text
-
-#test issue 38
-
-{-# LANGUAGE TypeApplications #-}
-foo = bar @Baz
-
-#test comment-before-BDCols
-{-# LANGUAGE TypeApplications #-}
-layoutPatternBindFinal alignmentToken binderDoc mPatDoc clauseDocs = do
-  docAlt
-    $  -- one-line solution
-       [ docCols
-           (ColBindingLine alignmentToken)
-           [ docSeq (patPartInline ++ [guardPart])
-           , docSeq
-             [ appSep $ return binderDoc
-             , docForceSingleline $ return body
-             , wherePart
-             ]
-           ]
-       | not hasComments
-       , [(guards, body, _bodyRaw)] <- [clauseDocs]
-       , let guardPart = singleLineGuardsDoc guards
-       , wherePart <- case mWhereDocs of
-         Nothing  -> return @[] $ docEmpty
-         Just [w] -> return @[] $ docSeq
-           [ docSeparator
-           , appSep $ docLit $ Text.pack "where"
-           , docSetIndentLevel $ docForceSingleline $ return w
-           ]
-         _ -> []
-       ]
-    ++ -- one-line solution + where in next line(s)
-       [ docLines
-         $  [ docCols
-                (ColBindingLine alignmentToken)
-                [ docSeq (patPartInline ++ [guardPart])
-                , docSeq
-                  [appSep $ return binderDoc, docForceParSpacing $ return body]
-                ]
-            ]
-         ++ wherePartMultiLine
-       | [(guards, body, _bodyRaw)] <- [clauseDocs]
-       , let guardPart = singleLineGuardsDoc guards
-       , Data.Maybe.isJust mWhereDocs
-       ]
-    ++ -- two-line solution + where in next line(s)
-       [ docLines
-         $  [ docForceSingleline
-              $ docSeq (patPartInline ++ [guardPart, return binderDoc])
-            , docEnsureIndent BrIndentRegular $ docForceSingleline $ return
-              body
-            ]
-         ++ wherePartMultiLine
-       | [(guards, body, _bodyRaw)] <- [clauseDocs]
-       , let guardPart = singleLineGuardsDoc guards
-       ]
-
-#test comment-testcase-17
-{-# LANGUAGE MultiWayIf #-}
-func = do
-  let foo = if
-        | Constuctoooooooooooooooooooooooooooooooooooor `elem` artics -- TODO
-                                                                      -> max
-          (defLen - 0.2) -- TODO
-          (defLen * 0.8)
-        | otherwise -> max (defLen - 0.05) (defLen * 0.95) -- TODO
-  return True
-
-#test issue 49
-
-foo n = case n of
-  1  -> True
-  -1 -> False
-
-bar n = case n of
-  (-2, -2) -> (-2, -2)
-
-#test issue 48 a
-
-foo =
-  let a    = b@1
-      cccc = ()
-  in  foo
-
-#test issue 48 b
-
-{-# LANGUAGE TypeApplications #-}
-foo =
-  let a    = b @1
-      cccc = ()
-  in  foo
-
-#test issue 52 a
-
-{-# LANGUAGE RecordWildCards #-}
-v = A {a = 1, ..} where b = 2
-
-#test issue 52 b
-
-{-# LANGUAGE RecordWildCards #-}
-v = A {..} where b = 2
-
-#test issue 52 c
-
-{-# LANGUAGE RecordWildCards #-}
-v = A {a = 1, b = 2, c = 3}
-
-#test issue 63 a
-#pending fix does not work on 8.0.2
-test :: Proxy 'Int
-
-#test issue 63 b
-#pending fix does not work on 8.0.2
-test :: Proxy '[ 'True]
-
-#test issue 63 c
-#pending fix does not work on 8.0.2
-test :: Proxy '[Bool]
-
-#test issue 64
-{-# LANGUAGE RankNTypes, KindSignatures #-}
-func
-  :: forall m str
-   . (Str str, Monad m)
-  => Int
-  -> Proxy (str :: [*])
-  -> m (Tagged str String)
-
-#test issue 67
-fmapuv :: U.Unbox a => (a -> b) -> U.Vector a -> V.Vector b
-fmapuv f xs = G.generate (G.length xs) (f . (xs G.!))
-
-
-#test parallellistcomp-workaround
-cs0 = 0 : [ c / Interval n | c <- cs | n <- [1..] ]
diff --git a/src-literatetests/16-pending.blt b/src-literatetests/16-pending.blt
deleted file mode 100644
index c8147d8..0000000
--- a/src-literatetests/16-pending.blt
+++ /dev/null
@@ -1,35 +0,0 @@
-###############################################################################
-###############################################################################
-###############################################################################
-#group pending
-###############################################################################
-###############################################################################
-###############################################################################
-
-
-
-## this testcase is not about idempotency, but about _how_ the output differs
-## from the input; i cannot really express this yet with the current
-## test-suite.
-## #test ayaz
-## 
-## myManageHook =
-##   composeOne [isFullscreen -?> doFullFloat, isDialog -?> doFloat, transience]
-##     <+> composeAll
-##           [ className =? "Pidgin" --> doFloat
-##           , className =? "XCalc" --> doFloat
-##           -- plan9port's acme
-##           , className =? "acme" --> doFloat
-##           -- Acme with Vi bindings editor
-##           , title =? "ED" --> doFloat
-##           , title =? "wlc-x11" --> doFloat
-##           , className =? "Skype" --> doFloat
-##           , className =? "ffplay" --> doFloat
-##           , className =? "mpv" --> doFloat
-##           , className =? "Plugin-container" --> doFloat -- Firefox flash, etc.
-##           -- Firefox works well tiled, but it has dialog windows we want to float.
-##           , appName =? "Browser" --> doFloat
-##           ]
-##  where
-##   role = stringProperty "WM_WINDOW_ROLE"
-
diff --git a/src-literatetests/Main.hs b/src-literatetests/Main.hs
index 34b4e4e..fe966e6 100644
--- a/src-literatetests/Main.hs
+++ b/src-literatetests/Main.hs
@@ -24,7 +24,6 @@ import Language.Haskell.Brittany.Internal.Config
 import Data.Coerce ( coerce )
 
 import qualified Data.Text.IO as Text.IO
-import           System.FilePath ( (</>) )
 
 
 
@@ -39,10 +38,8 @@ data InputLine
 
 main :: IO ()
 main = do
-  files <- System.Directory.listDirectory "src-literatetests/"
-  let blts = List.sort $ filter (".blt" `isSuffixOf`) files
-  inputs <- blts `forM` \blt -> Text.IO.readFile ("src-literatetests" </> blt)
-  let groups = createChunks =<< inputs
+  input <- Text.IO.readFile "src-literatetests/tests.blt"
+  let groups = createChunks input
   hspec $ groups `forM_` \(groupname, tests) -> do
     describe (Text.unpack groupname) $ tests `forM_` \(name, pend, inp) -> do
       (if pend then before_ pending else id)
diff --git a/src-literatetests/tests.blt b/src-literatetests/tests.blt
new file mode 100644
index 0000000..b87a418
--- /dev/null
+++ b/src-literatetests/tests.blt
@@ -0,0 +1,1097 @@
+
+###############################################################################
+###############################################################################
+###############################################################################
+#group type signatures
+###############################################################################
+###############################################################################
+###############################################################################
+
+#test simple001
+func :: a -> a
+
+#test long typeVar
+func
+  :: lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+  -> lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+
+#test keep linebreak mode
+func
+  :: lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+  -> lakjsdlkjasldkj
+  -> lakjsdlkjasldkj
+
+#test simple parens 1
+func :: ((a))
+
+#test simple parens 2
+func :: (a -> a) -> a
+
+#test simple parens 3
+func :: a -> (a -> a)
+
+#test did anyone say parentheses?
+func :: (((((((((())))))))))
+
+-- current output is.. funny. wonder if that can/needs to be improved..
+#test give me more!
+#pending
+func :: ((((((((((((((((((((((((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))))
+
+#test unit
+func :: ()
+
+
+###############################################################################
+
+#test paren'd func 1
+func
+  :: (  lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+     -> lakjsdlkjasldkj
+     -> lakjsdlkjasldkj
+     )
+
+#test paren'd func 2
+func
+  :: lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+  -> (lakjsdlkjasldkj -> lakjsdlkjasldkj)
+
+#test paren'd func 3
+func
+  :: (lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd -> lakjsdlkjasldkj)
+  -> lakjsdlkjasldkj
+
+#test paren'd func 4
+func
+  :: (  lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+     -> lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+     )
+  -> lakjsdlkjasldkj
+
+#test paren'd func 5
+func
+  :: ( (  lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       -> lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       )
+     )
+
+###############################################################################
+
+#test type application 1
+func :: asd -> Either a b
+
+#test type application 2
+func
+  :: asd
+  -> Either
+       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+
+#test type application 3
+func
+  :: asd
+  -> Trither
+       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+
+#test type application 4
+func
+  :: Trither
+       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+  -> asd
+
+#test type application 5
+func
+  :: Trither
+       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       (lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd -> asd)
+
+#test type application 6
+func
+  :: Trither
+       asd
+       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       (  lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       -> lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       )
+
+#test type application paren 1
+func
+  :: asd
+  -> ( Trither
+         lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+         lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+         lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+     )
+
+#test type application paren 2
+func
+  :: asd
+  -> ( Trither
+         lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+         lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+     )
+       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+
+#test type application paren 3
+func
+  :: ( Trither
+         lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+         lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+     )
+       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+  -> asd
+
+###############################################################################
+
+#test list simple
+func :: [a -> b]
+
+#test list func
+func
+  :: [  lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+     -> lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+     ]
+
+#test list paren
+func
+  :: [ (  lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       -> lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       )
+     ]
+
+################################################################## -- #############
+
+#test tuple type 1
+func :: (a, b, c)
+
+#test tuple type 2
+func :: ((a, b, c), (a, b, c), (a, b, c))
+
+#test tuple type long
+func
+  :: ( lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+     , lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+     , lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+     )
+
+#test tuple type nested
+func
+  :: ( ( lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       , (lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd)
+       , lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       )
+     )
+
+#test tuple type function
+func
+  :: [ ( lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       , lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       , lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       )
+     ]
+###############################################################################
+#test type operator stuff
+#pending
+test050 :: a :+: b
+test051 ::  lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+        :+: lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+test052 ::  lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+        ->  lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+        :+: lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+        ->  lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+
+###############################################################################
+
+#test forall oneliner
+{-# LANGUAGE ScopedTypeVariables #-}
+func :: forall (a :: *) b . a -> b
+
+#test forall context multiline
+{-# LANGUAGE ScopedTypeVariables #-}
+func
+  :: forall m
+   . Foo
+  => ColMap2
+  -> ColInfo
+  -> ColInfo
+  -> ColInfo
+  -> ColInfo
+  -> m ()
+
+#test forall no-context multiline
+{-# LANGUAGE ScopedTypeVariables #-}
+func
+  :: forall m
+  .  ColMap2
+  -> ColInfo
+  -> ColInfo
+  -> ColInfo
+  -> ColInfo
+  -> ColInfo
+  -> m ()
+
+#test language pragma issue
+{-# LANGUAGE ScopedTypeVariables #-}
+func :: forall (a :: *) b . a -> b
+
+#test comments 1
+func :: a -> b -- comment
+
+#test comments 2
+funcA :: a -> b -- comment A
+funcB :: a -> b -- comment B
+
+#test comments all
+#pending
+-- a
+func -- b
+  :: -- c
+  a -- d
+  -> -- e
+  ( -- f
+  c -- g
+  , -- h
+  d -- i
+  ) -- j
+-- k
+
+###############################################################################
+
+#test ImplicitParams 1
+{-# LANGUAGE ImplicitParams #-}
+func :: (?asd::Int) -> ()
+
+#test ImplicitParams 2
+{-# LANGUAGE ImplicitParams #-}
+func
+  :: (  ?asd
+     :: lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+     -> lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+     )
+  -> ()
+
+
+###############################################################################
+###############################################################################
+###############################################################################
+#group type signatures pragmas
+###############################################################################
+###############################################################################
+###############################################################################
+
+#test inline pragma 1
+func = f
+ where
+  {-# INLINE f #-}
+  f = id
+
+#test inline pragma 2
+func = ($)
+ where
+  {-# INLINE ($) #-}
+  ($) = id
+
+#test inline pragma 3
+func = f
+ where
+  {-# INLINE CONLIKE [1] f #-}
+  f = id
+
+#test inline pragma 4
+#pending this does not work with the compiler version we currently use yet (i think). should work with ghc-8.0.2.
+func = f
+ where
+  {-# INLINE [~] f #-}
+  f = id
+
+
+###############################################################################
+###############################################################################
+###############################################################################
+#group equation.basic
+###############################################################################
+###############################################################################
+###############################################################################
+## some basic testing of different kinds of equations.
+## some focus on column layouting for multiple-equation definitions.
+## (that part probably is not implemented in any way yet.)
+
+#test basic 1
+func x = x
+
+#test infix 1
+x *** y = x
+
+#test symbol prefix
+(***) x y = x
+
+
+###############################################################################
+###############################################################################
+###############################################################################
+#group equation.patterns
+###############################################################################
+###############################################################################
+###############################################################################
+
+#test wildcard
+func _ = x
+
+#test simple long pattern
+#pending
+func reallyreallyreallyreallyreallyreallyreallyreallyreallyreallylongvariable
+  = x
+
+#test simple multiline pattern
+#pending
+func reallyreallyreallyreallyreallyreallyreallyreallyreallyreallylongvariable
+     reallyreallyreallyreallyreallyreallyreallyreallyreallyreallylongvariable
+  = x
+
+#test another multiline pattern
+#pending
+func reallyreallyreallyreallyreallyreallyreallyreallyreallyreallylongvariable
+     a
+     b
+  = x
+
+#test simple constructor
+func (A a) = a
+
+#test list constructor
+func (x:xr) = x
+
+#test some other constructor symbol
+#pending
+func (x:+:xr) = x
+
+
+###############################################################################
+###############################################################################
+###############################################################################
+#group equation.guards
+###############################################################################
+###############################################################################
+###############################################################################
+#test simple guard
+func | True = x
+
+#test multiple-clauses-1
+func x | x         = simple expression
+       | otherwise = 0
+
+#test multiple-clauses-2
+func x
+  | a somewhat longer guard x = "and a somewhat longer expession that does not"
+  | otherwise                 = "fit without putting the guards in new lines"
+
+#test multiple-clauses-3
+func x
+  | very long guard, another rather long guard that refers to x = nontrivial
+    expression
+    foo
+    bar
+    alsdkjlasdjlasj
+  | otherwise = 0
+
+#test multiple-clauses-4
+func x
+  | very long guard, another rather long guard that refers to x
+  = nontrivialexpression foo bar alsdkjlasdjlasj
+  | otherwise
+  = 0
+
+#test multiple-clauses-5
+func x
+  | very loooooooooooooooooooooooooooooong guard
+  , another rather long guard that refers to x
+  = nontrivial expression foo bar alsdkjlasdjlasj
+  | otherwise
+  = 0
+
+
+###############################################################################
+###############################################################################
+###############################################################################
+#group expression.basic
+###############################################################################
+###############################################################################
+###############################################################################
+
+#test var
+func = x
+
+describe "infix op" $ do
+#test 1
+func = x + x
+
+#test long
+#pending
+func = mweroiuxlskdfjlksjdflkjsdfljksldkjflkjsdflkj
+     + mweroiuxlskdfjlksjdflkjsdfljksldkjflkjsdflkj
+
+#test long keep linemode 1
+#pending
+func = mweroiuxlskdfjlksjdflkjsdfljksldkjflkjsdflkj
+     + mweroiuxlskdfjlksj
+     + mweroiuxlskdfjlksj
+
+#test long keep linemode 2
+#pending
+func = mweroiuxlskdfjlksj
+     + mweroiuxlskdfjlksj
+     + mweroiuxlskdfjlksjdflkjsdfljksldkjflkjsdflkj
+
+#test literals
+func = 1
+func = "abc"
+func = 1.1e5
+func = 'x'
+func = 981409823458910394810928414192837123987123987123
+
+#test lambdacase
+{-# LANGUAGE LambdaCase #-}
+func = \case
+  FooBar -> x
+  Baz    -> y
+
+#test lambda
+func = \x -> abc
+
+describe "app" $ do
+#test 1
+func = klajsdas klajsdas klajsdas
+
+#test 2
+func = lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd
+  lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd
+  lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd
+
+#test 3
+func = lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd lakjsdlajsdljas
+                                                     lakjsdlajsdljas
+                                                     lakjsdlajsdljas
+
+###
+#group expression.basic.sections
+###
+
+#test left
+func = (1+)
+
+#test right
+func = (+1)
+
+#test left inf
+## TODO: this could be improved..
+func = (1`abc`)
+
+#test right inf
+func = (`abc`1)
+
+###
+#group tuples
+###
+
+#test 1
+func = (abc, def)
+
+#test 2
+#pending
+func = (lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd
+  , lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd)
+
+
+
+###############################################################################
+###############################################################################
+###############################################################################
+#group expression.do statements
+###############################################################################
+###############################################################################
+###############################################################################
+
+#test simple
+func = do
+  stmt
+  stmt
+
+#test bind
+func = do
+  x <- stmt
+  stmt x
+
+#test let
+func = do
+  let x = 13
+  stmt x
+
+
+###############################################################################
+###############################################################################
+###############################################################################
+#group expression.lists
+###############################################################################
+###############################################################################
+###############################################################################
+
+#test monad-comprehension-case-of
+func =
+  foooooo
+    $ [ case
+          foooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
+        of
+          _ -> True
+      ]
+
+
+###############################################################################
+###############################################################################
+###############################################################################
+#group expression.multiwayif
+###############################################################################
+###############################################################################
+###############################################################################
+
+#test simple
+{-# LANGUAGE MultiWayIf #-}
+func = if
+  | cond1 -> loooooooooooooooooooooooooooooong expr1
+  | cond2 -> loooooooooooooooooooooooooooooong expr2
+
+#test simplenested
+{-# LANGUAGE MultiWayIf #-}
+func = do
+  foo
+  bar $ if
+    | cond1 -> loooooooooooooooooooooooooooooong expr1
+    | cond2 -> loooooooooooooooooooooooooooooong expr2
+
+
+###############################################################################
+###############################################################################
+###############################################################################
+#group stylisticspecialcases
+###############################################################################
+###############################################################################
+###############################################################################
+
+#test operatorprefixalignment-even-with-multiline-alignbreak
+func =
+  foo
+    $  [ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+       , bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
+       ]
+    ++ [ccccccccccccccccccccccccccccccccccccccccccccccccccccccccc]
+
+
+###############################################################################
+###############################################################################
+###############################################################################
+#group template haskell
+###############################################################################
+###############################################################################
+###############################################################################
+
+#test top level splice
+{-# LANGUAGE TemplateHaskell #-}
+deriveFromJSON (unPrefix "assignPost") ''AssignmentPost
+
+#test top level splice wrapped
+{-# LANGUAGE TemplateHaskell #-}
+$(deriveFromJSON (unPrefix "assignPost") ''AssignmentPost)
+
+
+###############################################################################
+###############################################################################
+###############################################################################
+#group regression
+###############################################################################
+###############################################################################
+###############################################################################
+
+#test newlines-comment
+func = do
+  abc <- foo
+
+--abc
+return ()
+
+#test parenthesis-around-unit
+func = (())
+
+#test let-defs indentation
+func = do
+  let foo True = True
+      foo _    = False
+  return ()
+
+#test record update indentation 1
+func = do
+  s <- mGet
+  mSet $ s { _lstate_indent = _lstate_indent state }
+
+#test record update indentation 2
+func = do
+  s <- mGet
+  mSet $ s { _lstate_indent = _lstate_indent state
+           , _lstate_indent = _lstate_indent state
+           }
+
+#test record update indentation 3
+func = do
+  s <- mGet
+  mSet $ s
+    { _lstate_indent = _lstate_indent lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+    , _lstate_indent = _lstate_indent lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+    }
+
+#test post-indent comment
+func = do
+-- abc
+  -- def
+  return ()
+
+#test post-unindent comment
+func = do
+  do
+    return ()
+    -- abc
+  -- def
+  return ()
+
+#test CPP empty comment case
+#pending CPP parsing needs fixing for roundTripEqual
+{-# LANGUAGE CPP #-}
+module Test where
+func = do
+#if FOO
+  let x = 13
+#endif
+  stmt x
+
+## really, the following should be handled by forcing the Alt to multiline
+## because there are comments. as long as this is not implemented though,
+## we should ensure the trivial solution works.
+#test comment inline placement (temporary)
+func
+  :: Int -- basic indentation amount
+  -> Int -- currently used width in current line (after indent)
+         -- used to accurately calc placing of the current-line
+  -> LayoutDesc
+  -> Int
+
+#test some indentation thingy
+func =
+  ( lkjadljasldjalskdjaldjalsdjkalsdjlaksdjlasjdlajsaldskj
+  $ abc
+  $ def
+  $ ghi
+  $ jkl
+  )
+
+#test parenthesized operator
+buildG bounds0 edges0 = accumArray (flip (:)) [] bounds0 (map reassoc edges0)
+  where reassoc (v, e, w) = (v, (e, w))
+
+#test record pattern matching stuff
+downloadRepoPackage = case repo of
+  RepoLocal {..}    -> return ()
+  RepoLocal { abc } -> return ()
+  RepoLocal{}       -> return ()
+
+#test do let comment indentation level problem
+func = do
+  let (primaryPkg, otherPkgs) = selectPrimaryLocalPackage pwd pkgs'
+      (bproblems, x) = resolveBuildTargets primaryPkg otherPkgs utargets''
+      -- default local dir target if there's no given target
+      utargets'' = "foo"
+  return ()
+
+#test list comprehension comment placement
+func =
+  [ (thing, take 10 alts) --TODO: select best ones
+  | (thing, _got, alts@(_:_)) <- nosuchFooThing
+  , gast                      <- award
+  ]
+
+#test if-then-else comment placement
+func = if x
+  then if y -- y is important
+    then foo
+    else bar
+  else Nothing
+
+#test qualified infix pattern
+#pending "TODO"
+wrapPatPrepend pat prepElem = do
+  patDocs <- layoutPat pat
+  case Seq.viewl patDocs of
+    Seq.EmptyL -> return $ Seq.empty
+    x1 Seq.:< xR -> do
+      x1' <- docSeq [prepElem, return x1]
+      return $ x1' Seq.<| xR
+
+#test type signature multiline forcing issue
+layoutWriteNewlineBlock
+  :: ( MonadMultiWriter Text.Builder.Builder m
+     , MonadMultiState LayoutState m
+     , MonadMultiWriter (Seq String) m
+     )
+  => m ()
+
+#test multiwayif proper indentation
+{-# LANGUAGE MultiWayIf #-}
+readMergePersConfig path shouldCreate conf = do
+  exists <- liftIO $ System.Directory.doesFileExist path
+  if
+    | exists -> do
+      contents <- liftIO $ ByteString.readFile path -- no lazy IO, tyvm.
+      fileConf <- case Data.Yaml.decodeEither contents of
+        Left e -> do
+          liftIO
+            $  putStrErrLn
+            $  "error reading in brittany config from "
+            ++ path
+            ++ ":"
+          liftIO $ putStrErrLn e
+          mzero
+        Right x -> return x
+      return $ fileConf Semigroup.<> conf
+    | shouldCreate -> do
+      liftIO $ ByteString.writeFile path $ Data.Yaml.encode $ cMap
+        (Option . Just . runIdentity)
+        staticDefaultConfig
+      return $ conf
+    | otherwise -> do
+      return conf
+
+#test nested pattern alignment issue"
+func = BuildReport
+ where
+  convertInstallOutcome = case result of
+    Left  BR.PlanningFailed      -> PlanningFailed
+    Left  (BR.DependentFailed p) -> DependencyFailed p
+    Left  (BR.DownloadFailed  _) -> DownloadFailed
+    Left  (BR.UnpackFailed    _) -> UnpackFailed
+    Left  (BR.ConfigureFailed _) -> ConfigureFailed
+    Left  (BR.BuildFailed     _) -> BuildFailed
+    Left  (BR.TestsFailed     _) -> TestsFailed
+    Left  (BR.InstallFailed   _) -> InstallFailed
+    Right (BR.BuildOk _ _ _    ) -> InstallOk
+
+#test nested pattern alignment issue"
+func = BuildReport
+ where
+  convertInstallOutcome = case result of
+    Left  BR.PlanningFailed      -> PlanningFailed
+    Left  (BR.DependentFailed p) -> DependencyFailed p
+    Left  (BR.DownloadFailed  _) -> DownloadFailed
+    Left  (BR.UnpackFailed    _) -> UnpackFailed
+    Left  (BR.ConfigureFailed _) -> ConfigureFailed
+    Left  (BR.BuildFailed     _) -> BuildFailed
+    Left  (BR.TestsFailed     _) -> TestsFailed
+    Left  (BR.InstallFailed   _) -> InstallFailed
+    Right (BR.BuildOk _ _ _    ) -> InstallOk
+
+#test partially overflowing alignment issue"
+showPackageDetailedInfo pkginfo =
+  renderStyle (style { lineLength = 80, ribbonsPerLine = 1 })
+    $   char '*'
+    $+$ something
+          [ entry "Synopsis" synopsis hideIfNull reflowParagraphs
+          , entry "Versions available"
+                  sourceVersions
+                  (altText null "[ Not available from server ]")
+                  (dispTopVersions 9 (preferredVersions pkginfo))
+          , entry
+            "Versions installed"
+            installedVersions
+            ( altText
+              null
+              (if hasLib pkginfo then "[ Not installed ]" else "[ Unknown ]")
+            )
+            (dispTopVersions 4 (preferredVersions pkginfo))
+          , entry "Homepage"      homepage     orNotSpecified  text
+          , entry "Bug reports"   bugReports   orNotSpecified  text
+          , entry "Description"   description  hideIfNull      reflowParagraphs
+          , entry "Category"      category     hideIfNull      text
+          , entry "License"       license      alwaysShow      disp
+          , entry "Author"        author       hideIfNull      reflowLines
+          , entry "Maintainer"    maintainer   hideIfNull      reflowLines
+          , entry "Source repo"   sourceRepo   orNotSpecified  text
+          , entry "Executables"   executables  hideIfNull      (commaSep text)
+          , entry "Flags" flags hideIfNull (commaSep dispFlag)
+          , entry "Dependencies" dependencies hideIfNull (commaSep dispExtDep)
+          , entry "Documentation" haddockHtml  showIfInstalled text
+          , entry "Cached"        haveTarball  alwaysShow      dispYesNo
+          , if not (hasLib pkginfo)
+            then empty
+            else text "Modules:"
+              $+$ nest 4 (vcat (map disp . sort . modules $ pkginfo))
+          ]
+
+#test issue 7a
+isValidPosition position | validX && validY = Just position
+                         | otherwise        = Nothing
+
+#test issue-6-pattern-linebreak-validity
+## this is ugly, but at least syntactically valid.
+foo = Reflex.runSpiderHost $ ReflexHost.hostApp $ do
+  (inputEvent :: Reflex.Event Reflex.Spider String, inputFire :: String
+    -> IO Bool                                                         ) <-
+    ReflexHost.newExternalEvent
+  liftIO . forkIO . forever $ getLine >>= inputFire
+  ReflexHost.performEvent_ $ fmap (liftIO . putStrLn) inputEvent
+
+#test issue 16
+foldrDesc f z = unSwitchQueue $ \q ->
+  switch (Min.foldrDesc (f unTaggedF) z q) (Min.foldrAsc (f unTaggedF) z q)
+
+#test issue 18
+autocheckCases =
+  [ ("Never Deadlocks"  , representative deadlocksNever)
+  , ("No Exceptions"    , representative exceptionsNever)
+  , ("Consistent Result", alwaysSame) -- already representative
+  ]
+
+#test issue 18b
+autocheckCases =
+  [ ("Never Deadlocks", representative deadlocksNever)
+  , ("No Exceptions"  , representative exceptionsNever)
+  , ( "Consistent Result"
+    , alwaysSame -- already representative
+    )
+  ]
+
+#test issue 18c
+func =
+  [ (abc, (1111, 1111))
+  , (def, (2, 2))
+  , foo -- comment
+  ]
+
+#test issue 26
+foo a b = g a b -- fooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
+  where g a b = b + b * a
+
+#test issue 26b
+foo a b = g a b where g a b = b + b * a -- fooooooooooooooooooooooooooooooooooo
+
+#test aggressive alignment 1
+func = do
+  abc                  <- expr
+  abcccccccccccccccccc <- expr
+  abcccccccccccccccccccccccccccccccccccccccccc <- expr
+  abccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc <- expr
+
+#test example alignment 1
+func (MyLongFoo abc def) = 1
+func (Bar       a   d  ) = 2
+func _                   = 3
+
+#test listcomprehension-case-of
+parserCompactLocation =
+  [ try
+      $ [ ParseRelAbs (Text.Read.read digits) _ _
+        | digits <- many1 digit
+        , rel1 :: Maybe (Either Int (Ratio Int)) <- optionMaybe
+          [ case divPart of
+              Nothing -> Left $ Text.Read.read digits
+              Just ddigits ->
+                Right $ Text.Read.read digits % Text.Read.read ddigits
+          | digits  <- many1 digit
+          , divPart <- optionMaybe (string "/" *> many1 digit)
+          ]
+        ]
+  ]
+
+#test opapp-specialcasing-1
+func = fooooooooooooooooooooooooooooooooo $ foooooooooooooooooooooooooooooooo
+  foooooooooooooooooooooooooooooooo
+  foooooooooooooooooooooooooooooooo
+
+#test opapp-specialcasing-2
+func =
+  fooooooooooooooooooooooooooooooooo
+    + foooooooooooooooooooooooooooooooo foooooooooooooooooooooooooooooooo
+                                        foooooooooooooooooooooooooooooooo
+
+#test opapp-specialcasing-3
+func = fooooooooooooooooooooooooooooooooo + foooooooooooooooooooooooooooooooo
+  [ foooooooooooooooooooooooooooooooo
+  , foooooooooooooooooooooooooooooooo
+  , foooooooooooooooooooooooooooooooo
+  ]
+
+#test opapp-indenting
+parserPrim =
+  [ r
+  | r <-
+    [ SGPPrimFloat $ bool id (0-) minus $ readGnok "parserPrim"
+                                                   (d1 ++ d2 ++ d3 ++ d4)
+    | d2 <- string "."
+    , d3 <- many1 (oneOf "0123456789")
+    , _  <- string "f"
+    ]
+    <|> [ SGPPrimFloat $ bool id (0-) minus $ fromIntegral
+            (readGnok "parserPrim" d1 :: Integer)
+        | _ <- string "f"
+        ]
+    <|> [ SGPPrimInt $ bool id (0-) minus $ fromIntegral
+            (readGnok "parserPrim" d1 :: Integer)
+        | _ <- string "i"
+        ]
+  ]
+
+#test another-parspacing-testcase
+
+samples = (SV.unpackaaaaadat) <&> \f ->
+  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+
+#test recordupd-singleline-bug
+
+runBrittany tabSize text = do
+  let
+    config' = staticDefaultConfig
+    config  = config'
+      { _conf_layout  = (_conf_layout config') { _lconfig_indentAmount = coerce
+                                                 tabSize
+                                               }
+      , _conf_forward = forwardOptionsSyntaxExtsEnabled
+      }
+  parsePrintModule config text
+
+#test issue 38
+
+{-# LANGUAGE TypeApplications #-}
+foo = bar @Baz
+
+#test comment-before-BDCols
+{-# LANGUAGE TypeApplications #-}
+layoutPatternBindFinal alignmentToken binderDoc mPatDoc clauseDocs = do
+  docAlt
+    $  -- one-line solution
+       [ docCols
+           (ColBindingLine alignmentToken)
+           [ docSeq (patPartInline ++ [guardPart])
+           , docSeq
+             [ appSep $ return binderDoc
+             , docForceSingleline $ return body
+             , wherePart
+             ]
+           ]
+       | not hasComments
+       , [(guards, body, _bodyRaw)] <- [clauseDocs]
+       , let guardPart = singleLineGuardsDoc guards
+       , wherePart <- case mWhereDocs of
+         Nothing  -> return @[] $ docEmpty
+         Just [w] -> return @[] $ docSeq
+           [ docSeparator
+           , appSep $ docLit $ Text.pack "where"
+           , docSetIndentLevel $ docForceSingleline $ return w
+           ]
+         _ -> []
+       ]
+    ++ -- one-line solution + where in next line(s)
+       [ docLines
+         $  [ docCols
+                (ColBindingLine alignmentToken)
+                [ docSeq (patPartInline ++ [guardPart])
+                , docSeq
+                  [appSep $ return binderDoc, docForceParSpacing $ return body]
+                ]
+            ]
+         ++ wherePartMultiLine
+       | [(guards, body, _bodyRaw)] <- [clauseDocs]
+       , let guardPart = singleLineGuardsDoc guards
+       , Data.Maybe.isJust mWhereDocs
+       ]
+    ++ -- two-line solution + where in next line(s)
+       [ docLines
+         $  [ docForceSingleline
+              $ docSeq (patPartInline ++ [guardPart, return binderDoc])
+            , docEnsureIndent BrIndentRegular $ docForceSingleline $ return
+              body
+            ]
+         ++ wherePartMultiLine
+       | [(guards, body, _bodyRaw)] <- [clauseDocs]
+       , let guardPart = singleLineGuardsDoc guards
+       ]
+
+#test comment-testcase-17
+{-# LANGUAGE MultiWayIf #-}
+func = do
+  let foo = if
+        | Constuctoooooooooooooooooooooooooooooooooooor `elem` artics -- TODO
+                                                                      -> max
+          (defLen - 0.2) -- TODO
+          (defLen * 0.8)
+        | otherwise -> max (defLen - 0.05) (defLen * 0.95) -- TODO
+  return True
+
+#test issue 49
+
+foo n = case n of
+  1  -> True
+  -1 -> False
+
+bar n = case n of
+  (-2, -2) -> (-2, -2)
+
+#test issue 48 a
+
+foo =
+  let a    = b@1
+      cccc = ()
+  in  foo
+
+#test issue 48 b
+
+{-# LANGUAGE TypeApplications #-}
+foo =
+  let a    = b @1
+      cccc = ()
+  in  foo
+
+
+###############################################################################
+###############################################################################
+###############################################################################
+#group pending
+###############################################################################
+###############################################################################
+###############################################################################
+
+
+
+## this testcase is not about idempotency, but about _how_ the output differs
+## from the input; i cannot really express this yet with the current
+## test-suite.
+## #test ayaz
+##
+## myManageHook =
+##   composeOne [isFullscreen -?> doFullFloat, isDialog -?> doFloat, transience]
+##     <+> composeAll
+##           [ className =? "Pidgin" --> doFloat
+##           , className =? "XCalc" --> doFloat
+##           -- plan9port's acme
+##           , className =? "acme" --> doFloat
+##           -- Acme with Vi bindings editor
+##           , title =? "ED" --> doFloat
+##           , title =? "wlc-x11" --> doFloat
+##           , className =? "Skype" --> doFloat
+##           , className =? "ffplay" --> doFloat
+##           , className =? "mpv" --> doFloat
+##           , className =? "Plugin-container" --> doFloat -- Firefox flash, etc.
+##           -- Firefox works well tiled, but it has dialog windows we want to float.
+##           , appName =? "Browser" --> doFloat
+##           ]
+##  where
+##   role = stringProperty "WM_WINDOW_ROLE"
+
diff --git a/src/Language/Haskell/Brittany/Internal.hs b/src/Language/Haskell/Brittany/Internal.hs
index 64c139a..4c4bbf0 100644
--- a/src/Language/Haskell/Brittany/Internal.hs
+++ b/src/Language/Haskell/Brittany/Internal.hs
@@ -20,7 +20,7 @@ import qualified Language.Haskell.GHC.ExactPrint.Types as ExactPrint.Types
 import qualified Language.Haskell.GHC.ExactPrint.Parsers as ExactPrint.Parsers
 
 import           Data.Data
-import           Control.Monad.Trans.Except
+import           Control.Monad.Trans.Either
 import           Data.HList.HList
 import           Data.CZipWith
 
@@ -62,7 +62,7 @@ import qualified GHC.LanguageExtensions.Type as GHC
 -- Note that this function ignores/resets all config values regarding
 -- debugging, i.e. it will never use `trace`/write to stderr.
 parsePrintModule :: Config -> Text -> IO (Either [BrittanyError] Text)
-parsePrintModule configRaw inputText = runExceptT $ do
+parsePrintModule configRaw inputText = runEitherT $ do
   let config = configRaw { _conf_debug = _conf_debug staticDefaultConfig }
   let ghcOptions         = config & _conf_forward & _options_ghc & runIdentity
   let config_pp          = config & _conf_preprocessor
@@ -87,7 +87,7 @@ parsePrintModule configRaw inputText = runExceptT $ do
       cppCheckFunc
       (hackTransform $ Text.unpack inputText)
     case parseResult of
-      Left  err -> throwE $ [ErrorInput err]
+      Left  err -> left $ [ErrorInput err]
       Right x   -> pure $ x
   (errsWarns, outputTextL) <- do
     let omitCheck =
@@ -117,7 +117,7 @@ parsePrintModule configRaw inputText = runExceptT $ do
         case config & _conf_errorHandling & _econf_Werror & confUnpack of
           False -> 0 < maximum (-1 : fmap customErrOrder errsWarns)
           True  -> not $ null errsWarns
-  if hasErrors then throwE $ errsWarns else pure $ TextL.toStrict outputTextL
+  if hasErrors then left $ errsWarns else pure $ TextL.toStrict outputTextL
 
 
 
diff --git a/src/Language/Haskell/Brittany/Internal/Config.hs b/src/Language/Haskell/Brittany/Internal/Config.hs
index baaca1f..49651d7 100644
--- a/src/Language/Haskell/Brittany/Internal/Config.hs
+++ b/src/Language/Haskell/Brittany/Internal/Config.hs
@@ -8,8 +8,7 @@ module Language.Haskell.Brittany.Internal.Config
   , configParser
   , staticDefaultConfig
   , forwardOptionsSyntaxExtsEnabled
-  , readConfig
-  , writeDefaultConfig
+  , readMergePersConfig
   , showConfigYaml
   )
 where
@@ -199,37 +198,29 @@ configParser = do
 --   , infoIntersperse = True
 --   }
 
-
--- | Reads a config from a file. If the file does not exist, returns
--- Nothing. If the file exists and parsing fails, prints to stderr and
--- aborts the MaybeT. Otherwise succeed via Just.
--- If the second parameter is True and the file does not exist, writes the
--- staticDefaultConfig to the file.
-readConfig
-  :: MonadIO m => System.IO.FilePath -> MaybeT m (Maybe (CConfig Option))
-readConfig path = do
+readMergePersConfig
+  :: System.IO.FilePath -> Bool -> CConfig Option -> MaybeT IO (CConfig Option)
+readMergePersConfig path shouldCreate conf = do
   exists <- liftIO $ System.Directory.doesFileExist path
-  if exists
-    then do
-      contents <- liftIO $ ByteString.readFile path -- no lazy IO, tyvm.
-      fileConf <- case Data.Yaml.decodeEither contents of
-        Left e -> do
-          liftIO
-            $  putStrErrLn
-            $  "error reading in brittany config from "
-            ++ path
-            ++ ":"
-          liftIO $ putStrErrLn e
-          mzero
-        Right x -> return x
-      return $ Just fileConf
-    else return $ Nothing
-
-writeDefaultConfig :: MonadIO m => System.IO.FilePath -> m ()
-writeDefaultConfig path =
-  liftIO $ ByteString.writeFile path $ Data.Yaml.encode $ cMap
-    (Option . Just . runIdentity)
-    staticDefaultConfig
+  if
+    | exists -> do
+        contents <- liftIO $ ByteString.readFile path -- no lazy IO, tyvm.
+        fileConf <- case Data.Yaml.decodeEither contents of
+          Left e -> do
+            liftIO
+              $ putStrErrLn
+              $ "error reading in brittany config from " ++ path ++ ":"
+            liftIO $ putStrErrLn e
+            mzero
+          Right x -> return x
+        return $ fileConf Semigroup.<> conf
+    | shouldCreate -> do
+        liftIO $ ByteString.writeFile path
+               $ Data.Yaml.encode
+               $ cMap (Option . Just . runIdentity) staticDefaultConfig
+        return $ conf
+    | otherwise -> do
+        return conf
 
 showConfigYaml :: Config -> String
 showConfigYaml = Data.ByteString.Char8.unpack
diff --git a/src/Language/Haskell/Brittany/Internal/ExactPrintUtils.hs b/src/Language/Haskell/Brittany/Internal/ExactPrintUtils.hs
index 74ed50d..faa9526 100644
--- a/src/Language/Haskell/Brittany/Internal/ExactPrintUtils.hs
+++ b/src/Language/Haskell/Brittany/Internal/ExactPrintUtils.hs
@@ -58,24 +58,26 @@ parseModuleWithCpp
   -> (GHC.DynFlags -> IO (Either String a))
   -> IO (Either String (ExactPrint.Anns, GHC.ParsedSource, a))
 parseModuleWithCpp cpp opts args fp dynCheck =
-  ExactPrint.ghcWrapper $ ExceptT.runExceptT $ do
+  ExactPrint.ghcWrapper $ EitherT.runEitherT $ do
     dflags0                       <- lift $ GHC.getSessionDynFlags
-    (dflags1, leftover, warnings) <- lift
-      $ GHC.parseDynamicFlagsCmdLine dflags0 (GHC.noLoc <$> args)
+    (dflags1, leftover, warnings) <- lift $ GHC.parseDynamicFlagsCmdLine
+      dflags0
+      (GHC.noLoc <$> args)
     void $ lift $ GHC.setSessionDynFlags dflags1
-    dflags2 <- lift $ ExactPrint.initDynFlags fp
+    dflags2                       <- lift $ ExactPrint.initDynFlags fp
     when (not $ null leftover)
-      $  ExceptT.throwE
+      $  EitherT.left
       $  "when parsing ghc flags: leftover flags: "
       ++ show (leftover <&> \(L _ s) -> s)
     when (not $ null warnings)
-      $  ExceptT.throwE
+      $  EitherT.left
       $  "when parsing ghc flags: encountered warnings: "
       ++ show (warnings <&> \(L _ s) -> s)
-    x   <- ExceptT.ExceptT $ liftIO $ dynCheck dflags2
+    x <- EitherT.EitherT $ liftIO $ dynCheck dflags2
     res <- lift $ ExactPrint.parseModuleApiAnnsWithCppInternal cpp dflags2 fp
-    either (\(span, err) -> ExceptT.throwE $ show span ++ ": " ++ err)
-           (\(a, m) -> pure (a, m, x))
+    EitherT.hoistEither
+      $ either (\(span, err) -> Left $ show span ++ ": " ++ err)
+               (\(a, m) -> Right (a, m, x))
       $ ExactPrint.postParseTransform res opts
 
 parseModuleFromString
@@ -85,21 +87,22 @@ parseModuleFromString
   -> String
   -> IO (Either String (ExactPrint.Anns, GHC.ParsedSource, a))
 parseModuleFromString args fp dynCheck str =
-  ExactPrint.ghcWrapper $ ExceptT.runExceptT $ do
+  ExactPrint.ghcWrapper $ EitherT.runEitherT $ do
     dflags0                       <- lift $ ExactPrint.initDynFlagsPure fp str
-    (dflags1, leftover, warnings) <- lift
-      $ GHC.parseDynamicFlagsCmdLine dflags0 (GHC.noLoc <$> args)
+    (dflags1, leftover, warnings) <-
+      lift $ GHC.parseDynamicFlagsCmdLine dflags0 (GHC.noLoc <$> args)
     when (not $ null leftover)
-      $  ExceptT.throwE
+      $  EitherT.left
       $  "when parsing ghc flags: leftover flags: "
       ++ show (leftover <&> \(L _ s) -> s)
     when (not $ null warnings)
-      $  ExceptT.throwE
+      $  EitherT.left
       $  "when parsing ghc flags: encountered warnings: "
       ++ show (warnings <&> \(L _ s) -> s)
-    x <- ExceptT.ExceptT $ liftIO $ dynCheck dflags1
-    either (\(span, err) -> ExceptT.throwE $ show span ++ ": " ++ err)
-           (\(a, m) -> pure (a, m, x))
+    x <- EitherT.EitherT $ liftIO $ dynCheck dflags1
+    EitherT.hoistEither
+      $ either (\(span, err) -> Left $ show span ++ ": " ++ err)
+               (\(a, m) -> Right (a, m, x))
       $ ExactPrint.parseWith dflags1 fp GHC.parseModule str
 
 -----------
diff --git a/src/Language/Haskell/Brittany/Internal/LayouterBasics.hs b/src/Language/Haskell/Brittany/Internal/LayouterBasics.hs
index 52c9e08..cffcad7 100644
--- a/src/Language/Haskell/Brittany/Internal/LayouterBasics.hs
+++ b/src/Language/Haskell/Brittany/Internal/LayouterBasics.hs
@@ -42,13 +42,11 @@ module Language.Haskell.Brittany.Internal.LayouterBasics
   , appSep
   , docCommaSep
   , docParenLSep
-  , docTick
   , spacifyDocs
   , briDocMToPPM
   , allocateNode
   , docSharedWrapper
   , hasAnyCommentsBelow
-  , hasAnnKeyword
   )
 where
 
@@ -82,8 +80,6 @@ import           ApiAnnotation ( AnnKeywordId(..) )
 import           Data.Data
 import           Data.Generics.Schemes
 
-import qualified Data.Char as Char
-
 import           DataTreePrint
 
 import           Data.HList.HList
@@ -156,21 +152,20 @@ briDocByExactInlineOnly infoStr ast = do
   let exactPrinted = Text.pack $ ExactPrint.exactPrint ast anns
   fallbackMode <-
     mAsk <&> _conf_errorHandling .> _econf_ExactPrintFallback .> confUnpack
-  let exactPrintNode t = allocateNode $ BDFExternal
+  let exactPrintNode = allocateNode $ BDFExternal
         (ExactPrint.Types.mkAnnKey ast)
         (foldedAnnKeys ast)
         False
-        t
-  let errorAction = do
-        mTell $ [ErrorUnknownNode infoStr ast]
-        docLit
-          $ Text.pack "{- BRITTANY ERROR UNHANDLED SYNTACTICAL CONSTRUCT -}"
+        exactPrinted
+  let
+    errorAction = do
+      mTell $ [ErrorUnknownNode infoStr ast]
+      docLit $ Text.pack "{- BRITTANY ERROR UNHANDLED SYNTACTICAL CONSTRUCT -}"
   case (fallbackMode, Text.lines exactPrinted) of
     (ExactPrintFallbackModeNever, _  ) -> errorAction
-    (_                          , [t]) -> exactPrintNode
-      (Text.dropWhile Char.isSpace . Text.dropWhileEnd Char.isSpace $ t)
-    (ExactPrintFallbackModeRisky, _) -> exactPrintNode exactPrinted
-    _ -> errorAction
+    (_                          , [_]) -> exactPrintNode
+    (ExactPrintFallbackModeRisky, _  ) -> exactPrintNode
+    _                                  -> errorAction
 
 rdrNameToText :: RdrName -> Text
 -- rdrNameToText = Text.pack . show . flip runSDoc unsafeGlobalDynFlags . ppr
@@ -243,19 +238,6 @@ hasAnyCommentsBelow ast@(L l _) = do
     $ Map.elems
     $ anns
 
-hasAnnKeyword
-  :: (Data a, MonadMultiReader (Map AnnKey Annotation) m)
-  => Located a
-  -> AnnKeywordId
-  -> m Bool
-hasAnnKeyword ast annKeyword = do
-  anns <- mAsk
-  let hasK (ExactPrint.Types.G x, _) = x == annKeyword
-      hasK _                         = False
-  pure $ case Map.lookup (ExactPrint.Types.mkAnnKey ast) anns of
-    Nothing -> False
-    Just (ExactPrint.Types.Ann _ _ _ aks _ _) -> any hasK aks
-
 -- new BriDoc stuff
 
 allocateNode
@@ -465,9 +447,6 @@ docCommaSep = appSep $ docLit $ Text.pack ","
 docParenLSep :: ToBriDocM BriDocNumbered
 docParenLSep = appSep $ docLit $ Text.pack "("
 
-docTick :: ToBriDocM BriDocNumbered
-docTick = docLit $ Text.pack "'"
-
 docNodeAnnKW
   :: Data.Data.Data ast
   => Located ast
diff --git a/src/Language/Haskell/Brittany/Internal/Layouters/Expr.hs b/src/Language/Haskell/Brittany/Internal/Layouters/Expr.hs
index 0e36a21..a6ba345 100644
--- a/src/Language/Haskell/Brittany/Internal/Layouters/Expr.hs
+++ b/src/Language/Haskell/Brittany/Internal/Layouters/Expr.hs
@@ -154,32 +154,19 @@ layoutExpr lexpr@(L _ expr) = docWrapNode lexpr $ case expr of
     expDoc1 <- docSharedWrapper layoutExpr exp1
     expDoc2 <- docSharedWrapper layoutExpr exp2
     docAlt
-      [ -- func arg
-        docSeq [appSep $ docForceSingleline expDoc1, docForceSingleline expDoc2]
-      , -- func argline1
-        --   arglines
-        -- e.g.
-        -- func if x
-        --   then 1
-        --   else 2
-        docSetParSpacing
+      [ docSeq [appSep $ docForceSingleline expDoc1, docForceSingleline expDoc2]
+      , docSetParSpacing
       $ docAddBaseY BrIndentRegular
       $ docSeq
         [ appSep $ docForceSingleline expDoc1
         , docForceParSpacing expDoc2
         ]
-      , -- func
-        --   arg
-        docSetParSpacing
+      , docSetParSpacing
       $ docAddBaseY BrIndentRegular
       $ docPar
         (docForceSingleline expDoc1)
-        (docNonBottomSpacing expDoc2)
-      , -- fu
-        --   nc
-        --   ar
-        --     gument
-        docAddBaseY BrIndentRegular
+        expDoc2
+      , docAddBaseY BrIndentRegular
       $ docPar
         expDoc1
         expDoc2
@@ -321,11 +308,11 @@ layoutExpr lexpr@(L _ expr) = docWrapNode lexpr $ case expr of
   SectionL left op -> do -- TODO: add to testsuite
     leftDoc <- docSharedWrapper layoutExpr left
     opDoc   <- docSharedWrapper layoutExpr op
-    docSeq [leftDoc, docSeparator, opDoc]
+    docSeq [leftDoc, opDoc]
   SectionR op right -> do -- TODO: add to testsuite
     opDoc    <- docSharedWrapper layoutExpr op
     rightDoc <- docSharedWrapper layoutExpr right
-    docSeq [opDoc, docSeparator, rightDoc]
+    docSeq [opDoc, rightDoc]
   ExplicitTuple args boxity
     | Just argExprs <- args `forM` (\case (L _ (Present e)) -> Just e; _ -> Nothing) -> do
     argDocs <- docSharedWrapper layoutExpr `mapM` argExprs
@@ -685,103 +672,42 @@ layoutExpr lexpr@(L _ expr) = docWrapNode lexpr $ case expr of
         then return Nothing
         else Just <$> docSharedWrapper layoutExpr fExpr
       return $ (fieldl, lrdrNameToText lnameF, fExpDoc)
-    let line1 appender wrapper =
-          [ appender $ docLit $ Text.pack "{"
-          , docWrapNodePrior fd1l $ appSep $ docLit $ fd1n
-          , case fd1e of
-              Just x -> docSeq
-                [ appSep $ docLit $ Text.pack "="
-                , docWrapNodeRest fd1l $ wrapper $ x
-                ]
-              Nothing -> docEmpty
-          ]
-    let lineR wrapper = fdr <&> \(lfield, fText, fDoc) ->
-          [ docCommaSep
-          , appSep $ docLit $ fText
-          , case fDoc of
-              Just x -> docWrapNode lfield $ docSeq
-                [ appSep $ docLit $ Text.pack "="
-                , wrapper x
-                ]
-              Nothing -> docEmpty
-          ]
-    let lineN =
-          [ docNodeAnnKW lexpr (Just AnnOpenC) docEmpty
-          , docLit $ Text.pack "}"
-          ]
     docAlt
-      [  docSeq
-      $  [docNodeAnnKW lexpr Nothing $ nameDoc, docSeparator]
-      ++ line1 id docForceSingleline
-      ++ join (lineR docForceSingleline)
-      ++ lineN
-      , docSetParSpacing
+      [ docSetParSpacing
       $ docAddBaseY BrIndentRegular
       $ docPar
           (docNodeAnnKW lexpr Nothing $ nameDoc)
-          ( docNonBottomSpacing
-          $ docLines
-          $  [docCols ColRecUpdate $ line1 appSep (docAddBaseY BrIndentRegular)]
-          ++ (docCols ColRecUpdate <$> lineR (docAddBaseY BrIndentRegular))
-          ++ [docSeq lineN]
-          )
+          (docNonBottomSpacing $ docLines $ let
+            line1 = docCols ColRecUpdate
+              [ appSep $ docLit $ Text.pack "{"
+              , docWrapNodePrior fd1l $ appSep $ docLit $ fd1n
+              , case fd1e of
+                  Just x -> docSeq
+                    [ appSep $ docLit $ Text.pack "="
+                    , docWrapNodeRest fd1l $ docAddBaseY BrIndentRegular $ x
+                    ]
+                  Nothing -> docEmpty
+              ]
+            lineR = fdr <&> \(lfield, fText, fDoc) -> docCols ColRecUpdate
+              [ appSep $ docLit $ Text.pack ","
+              , appSep $ docLit $ fText
+              , case fDoc of
+                  Just x -> docWrapNode lfield $ docSeq
+                    [ appSep $ docLit $ Text.pack "="
+                    , docAddBaseY BrIndentRegular x
+                    ]
+                  Nothing -> docEmpty
+              ]
+            lineN = docSeq
+              [ docNodeAnnKW lexpr (Just AnnOpenC) docEmpty
+              , docLit $ Text.pack "}"
+              ]
+            in [line1] ++ lineR ++ [lineN])
+      -- TODO oneliner (?)
       ]
   RecordCon lname _ _ (HsRecFields [] (Just 0)) -> do
     let t = lrdrNameToText lname
     docWrapNode lname $ docLit $ t <> Text.pack " {..}"
-  RecordCon lname _ _ (HsRecFields fs@(_:_) (Just dotdoti)) | dotdoti == length fs -> do
-    let nameDoc = docWrapNode lname $ docLit $ lrdrNameToText lname
-    ((fd1l, fd1n, fd1e):fdr) <- fs `forM` \fieldl@(L _ (HsRecField (L _ (FieldOcc lnameF _)) fExpr pun)) -> do
-      fExpDoc <- if pun
-        then return Nothing
-        else Just <$> docSharedWrapper layoutExpr fExpr
-      return $ (fieldl, lrdrNameToText lnameF, fExpDoc)
-    let line1 appender wrapper =
-          [ appender $ docLit $ Text.pack "{"
-          , docWrapNodePrior fd1l $ appSep $ docLit $ fd1n
-          , case fd1e of
-              Just x -> docSeq
-                [ appSep $ docLit $ Text.pack "="
-                , docWrapNodeRest fd1l $ wrapper $ x
-                ]
-              Nothing -> docEmpty
-          ]
-    let lineR wrapper = fdr <&> \(lfield, fText, fDoc) ->
-          [ docCommaSep
-          , appSep $ docLit $ fText
-          , case fDoc of
-              Just x -> docWrapNode lfield $ docSeq
-                [ appSep $ docLit $ Text.pack "="
-                , wrapper x
-                ]
-              Nothing -> docEmpty
-          ]
-    let lineDot =
-          [ docCommaSep
-          , docLit $ Text.pack ".."
-          ]
-    let lineN =
-          [ docNodeAnnKW lexpr (Just AnnOpenC) docEmpty
-          , docLit $ Text.pack "}"
-          ]
-    docAlt
-      [  docSeq
-      $  [docNodeAnnKW lexpr Nothing $ nameDoc, docSeparator]
-      ++ line1 id docForceSingleline
-      ++ join (lineR docForceSingleline)
-      ++ lineDot
-      ++ lineN
-      , docSetParSpacing
-      $ docAddBaseY BrIndentRegular
-      $ docPar
-          (docNodeAnnKW lexpr Nothing $ nameDoc)
-          ( docNonBottomSpacing
-          $ docLines
-          $  [docCols ColRecUpdate $ line1 appSep (docAddBaseY BrIndentRegular)]
-          ++ (docCols ColRecUpdate <$> lineR (docAddBaseY BrIndentRegular))
-          ++ [docSeq lineDot, docSeq lineN]
-          )
-      ]
   RecordCon{} ->
     unknownNodeError "RecordCon with puns" lexpr
   RecordUpd rExpr [] _ _ _ _ -> do
@@ -829,7 +755,7 @@ layoutExpr lexpr@(L _ expr) = docWrapNode lexpr $ case expr of
                   Nothing -> docEmpty
               ]
             lineR = rFr <&> \(lfield, fText, fDoc) -> docWrapNode lfield $ docCols ColRecUpdate
-              [ docCommaSep
+              [ appSep $ docLit $ Text.pack ","
               , appSep $ docLit $ fText
               , case fDoc of
                   Just x ->  docSeq [ appSep $ docLit $ Text.pack "="
@@ -859,7 +785,7 @@ layoutExpr lexpr@(L _ expr) = docWrapNode lexpr $ case expr of
                   Nothing -> docEmpty
               ]
             lineR = rFr <&> \(lfield, fText, fDoc) -> docWrapNode lfield $ docCols ColRecUpdate
-              [ docCommaSep
+              [ appSep $ docLit $ Text.pack ","
               , appSep $ docLit $ fText
               , case fDoc of
                   Just x ->  docSeq [ appSep $ docLit $ Text.pack "="
@@ -903,7 +829,7 @@ layoutExpr lexpr@(L _ expr) = docWrapNode lexpr $ case expr of
         docSeq
           [ docLit $ Text.pack "["
           , docForceSingleline e1Doc
-          , docCommaSep
+          , appSep $ docLit $ Text.pack ","
           , appSep $ docForceSingleline e2Doc
           , docLit $ Text.pack "..]"
           ]
@@ -924,7 +850,7 @@ layoutExpr lexpr@(L _ expr) = docWrapNode lexpr $ case expr of
         docSeq
           [ docLit $ Text.pack "["
           , docForceSingleline e1Doc
-          , docCommaSep
+          , appSep $ docLit $ Text.pack ","
           , appSep $ docForceSingleline e2Doc
           , appSep $ docLit $ Text.pack ".."
           , docForceSingleline eNDoc
diff --git a/src/Language/Haskell/Brittany/Internal/Layouters/Pattern.hs b/src/Language/Haskell/Brittany/Internal/Layouters/Pattern.hs
index 3f66932..b36fcaa 100644
--- a/src/Language/Haskell/Brittany/Internal/Layouters/Pattern.hs
+++ b/src/Language/Haskell/Brittany/Internal/Layouters/Pattern.hs
@@ -96,26 +96,6 @@ layoutPat lpat@(L _ pat) = docWrapNode lpat $ case pat of
       [ appSep $ docLit t
       , docLit $ Text.pack "{..}"
       ]
-  ConPatIn lname (RecCon (HsRecFields fs@(_:_) (Just dotdoti))) | dotdoti == length fs -> do
-    let t = lrdrNameToText lname
-    fds <- fs `forM` \(L _ (HsRecField (L _ (FieldOcc lnameF _)) fPat pun)) -> do
-      fExpDoc <- if pun
-        then return Nothing
-        else Just <$> docSharedWrapper layoutPat fPat
-      return $ (lrdrNameToText lnameF, fExpDoc)
-    fmap Seq.singleton $ docSeq
-      [ appSep $ docLit t
-      , appSep $ docLit $ Text.pack "{"
-      , docSeq $ fds >>= \case
-          (fieldName, Just fieldDoc) ->
-            [ appSep $ docLit $ fieldName
-            , appSep $ docLit $ Text.pack "="
-            , fieldDoc >>= colsWrapPat
-            , docCommaSep
-            ]
-          (fieldName, Nothing) -> [docLit fieldName, docCommaSep]
-      , docLit $ Text.pack "..}"
-      ]
   TuplePat args boxity _ -> do
     case boxity of
       Boxed   -> wrapPatListy args "(" ")"
diff --git a/src/Language/Haskell/Brittany/Internal/Layouters/Stmt.hs b/src/Language/Haskell/Brittany/Internal/Layouters/Stmt.hs
index a8d95aa..692b467 100644
--- a/src/Language/Haskell/Brittany/Internal/Layouters/Stmt.hs
+++ b/src/Language/Haskell/Brittany/Internal/Layouters/Stmt.hs
@@ -70,12 +70,6 @@ layoutStmt lstmt@(L _ stmt) = docWrapNode lstmt $ case stmt of
         (docLit $ Text.pack "let")
         (docSetBaseAndIndent $ docLines $ return <$> bindDocs)
       ]
-  RecStmt stmts _ _ _ _ _ _ _ _ _ -> do
-    docSeq
-      [ docLit (Text.pack "rec")
-      , docSeparator
-      , docSetBaseAndIndent $ docLines $ layoutStmt <$> stmts
-      ]
   BodyStmt expr _ _ _      -> do
     expDoc <- docSharedWrapper layoutExpr expr
     docAddBaseY BrIndentRegular $ expDoc
diff --git a/src/Language/Haskell/Brittany/Internal/Layouters/Type.hs b/src/Language/Haskell/Brittany/Internal/Layouters/Type.hs
index a5148f5..36d1633 100644
--- a/src/Language/Haskell/Brittany/Internal/Layouters/Type.hs
+++ b/src/Language/Haskell/Brittany/Internal/Layouters/Type.hs
@@ -14,11 +14,7 @@ import           Language.Haskell.Brittany.Internal.Types
 import           Language.Haskell.Brittany.Internal.LayouterBasics
 
 import           RdrName ( RdrName(..) )
-import           GHC ( runGhc
-                     , GenLocated(L)
-                     , moduleNameString
-                     , AnnKeywordId (..)
-                     )
+import           GHC ( runGhc, GenLocated(L), moduleNameString )
 import           Language.Haskell.GHC.ExactPrint.Types ( mkAnnKey )
 import           HsSyn
 import           Name
@@ -33,20 +29,12 @@ layoutType :: ToBriDoc HsType
 layoutType ltype@(L _ typ) = docWrapNode ltype $ case typ of
   -- _ | traceShow (ExactPrint.Types.mkAnnKey ltype) False -> error "impossible"
 #if MIN_VERSION_ghc(8,2,0) /* ghc-8.2 */
-  HsTyVar promoted name -> do
-    t <- lrdrNameToTextAnn name
-    case promoted of
-      Promoted -> docSeq
-        [ docSeparator
-        , docTick
-        , docWrapNode name $ docLit t
-        ]
-      NotPromoted -> docWrapNode name $ docLit t
+  HsTyVar _ name -> do
 #else /* ghc-8.0 */
   HsTyVar name -> do
+#endif
     t <- lrdrNameToTextAnn name
     docWrapNode name $ docLit t
-#endif
   HsForAllTy bndrs (L _ (HsQualTy (L _ cntxts@(_:_)) typ2)) -> do
     typeDoc <- docSharedWrapper layoutType typ2
     tyVarDocs <- bndrs `forM` \case
@@ -306,7 +294,7 @@ layoutType ltype@(L _ typ) = docWrapNode ltype $ case typ of
     docAlt
       [ docSeq
         [ docForceSingleline typeDoc1
-        , docSeparator
+        , docLit $ Text.pack " "
         , docForceSingleline typeDoc2
         ]
       , docPar
@@ -336,7 +324,7 @@ layoutType ltype@(L _ typ) = docWrapNode ltype $ case typ of
     docAlt
       [ docSeq
       $ docForceSingleline docHead : (docRest >>= \d ->
-        [ docSeparator, docForceSingleline d ])
+        [ docLit $ Text.pack " ", docForceSingleline d ])
       , docPar docHead (docLines $ docEnsureIndent BrIndentRegular <$> docRest)
       ]
   HsAppsTy (typHead:typRest) -> do
@@ -345,7 +333,7 @@ layoutType ltype@(L _ typ) = docWrapNode ltype $ case typ of
     docAlt
       [ docSeq
       $ docForceSingleline docHead : (docRest >>= \d ->
-        [ docSeparator, docForceSingleline d ])
+        [ docLit $ Text.pack " ", docForceSingleline d ])
       , docPar docHead (docLines $ docEnsureIndent BrIndentRegular <$> docRest)
       ]
     where
@@ -525,47 +513,19 @@ layoutType ltype@(L _ typ) = docWrapNode ltype $ case typ of
   HsKindSig typ1 kind1 -> do
     typeDoc1 <- docSharedWrapper layoutType typ1
     kindDoc1 <- docSharedWrapper layoutType kind1
-    hasParens <- hasAnnKeyword ltype AnnOpenP
     docAlt
-      [ if hasParens
-        then docSeq
-          [ docLit $ Text.pack "("
-          , docForceSingleline typeDoc1
-          , docSeparator
-          , docLit $ Text.pack "::"
-          , docSeparator
-          , docForceSingleline kindDoc1
-          , docLit $ Text.pack ")"
-          ]
-        else docSeq
-          [ docForceSingleline typeDoc1
-          , docSeparator
-          , docLit $ Text.pack "::"
-          , docSeparator
-          , docForceSingleline kindDoc1
-          ]
-      , if hasParens
-        then docLines
-          [ docCols
-            ColTyOpPrefix
-            [ docWrapNodeRest ltype $ docParenLSep
-            , docAddBaseY (BrIndentSpecial 3) $ typeDoc1
-            ]
-          , docCols
-            ColTyOpPrefix
-            [ docWrapNodeRest ltype $ docLit $ Text.pack ":: "
-            , docAddBaseY (BrIndentSpecial 3) kindDoc1
-            ]
-          , (docLit $ Text.pack ")")
-          ]
-        else docPar
+      [ docSeq
+        [ docForceSingleline typeDoc1
+        , docLit $ Text.pack " :: "
+        , docForceSingleline kindDoc1
+        ]
+      , docPar
           typeDoc1
-          ( docCols
-            ColTyOpPrefix
-            [ docWrapNodeRest ltype $ docLit $ Text.pack ":: "
-            , docAddBaseY (BrIndentSpecial 3) kindDoc1
-            ]
-          )
+          ( docCols ColTyOpPrefix
+              [ docWrapNodeRest ltype
+              $ docLit $ Text.pack ":: "
+              , docAddBaseY (BrIndentSpecial 3) kindDoc1
+              ])
       ]
   HsBangTy{} -> -- TODO
     briDocByExactInlineOnly "HsBangTy{}" ltype
diff --git a/srcinc/prelude.inc b/srcinc/prelude.inc
index 81ca53a..805b941 100644
--- a/srcinc/prelude.inc
+++ b/srcinc/prelude.inc
@@ -136,7 +136,7 @@ import qualified Data.Text.Lazy.IO as TextL.IO
 import qualified Control.Monad.Trans.State as State
 import qualified Control.Monad.Trans.State.Lazy as StateL
 import qualified Control.Monad.Trans.State.Strict as StateS
-import qualified Control.Monad.Trans.Except as ExceptT
+import qualified Control.Monad.Trans.Either as EitherT
 
 import qualified Data.Strict.Maybe as Strict
 
diff --git a/stack.yaml b/stack.yaml
index 539cd6d..39c0882 100644
--- a/stack.yaml
+++ b/stack.yaml
@@ -3,7 +3,7 @@ resolver: lts-9.0
 extra-deps:
   - monad-memo-0.4.1
   - czipwith-1.0.0.0
-  - butcher-1.2.0.0
+  - butcher-1.1.0.0
   - data-tree-print-0.1.0.0
   - deque-0.2