Merge pull request #377 from lspitzner/tfausak-patch-1

Announce end of maintenance

.devcontainer/Dockerfile

@@ -0,0 +1,30 @@
+ARG UBUNTU_TAG=20.04
+FROM ubuntu:"$UBUNTU_TAG"
+
+ENV LANG=C.UTF-8
+RUN \
+    apt-get update && \
+    apt-get install --assume-yes curl gcc git libgmp-dev libtinfo-dev make sudo
+
+ARG GHCUP_VERSION=0.1.17.4
+RUN \
+    curl --output /usr/local/bin/ghcup "https://downloads.haskell.org/~ghcup/$GHCUP_VERSION/x86_64-linux-ghcup-$GHCUP_VERSION" && \
+    chmod +x /usr/local/bin/ghcup && \
+    ghcup --version
+
+ARG USER_NAME=haskell
+RUN \
+    useradd --create-home --shell "$( which bash )" "$USER_NAME" && \
+    echo "$USER_NAME ALL=(ALL) NOPASSWD: ALL" | tee "/etc/sudoers.d/$USER_NAME"
+USER "$USER_NAME"
+ENV PATH="/home/$USER_NAME/.cabal/bin:/home/$USER_NAME/.ghcup/bin:$PATH"
+
+ARG GHC_VERSION=9.0.1
+RUN \
+    ghcup install ghc "$GHC_VERSION" --set && \
+    ghc --version
+
+ARG CABAL_VERSION=3.6.2.0
+RUN \
+    ghcup install cabal "$CABAL_VERSION" --set && \
+    cabal --version

.devcontainer/devcontainer.json

@@ -0,0 +1,6 @@
+{
+    "build": {
+        "dockerfile": "Dockerfile"
+    },
+    "postCreateCommand": "cabal update"
+}

.github/workflows/ci.yaml

@@ -0,0 +1,105 @@
+name: CI
+on:
+  pull_request:
+    branches:
+      - main
+      - master
+  push:
+    branches:
+      - main
+      - master
+  release:
+    types:
+      - created
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { os: macos-11, ghc: 9.0.1, cabal: 3.6.2.0 }
+          - { os: ubuntu-20.04, ghc: 9.0.1, cabal: 3.6.2.0 }
+          - { os: windows-2019, ghc: 9.0.1, cabal: 3.6.2.0, ext: .exe }
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v2
+      - run: mkdir artifact
+      - run: mkdir artifact/${{ matrix.os }}
+      - id: setup-haskell
+        uses: haskell/actions/setup@v1
+        with:
+          ghc-version: ${{ matrix.ghc }}
+          cabal-version: ${{ matrix.cabal }}
+      - run: cabal configure --enable-tests --flags pedantic --jobs
+      - run: cabal freeze
+      - run: cat cabal.project.freeze
+      - uses: actions/cache@v2
+        with:
+          path: ${{ steps.setup-haskell.outputs.cabal-store }}
+          key: ${{ matrix.os }}-${{ matrix.ghc }}-${{ matrix.cabal }}-${{ hashFiles('cabal.project.freeze') }}
+          restore-keys: |
+            ${{ matrix.os }}-${{ matrix.ghc }}-${{ matrix.cabal }}-
+            ${{ matrix.os }}-${{ matrix.ghc }}-
+      - run: cabal build
+      - run: cabal install --installdir artifact/${{ matrix.os }} --install-method copy
+      - run: cabal test --test-show-details direct
+      - run: cabal check
+      - run: cabal sdist --output-dir artifact/${{ matrix.os }}
+      - uses: svenstaro/upx-action@v2
+        with:
+          file: artifact/${{ matrix.os }}/brittany${{ matrix.ext }}
+      - uses: actions/upload-artifact@v2
+        with:
+          path: artifact
+          name: brittany-${{ github.sha }}
+
+  release:
+    needs: build
+    if: github.event_name == 'release'
+    runs-on: ubuntu-20.04
+    steps:
+
+      - uses: actions/checkout@v2
+
+      - uses: actions/download-artifact@v2
+        with:
+          name: brittany-${{ github.sha }}
+          path: artifact
+
+      - uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          asset_content_type: application/octet-stream
+          asset_name: brittany-${{ github.event.release.tag_name }}-ubuntu
+          asset_path: artifact/ubuntu-20.04/brittany
+          upload_url: ${{ github.event.release.upload_url }}
+
+      - uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          asset_content_type: application/octet-stream
+          asset_name: brittany-${{ github.event.release.tag_name }}-macos
+          asset_path: artifact/macos-11/brittany
+          upload_url: ${{ github.event.release.upload_url }}
+
+      - uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          asset_content_type: application/octet-stream
+          asset_name: brittany-${{ github.event.release.tag_name }}-windows.exe
+          asset_path: artifact/windows-2019/brittany.exe
+          upload_url: ${{ github.event.release.upload_url }}
+
+      - uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          asset_content_type: application/gzip
+          asset_name: brittany-${{ github.event.release.tag_name }}.tar.gz
+          asset_path: artifact/ubuntu-20.04/brittany-${{ github.event.release.tag_name }}.tar.gz
+          upload_url: ${{ github.event.release.upload_url }}
+
+      - run: cabal upload --publish --username '${{ secrets.HACKAGE_USERNAME }}' --password '${{ secrets.HACKAGE_PASSWORD }}' artifact/ubuntu-20.04/brittany-${{ github.event.release.tag_name }}.tar.gz

.gitignore

@@ -5,7 +5,11 @@
 *.ps
 /*.pdf
 dist/
+dist-newstyle/
 local/
 .cabal-sandbox/
-.stack-work/
 cabal.sandbox.config
+cabal.project.local*
+cabal.project.freeze
+.ghc.environment.*
+result

.hlint.yaml

@@ -0,0 +1,16 @@
+# HLint configuration file
+# https://github.com/ndmitchell/hlint
+##########################
+
+# This file contains a template configuration file, which is typically
+# placed as .hlint.yaml in the root of your project
+
+- ignore: { name: 'Use :' }
+- ignore: { name: Eta reduce }
+- ignore: { name: Move brackets to avoid $ }
+- ignore: { name: Redundant $ }
+- ignore: { name: Redundant bracket }
+- ignore: { name: Use newtype instead of data }
+- ignore: {name: "Redundant do"}
+- ignore: {name: "Redundant return"}
+- ignore: {name: "Use camelCase"}

.vscode/extensions.json

@@ -0,0 +1,5 @@
+{
+    "recommendations": [
+        "taylorfausak.purple-yolk"
+    ]
+}

.vscode/settings.json

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

ChangeLog.md

@@ -1,5 +1,317 @@
 # Revision history for brittany
 
-## 0.1.0.0  -- YYYY-mm-dd
+## 0.14.0.0 -- November 2021
 
-* First version. Released on an unsuspecting world.
+* #357: Added support for GHC 9.0. Dropped support for all other versions of GHC.
+  * ab59e9acc3069551ac4132321b285d000f5f5691: Removed runtime dependency on `ghc-paths`.
+  * fa8365a7fa9372043d5a1018f2f7669ce3853edd: Started providing pre-built binaries for Linux, MacOS, and Windows.
+  * Many other changes to Brittany's internals and exposed Haskell interface, but (hopefully) no changes to its command-line interface.
+
+## 0.13.1.2 -- May 2021
+
+* #347: Allowed hspec 2.8. Thanks @felixonmars!
+
+## 0.13.1.1 -- February 2021
+
+* #333: Allowed random 1.2. Thanks @felixonmars!
+* #334: Updated Arch install instructions. Thanks @ahstro!
+* #343: Allowed ghc-exactprint 0.6.4. Thanks @maralorn!
+
+## 0.13.1.0 -- December 2020
+
+* #330: Started sorting imports. Thanks @expipiplus1!
+
+## 0.13.0.0 -- December 2020
+
+* #324: Added support for GHC 8.10.
+  * Dropped support for GHC 8.4, 8.2, and 8.0.
+  * Thanks @jneira, @bubba, @infinity0, and @expipiplus1!
+
+## 0.12.2.0 -- November 2020
+
+* #207: Fix newtype indent in associated type family.
+* #231: Improve comments-affecting-layout behaviour for tuples.
+* #259: Data declaration for newtype and records. Thanks @eborden!
+* #263: Fix non-idempotent newlines with comment + where.
+* #273: Error handling.
+* #281: Fix moving comment in export list (haddock header).
+* #286: Fix comments in instance/type instances.
+* #287: Add support for pattern synonyms. Thanks @RaoulHC!
+* #293: Expose main function as a module. Thanks @soareschen!
+* #303: Readme: Supports 8.8. Thanks @andys8!
+* #311: Allows aeson-1.5.*. Thanks @jkachmar!
+* #313: Nondecreasing export list formatting. Thanks @expipiplus1!
+
+## 0.12.1.1 -- December 2019
+
+* Bugfixes:
+    - Fix layouting regression of record update for many/large fields
+    - Fix whitespace regression on ExplicitForall notation
+      (`foo :: forall  a . Show a => a -> a`, note the double space)
+      introduced in 0.12. (#264)
+    - Fix roundtripping of type equality constraint
+      `f :: ((~) a b) => a -> b` (#267)
+* One experimental feature addition: Turning brace notation semicolons into
+  newlines when formatting (see #270)
+
+## 0.12.1.0 -- September 2019
+
+* Support ghc-8.8
+* Support for OverloadedLabels extension
+  (thanks to Evan Rutledge Borden @eborden)
+* Support for Implicit Params extension (thanks to pepe iborra @pepeiborra)
+* Add flag `--no-user-config` to enable only using manually passed config
+* Disable the performance test suite by default to prevent spurious failures
+  on certain CI setups. The github/travis brittany CI still has all tests
+  enabled. See the `brittany-test-perf` flag in the cabal file.
+* Bugfixes:
+    - Fix one wandering-comment bug for let-in expressions
+    - Fix invalid result for prefix operator pattern matches
+    - Fix lambda expression with laziness/strictness annotation
+    - Fix parenthesis handling for infix pattern matches with 3+ arguments
+* Changes to layouting behaviour:
+    - For pattern matching and data/instance definitions, the usage of
+      parenthesis is now "normalized", i.e. superfluous parens are removed by
+      brittany.
+
+## 0.12.0.0 -- June 2019
+
+* Support for ghc-8.6 (basic support, not necessarily all new syntactic
+  extensions)
+* Support -XExplicitNamespaces and -XPatternSynonyms
+* Allow a --dry-run sort of operation via flag "-c/--check-mode"
+  (thanks to Doug Beardsley @mightybyte)
+* Include file name in errors about unsupported syntax nodes (thanks to @5outh)
+* Partially implement layouting class instances: Layouts children, but
+  falls back on ghc-exactprint for the instance head
+  (thanks to Rupert Horlick @ruhatch)
+* Implement layouting for type synonyms (thanks to Rupert Horlick @ruhatch)
+* Support -XMagicHash, -XUnboxedTuples (thanks to Sergey Vinokurov @sergv)
+* Support -XQuasiQuotes (no formatting applied to the splices; they are simply
+  retained without causing the dreaded "Unknown construct: HsSpliceE{}")
+    - `lconfig_allowHangingQuasiQuotes` controls whether multi-line
+      QuasiQuotes are allowed to start at the end of the current line, or
+      whether they are always placed in new lines.
+* Bugfixes:
+    - Fix rare-case alignment bug with IndentPolicyMultiple (#144)
+    - Make inline layout config apply to module header (#151)
+    - Fix unaligned import-hiding layout (#150)
+    - Fix idempotence violation for comments around if-then-else (#167)
+    - Fix comments having an effect on far-away parent node's layout (#159)
+    - Fix imports of type operators ("symbolic data types")
+      (thanks to Phil Hazelden @ChickenProp)
+    - Work around GHC and cabal-install misfeature ".ghc.environment files"
+      that could break brittany in unexpected and hard-to-understand ways
+    - Stop removing empty lines before `where` keyword in a couple of cases
+    - Fix functions with mixing prefix/infix style causing error (#234)
+* Changes to layout:
+    - Align usage of spaces for record update vs record construction (#126)
+    - More indentation to import-hiding-paragraph (follow-up to #150 fix)
+    - Record construction and update now are layouted in the same way
+      (thanks to Evan Rutledge Borden @eborden)
+    - Stop allowing single-line layout when there are comments between
+      arguments (#214) (thanks to @matt-noonan)
+* Various build-instructions and editor integrations
+
+## 0.11.0.0 -- May 2018
+
+* Support for ghc-8.4
+* Implement inline-config
+    e.g. "-- brittany --indent=4"
+
+    respects the following comment forms as input:
+
+    ~~~~
+    source comment                       affected target
+    ======================================================
+    "-- brittany CONFIG"                 whole module
+    "-- brittany-next-binding CONFIG"    next binding
+    "-- brittany-disable-next-binding"   next binding
+    "-- brittany @ myExampleFunc CONFIG" `myExampleFunc`
+    ~~~~
+
+    multiline-comments are supported too, although
+    the specification must still be a single line. E.g.
+
+    > "{- brittany --columns 50 -}"
+
+    CONFIG is either:
+
+    1) one or more flags in the form of what brittany accepts
+       on the commandline, e.g. "--columns 50", or
+    2) one or more specifications in the form of what brittany
+       accepts in its config files for the layouting config
+       (a one-line yaml document), e.g. "{ lconfig_cols: 50 }"
+* Implement `IndentPolicyMultiple` (thanks to Bryan Richter @chreekat)
+    Restrict indentation amounts to `n * indentAmount`
+* Implement `--obfuscate` that replaces non-keyword identifiers with random
+  names
+* Do not write files unless there are changes (don't update modtime)
+  (`--write-mode=inplace`) (#93)
+* Bugfixes:
+    - Fix empty function constraints (`() => IO ()`) (#133)
+    - Fix overflowing columns caused by aligning with surrounding lines
+      for certain complex cases
+    - Implement hacky workaround for `type instance`s (`-XTypeFamilies`) (#89)
+* Layouting changes:
+    - On default settings, allow single-line module header
+      `module MyModule where` when no exports
+    - Fix one case of non-optimal layouting for if-then-else
+    - Allow same-line let binding inside do-notation with
+      `IndentPolicyLeft/Multiple` and `indentAmount>=4`
+
+## 0.10.0.0 -- March 2018
+
+* Implement module/exports/imports layouting (thanks to sniperrifle2004)
+* Expose config paths/parsing functions (thanks to Alexey Raga)
+* Bugfixes:
+    - Fix layouting of `NOINLINE` pragma
+    - Fix ticked type operator (e.g. `':-`) losing tick (#125)
+    - Fix alignment issue with cases involving operators (#65)
+    - Fix comments in tuples being dropped (#37)
+    - Fix comment placements with let-in (#110)
+* Layouting changes:
+    - Align arguments only if it is the same function being called (#128)
+    - Do not use single-line layout when infix operator expression contains
+      comments (#111)
+* New layouting config items:
+    - `lconfig_importColumn`/`--import-col`: column for import items
+    - `lconfig_importAsColumn`/`--import-as-col`: column for the "as" name of
+      a module
+    - `lconfig_reformatModulePreamble`: controls module/export/import layouting
+      (default True)
+    - `lconfig_allowSingleLineExportList`: permit one-line module header, e.g.
+      `module Main (main)` (default False)
+
+## 0.9.0.1  -- February 2018
+
+* Support `TupleSections` (thanks to Matthew Piziak)
+* Bugfixes:
+    - Fix Shebang handling with stdin input (#92)
+    - Fix bug that effectively deleted strict/lazy matches (BangPatterns) (#116)
+    - Fix infix operator whitespace bug (#101, #114)
+    - Fix help command output and its layouting (#103)
+    - Fix crash when config dir does not exist yet (#115)
+* Layouting changes:
+    - no space after opening non-tuple parenthesis even for multi-line case
+    - use spaces around infix operators (applies to sections and in pattern
+      matches)
+    - Let-in is layouted more flexibly in fewer lines, if possible
+      (thanks to Evan Borden)
+
+## 0.9.0.0  -- December 2017
+
+* Change default global config path (use XDG spec)
+    Existing config should still be respected, so this should not break
+    compatibility
+* Support per-project config
+* ! Slight rework of the commandline interface:
+    - Support multiple inputs and outputs
+    - Support inplace-transformation for multiple files via
+      `--write-mode=inplace`
+* Implement `IndentPolicyLeft` - the indentation mode that never adds more
+  than the base indentation for nested parts (no hanging indentation)
+
+    (thanks to Evan Borden)
+* Fix bug that manifested in bad output for (top-level) template haskell splices
+* Extension support:
+    - RecordWildCards
+    - RecursiveDo (was only partially supported previously)
+* Layouting Bugfixes:
+    - Properly reproduce parentheses around kind signatures
+    - Fix issue around promoted lists
+      (example good: `'[ 'True]` bad: `'['True]`)
+    - Trim text from exactprint used as workaround for unknown nodes
+      (unsupported extension workaround)
+* Layouting changes
+    - Insert spaces around operator in sections
+
+## 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`.
+* Publish to hackage.
+
+## 0.8.0.1  -- May 2017
+
+* Document the high-level design of the program
+* Improve layouting for many different cases, too many to list here. Brittany
+  still does only reformat top-level type signatures and bindings.
+* Publish all dependencies on hackage; `ghc-exactprint ` adaptions got merged
+  upstream as well.
+* Reduce the aggressiveness of horizontal alignment; this is configurable
+  via the `lconfig_alignmentLimit` and `lconfig_alignmentBreakOnMultiline`
+  values (config file only for now).
+* (!) Breaking change to the config file format: The keys previously contained
+  underscore (e.g. `_econf_Werror`) but do not anymore (`econf_Werror`).
+  Add config version; also
+* Move config value `conf_errorHandling.econf_CPPMode` to
+  `conf_preprocessor.ppconf_CPPMode`.
+* Cope with unhandled syntactical constructs more gracefully by falling back
+  on the ghc-exactprint output; Brittany simply won't touch certain
+  subexpressions instead of aborting. This is further configurable via the
+  `econf_omit_output_valid_check` config value.
+* Due to improvements to the `butcher` library: Accept `--key=value` on
+  commandline (only `--key value` was supported previously).
+* Improve testsuite setup: The `tests.blt` file contains many different
+  testcases that allow quick addition - feel free to report bugs directly
+  by making PRs with additions to that file.
+* Release under the terms of the AGPLv3
+
+## 0.7.1.0  -- 2016-09-06
+
+* Support stack
+* Fix --ghc-options handling
+* Add commandline param to allow shortcut `brittany Foo.hs`
+  meaning `brittany -i Foo.hs`
+
+## 0.7.0.0  -- 2016-09-04
+
+* First official alpha release
+* Fix commandline flag parsing
+* Implement/Improve horizontal aligning
+* Various minor fixes and layouting improvements
+
+## 0.6.0.0  -- 2016-08-12
+
+* Add check that output is syntactically valid
+* (!) Change config format, breaking previous configs
+* Various layouting additions/imporements
+* Various minor fixes
+
+## 0.5.0.0  -- 2016-08-08
+
+* Support --ghc-options
+* Support user and local config files: Local config file is not mandatory
+  anymore.
+
+## 0.4.0.0  -- 2016-08-06
+
+* Make comment handling a bit more clever
+* Various layouting additions/imporements
+
+## 0.3.0.0  -- 2016-08-04
+
+* Various layouting additions/imporements
+
+## 0.2.0.0  -- 2016-07-30
+
+* Basic and partial implementation for
+  expression/decl/statement/pattern layouting
+* Prevent exponential behaviour using manual stablenames
+
+## 0.1.0.0  -- 2016-06-05
+
+* First working code for type signature layouting

LICENSE

@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<http://www.gnu.org/licenses/>.

README.md

@@ -1,103 +1,197 @@
-# brittany
+# brittany [![Hackage version](https://img.shields.io/hackage/v/brittany.svg?label=Hackage)](https://hackage.haskell.org/package/brittany) [![Stackage version](https://www.stackage.org/package/brittany/badge/lts?label=Stackage)](https://www.stackage.org/package/brittany) [![Build Status](https://secure.travis-ci.org/lspitzner/brittany.svg?branch=master)](http://travis-ci.org/lspitzner/brittany)
+
+:warning:
+This project is effectively unmaintained!
+I ([@tfausak](https://github.com/tfausak)) would recommend switching to another formatter.
+At time of writing (2022-11-11), I would suggest [Ormolu](https://github.com/tweag/ormolu).
+Or if you prefer some configuration, I would suggest [Fourmolu](https://github.com/fourmolu/fourmolu).
+
 haskell source code formatter
 
 ![Output sample](https://github.com/lspitzner/brittany/raw/master/brittany-sample.gif)
 
-(see another demonstration in [Showcase.md](Showcase.md))
+(see [more examples and comparisons](/doc/showcases))
 
 This project's goals roughly are to:
 
-- Be idempotent (this also directly ensures that only valid haskell is
-  produced);
-- Support the full ghc-haskell syntax including syntactic extensions;
+- Always retain the semantics of the source being transformed;
+- Be idempotent;
+- Support the full GHC-haskell syntax including syntactic extensions
+  (but excluding `-XCPP` which is too hard);
 - Retain newlines and comments unmodified;
 - Be clever about using the available horizontal space while not overflowing
-  it if it cannot be avoided;
-- Be clever about aligning things horizontally.
+  the column maximum unless it cannot be avoided;
+- Be clever about aligning things horizontally (this can be turned off
+  completely however);
 - Have linear complexity in the size of the input.
 
-At this point, these goals are completed to different degrees.
-Currently, only type-signatures and function/value bindings are processed;
-other module elements (data-decls, classes, instances, imports/exports etc.) are not
-transformed in any way; this extends to e.g. bindings inside class instance
-definitions - they won't be touched (yet).
-By using ghc-exactprint as the parser, brittany supports full ghc syntax including
-extensions, but many of the less common syntactic elements (even of 2010 haskell) are
-not handled.
-There are cases where comments are not re-inserted properly (leading to an error or
-to affected comments being placed at a different location than in the input).
+In theory, the core algorithm inside brittany reaches these goals. It is rather
+clever about making use of horizontal space while still being linear in the
+size of the input (although the constant factor is not small). See
+[these examples of clever layouting](/doc/showcases/Layout_Interactions.md).
 
-The current algorithm is rather clever about horizontal space while still being
-linear in the size of the input (although the constant factor is not small).
+But brittany is not finished yet, and there are some open issues that yet
+require fixing:
 
-# Important notes
-
-- Requires `ghc`>=8
-- `-XCPP` is not officially supported (yet).
-- ~~Some commandline flags mentioned in the help don't work yet (and won't even
-  be parsed correctly.)~~ (fixed in 0.4.0.0)
-- some config values can not be configured via commandline yet.
-- ~~Creates a `brittany.yaml` config file _in the current directory_.~~
-  (fixed in 0.5.0.0; now creates user config file in `~/.brittany`;
-  still reads `brittany.yaml` in current dir if present.)
-- ~~Currently some unhandled syntactical constructs don't raise errors~~
-  (fixed in 0.6.0.0)
-- There are cases where comments are not copied to the output (this will
+- **only the module header (imports/exports), type-signatures and
+  function/value bindings** are processed;
+  other module elements (data-decls, classes, instances, etc.)
+  are not transformed in any way; this extends to e.g. **bindings inside class
+  instance definitions** - they **won't be touched** (yet).
+- By using `ghc-exactprint` as the parser, brittany supports full GHC
+  including extensions, but **some of the less common syntactic elements
+  (even of 2010 haskell) are not handled**.
+- **There are some known issues regarding handling of in-source comments.**
+  There are cases where comments are not copied to the output (this will
   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.)
 
-# Building
+## Try without Installing
 
-(This does not cover _installation_. TODO)
+You can [paste haskell code over here](https://hexagoxel.de/brittany/)
+to test how it gets formatted by brittany. (Rg. privacy: the server does
+log the size of the input, but _not_ the full input/output of requests.)
 
-via `cabal new-build`
+# Other usage notes
 
-~~~~.sh
-mkdir brittany-project
-cd brittany-project/
-git clone https://github.com/lspitzner/butcher.git
-git clone https://github.com/lspitzner/data-tree-print.git
-git clone https://github.com/lspitzner/ghc-exactprint.git
-git clone https://github.com/lspitzner/brittany.git
-cat > cabal.project <<EOF
-packages: data-tree-print butcher ghc-exactprint brittany
-EOF
-# cabal new-configure -w $PATH_TO_GHC_8
-cabal new-build brittany/
-~~~~
+- Supports GHC version `9.0.x`.
+- included in stackage with lts>=10.0 (or nightlies dating to >=2017-11-15)
+- config (file) documentation is lacking.
+- some config values can not be configured via commandline yet.
+- uses/creates user config file in `~/.config/brittany/config.yaml`;
+  also reads (the first) `brittany.yaml` found in current or parent
+  directories.
 
-or via `stack`
+# Installation
 
-~~~~.sh
-git clone https://github.com/lspitzner/brittany.git
-cd brittany
-stack build
-~~~~
+- via `stack`
 
+    ~~~~.sh
+    stack install brittany # --resolver lts-16.31
+    ~~~~
+
+    If you use an lts that includes brittany this should just work; otherwise
+    you may want to clone the repo and try again.
+
+- via `cabal`
+
+    Due to constant changes to the cabal UI, I have given up on making sure
+    these instructions work before releases. Please do not expect these
+    instructions to be up-to-date; they may produce incomprehensible error
+    messages, they may be broken otherwise, they may work now but break with
+    the next cabal release. Thanks for your understanding, and feel free to
+    open issues for any problems you encounter. -- lennart
+
+    If you are using cabal-3.0, using
+    `cabal install brittany --installdir=$HOME/.cabal/bin`
+    might work. Keep in mind that cabal merely puts a symlink to the "store"
+    into the installdir, so you have to re-install if you ever clean your
+    store. On cabal-2.4, try `cabal v2-install brittany`. On cabal-2.2 or
+    earlier you might be succesful using
+    ```cabal new-build exe:brittany; cp `find dist-newstyle/ -name brittany -type f | xargs -x ls -t | head -n1` $HOME/.cabal/bin/```.
+    Alternatively, you can also use the v1-approach with sandboxes as
+    `cabal v1-sandbox init; cabal v1-install brittany --bindir=$HOME/.cabal/bin`.
+
+    (TODO: These instructions are more confusing than helpful. I am inclined
+    to just remove them.)
+
+- on ArchLinux:
+    ~~~~.sh
+    pacman -S haskell-brittany
+    ~~~~
+
+# Development tips
+
+# Editor Integration
+
+#### Sublime text
+  [In this gist](https://gist.github.com/lspitzner/097c33177248a65e7657f0c6d0d12075)
+  I have described a haskell setup that includes a shortcut to run brittany formatting.
+#### VSCode
+  [This extension](https://marketplace.visualstudio.com/items?itemName=MaxGabriel.brittany)
+  connects commandline `brittany` to VSCode formatting API. Thanks to @MaxGabriel.
+#### Via HLS
+  [haskell-language-server](https://github.com/haskell/haskell-language-server)
+  includes a `brittany` plugin that directly uses the brittany library.
+  Relevant for any editors that properly support the language-server-protocol.
+#### Neovim / Vim 8
+  The [Neoformat](https://github.com/sbdchd/neoformat) plugin comes with support for
+  brittany built in.
+#### Atom
+  [Atom Beautify](https://atom.io/packages/atom-beautify) supports brittany as a formatter for Haskell. Since the default formatter is set to hindent, you will need to change this setting to brittany, after installing the extension.
+#### Emacs
+  [format-all](https://github.com/lassik/emacs-format-all-the-code) support brittany as the default formatter for Haskell.
 
 # Usage
 
-- Currently one mode of operation: Transform a single module. By default read
-  from `stdin` and written to `stdout`, but commandline arguments allow to
-  read/write from/to files.
+- Default mode of operation: Transform a single module, from `stdin` to `stdout`.
+  Can pass one or multiple files as input, and there is a flag to override them
+  in place instead of using `stdout` (since 0.9.0.0). So:
+
+    ~~~~ .sh
+    brittany                           # stdin -> stdout
+    brittany mysource.hs               # ./mysource.hs -> stdout
+    brittany --write-mode=inplace *.hs # apply formatting to all ./*.hs inplace
+    ~~~~
+
 - For stdin/stdout usage it makes sense to enable certain syntactic extensions
   by default, i.e. to add something like this to your
-  `~/.brittany/config.yaml` (execute `brittany` once to create default):
+  `~/.config/brittany/config.yaml` (execute `brittany` once to create default):
 
-  ~~~~
-  _conf_forward:
-    _options_ghc:
-    - -XLambdaCase
-    - -XMultiWayIf
-    - -XGADTs
-    - -XPatternGuards
-    - -XViewPatterns
-    - -XRecursiveDo
-    - -XTupleSections
-    - -XExplicitForAll
-    - -XImplicitParams
-    - -XQuasiQuotes
-    - -XTemplateHaskell
-    - -XBangPatterns
-  ~~~~
+    ~~~~
+    conf_forward:
+      options_ghc:
+      - -XLambdaCase
+      - -XMultiWayIf
+      - -XGADTs
+      - -XPatternGuards
+      - -XViewPatterns
+      - -XRecursiveDo
+      - -XTupleSections
+      - -XExplicitForAll
+      - -XImplicitParams
+      - -XQuasiQuotes
+      - -XTemplateHaskell
+      - -XBangPatterns
+    ~~~~
+
+# Feature Requests, Contribution, Documentation
+
+For a long time this project has had a single maintainer, and as a consequence
+there have been some mildly large delays for reacting to feature requests
+and even PRs.
+
+Sorry about that.
+
+The good news is that this project is getting sponsored by PRODA LTD, and two
+previous contributors, Evan Borden and Taylor Fausak, have agreed on helping
+with organisational aspects. Thanks!
+
+Still, this project has a long queue of very sensible feature requests, so it
+may take some time until new ones get our attention. But with the help of
+the co-maintainers, at least the reaction-times on PRs and the frequency
+of releases should improve significantly.
+
+If you are interested in making your own contributions, there is
+a good amount of high-level documentation at
+
+[the documentation index](doc/implementation/index.md)
+
+# License
+
+Copyright (C) 2016-2019 Lennart Spitzner\
+Copyright (C) 2019      PRODA LTD
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the
+[GNU Affero General Public License, version 3](http://www.gnu.org/licenses/agpl-3.0.html),
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.

Showcase.md

@@ -1,288 +0,0 @@
-# brittany showcase
-
-We will try to take the following module and try to fit it into 80 columns.
-
-## input
-
-~~~~ .hs
---        10        20        30        40        50        60        70        80
-module Language.Haskell.Brittany.BriLayouter
-  ( layoutBriDoc
-  )
-where
-
-
-
-layoutBriDoc :: Data.Data.Data ast => ast -> BriDocNumbered -> PPM ()
-layoutBriDoc ast briDoc = do
-  -- first step: transform the briDoc.
-  briDoc' <- MultiRWSS.withMultiStateS BDEmpty $ do
-    traceIfDumpConf "bridoc raw" _dconf_dump_bridoc_raw $ briDocToDoc $ unwrapBriDocNumbered $ briDoc
-    -- bridoc transformation: remove alts
-    transformAlts briDoc >>= mSet
-    mGet >>= traceIfDumpConf "bridoc post-alt" _dconf_dump_bridoc_simpl_alt . briDocToDoc
-    -- bridoc transformation: float stuff in
-    mGet <&> transformSimplifyFloating >>= mSet
-    mGet >>= traceIfDumpConf "bridoc post-floating" _dconf_dump_bridoc_simpl_floating . briDocToDoc
-    -- bridoc transformation: par removal
-    mGet <&> transformSimplifyPar >>= mSet
-    mGet >>= traceIfDumpConf "bridoc post-par" _dconf_dump_bridoc_simpl_par . briDocToDoc
-    -- bridoc transformation: float stuff in
-    mGet <&> transformSimplifyColumns >>= mSet
-    mGet >>= traceIfDumpConf "bridoc post-columns" _dconf_dump_bridoc_simpl_columns . briDocToDoc
-    -- -- bridoc transformation: indent
-    mGet <&> transformSimplifyIndent >>= mSet
-    mGet >>= traceIfDumpConf "bridoc post-indent" _dconf_dump_bridoc_simpl_indent . briDocToDoc
-    mGet >>= traceIfDumpConf "bridoc final" _dconf_dump_bridoc_final . briDocToDoc
-    -- -- convert to Simple type
-    -- simpl <- mGet <&> transformToSimple
-    -- return simpl
-  
-  anns :: ExactPrint.Types.Anns <- mAsk
-  let filteredAnns = filterAnns ast anns
-  
-  let state = LayoutState
-        { _lstate_baseY = 0
-        , _lstate_curY = 0
-        , _lstate_indLevel = 0
-        , _lstate_indLevelLinger = 0
-        , _lstate_commentsPrior = extractCommentsPrior filteredAnns
-        , _lstate_commentsPost = extractCommentsPost  filteredAnns
-        , _lstate_commentCol = Nothing
-        , _lstate_addSepSpace = Nothing
-        , _lstate_inhibitMTEL = False
-        , _lstate_isNewline = NewLineStateInit
-        }
-
-  state' <- MultiRWSS.withMultiStateS state $ layoutBriDocM briDoc'
-  
-  let remainingComments = Map.elems (_lstate_commentsPrior state') ++ Map.elems (_lstate_commentsPost  state')
-  remainingComments `forM_` (mTell . (:[]) . LayoutErrorUnusedComment . show . fmap fst)
-  
-  return $ ()
-~~~~
-
-## `brittany` output
-
-~~~~ .hs
---        10        20        30        40        50        60        70        80
-module Language.Haskell.Brittany.BriLayouter
-  ( layoutBriDoc
-  )
-where
-
-
-
-layoutBriDoc :: Data.Data.Data ast => ast -> BriDocNumbered -> PPM ()
-layoutBriDoc ast briDoc = do
-  -- first step: transform the briDoc.
-  briDoc'                       <- MultiRWSS.withMultiStateS BDEmpty $ do
-    traceIfDumpConf "bridoc raw" _dconf_dump_bridoc_raw
-      $ briDocToDoc
-      $ unwrapBriDocNumbered
-      $ briDoc
-    -- bridoc transformation: remove alts
-    transformAlts briDoc >>= mSet
-    mGet
-      >>= traceIfDumpConf "bridoc post-alt" _dconf_dump_bridoc_simpl_alt
-      .   briDocToDoc
-    -- bridoc transformation: float stuff in
-    mGet <&> transformSimplifyFloating >>= mSet
-    mGet
-      >>= traceIfDumpConf "bridoc post-floating"
-                          _dconf_dump_bridoc_simpl_floating
-      .   briDocToDoc
-    -- bridoc transformation: par removal
-    mGet <&> transformSimplifyPar >>= mSet
-    mGet
-      >>= traceIfDumpConf "bridoc post-par" _dconf_dump_bridoc_simpl_par
-      .   briDocToDoc
-    -- bridoc transformation: float stuff in
-    mGet <&> transformSimplifyColumns >>= mSet
-    mGet
-      >>= traceIfDumpConf "bridoc post-columns" _dconf_dump_bridoc_simpl_columns
-      .   briDocToDoc
-    -- -- bridoc transformation: indent
-    mGet <&> transformSimplifyIndent >>= mSet
-    mGet
-      >>= traceIfDumpConf "bridoc post-indent" _dconf_dump_bridoc_simpl_indent
-      .   briDocToDoc
-    mGet
-      >>= traceIfDumpConf "bridoc final" _dconf_dump_bridoc_final
-      .   briDocToDoc
-    -- -- convert to Simple type
-    -- simpl <- mGet <&> transformToSimple
-    -- return simpl
-
-  anns :: ExactPrint.Types.Anns <- mAsk
-  let filteredAnns = filterAnns ast anns
-
-  let state = LayoutState
-        { _lstate_baseY          = 0
-        , _lstate_curY           = 0
-        , _lstate_indLevel       = 0
-        , _lstate_indLevelLinger = 0
-        , _lstate_commentsPrior  = extractCommentsPrior filteredAnns
-        , _lstate_commentsPost   = extractCommentsPost filteredAnns
-        , _lstate_commentCol     = Nothing
-        , _lstate_addSepSpace    = Nothing
-        , _lstate_inhibitMTEL    = False
-        , _lstate_isNewline      = NewLineStateInit
-        }
-
-  state' <- MultiRWSS.withMultiStateS state $ layoutBriDocM briDoc'
-
-  let remainingComments = Map.elems (_lstate_commentsPrior state')
-        ++ Map.elems (_lstate_commentsPost state')
-  remainingComments
-    `forM_` (mTell . (:[]) . LayoutErrorUnusedComment . show . fmap fst)
-
-  return $ ()
-~~~~
-
-In contrast, let us look at Chris Done's `hindent` (version `5.2.1`) re-formatting results for the same input:
-
-## `hindent` output
-
-~~~~ .hs
---        10        20        30        40        50        60        70        80
-module Language.Haskell.Brittany.BriLayouter
-  ( layoutBriDoc
-  ) where
-
-layoutBriDoc
-  :: Data.Data.Data ast
-  => ast -> BriDocNumbered -> PPM ()
-layoutBriDoc ast briDoc
-                 -- first step: transform the briDoc.
- = do
-  briDoc' <-
-    MultiRWSS.withMultiStateS BDEmpty $ do
-      traceIfDumpConf "bridoc raw" _dconf_dump_bridoc_raw $
-        briDocToDoc $ unwrapBriDocNumbered $ briDoc
-      -- bridoc transformation: remove alts
-      transformAlts briDoc >>= mSet
-      mGet >>=
-        traceIfDumpConf "bridoc post-alt" _dconf_dump_bridoc_simpl_alt .
-        briDocToDoc
-      -- bridoc transformation: float stuff in
-      mGet <&> transformSimplifyFloating >>= mSet
-      mGet >>=
-        traceIfDumpConf "bridoc post-floating" _dconf_dump_bridoc_simpl_floating .
-        briDocToDoc
-      -- bridoc transformation: par removal
-      mGet <&> transformSimplifyPar >>= mSet
-      mGet >>=
-        traceIfDumpConf "bridoc post-par" _dconf_dump_bridoc_simpl_par .
-        briDocToDoc
-      -- bridoc transformation: float stuff in
-      mGet <&> transformSimplifyColumns >>= mSet
-      mGet >>=
-        traceIfDumpConf "bridoc post-columns" _dconf_dump_bridoc_simpl_columns .
-        briDocToDoc
-      -- -- bridoc transformation: indent
-      mGet <&> transformSimplifyIndent >>= mSet
-      mGet >>=
-        traceIfDumpConf "bridoc post-indent" _dconf_dump_bridoc_simpl_indent .
-        briDocToDoc
-      mGet >>=
-        traceIfDumpConf "bridoc final" _dconf_dump_bridoc_final . briDocToDoc
-  -- -- convert to Simple type
-  -- simpl <- mGet <&> transformToSimple
-  -- return simpl
-  anns :: ExactPrint.Types.Anns <- mAsk
-  let filteredAnns = filterAnns ast anns
-  let state =
-        LayoutState
-        { _lstate_baseY = 0
-        , _lstate_curY = 0
-        , _lstate_indLevel = 0
-        , _lstate_indLevelLinger = 0
-        , _lstate_commentsPrior = extractCommentsPrior filteredAnns
-        , _lstate_commentsPost = extractCommentsPost filteredAnns
-        , _lstate_commentCol = Nothing
-        , _lstate_addSepSpace = Nothing
-        , _lstate_inhibitMTEL = False
-        , _lstate_isNewline = NewLineStateInit
-        }
-  state' <- MultiRWSS.withMultiStateS state $ layoutBriDocM briDoc'
-  let remainingComments =
-        Map.elems (_lstate_commentsPrior state') ++
-        Map.elems (_lstate_commentsPost state')
-  remainingComments `forM_`
-    (mTell . (: []) . LayoutErrorUnusedComment . show . fmap fst)
-  return $ ()
-~~~~
-
-and haskell-formatter (version 1.0.0)
-
-## `haskell-formatter` output
-
-~~~~ .hs
---        10        20        30        40        50        60        70        80
-module Language.Haskell.Brittany.BriLayouter (layoutBriDoc) where
-
-layoutBriDoc :: Data.Data.Data ast => ast -> BriDocNumbered -> PPM ()
-layoutBriDoc ast briDoc
-  -- first step: transform the briDoc.
-  = do briDoc' <- MultiRWSS.withMultiStateS BDEmpty $
-                    do traceIfDumpConf "bridoc raw" _dconf_dump_bridoc_raw $
-                         briDocToDoc $ unwrapBriDocNumbered $ briDoc
-                       -- bridoc transformation: remove alts
-                       transformAlts briDoc >>= mSet
-                       mGet >>=
-                         traceIfDumpConf "bridoc post-alt"
-                           _dconf_dump_bridoc_simpl_alt
-                           . briDocToDoc
-                       -- bridoc transformation: float stuff in
-                       mGet <&> transformSimplifyFloating >>= mSet
-                       mGet >>=
-                         traceIfDumpConf "bridoc post-floating"
-                           _dconf_dump_bridoc_simpl_floating
-                           . briDocToDoc
-                       -- bridoc transformation: par removal
-                       mGet <&> transformSimplifyPar >>= mSet
-                       mGet >>=
-                         traceIfDumpConf "bridoc post-par"
-                           _dconf_dump_bridoc_simpl_par
-                           . briDocToDoc
-                       -- bridoc transformation: float stuff in
-                       mGet <&> transformSimplifyColumns >>= mSet
-                       mGet >>=
-                         traceIfDumpConf "bridoc post-columns"
-                           _dconf_dump_bridoc_simpl_columns
-                           . briDocToDoc
-                       -- -- bridoc transformation: indent
-                       mGet <&> transformSimplifyIndent >>= mSet
-                       mGet >>=
-                         traceIfDumpConf "bridoc post-indent"
-                           _dconf_dump_bridoc_simpl_indent
-                           . briDocToDoc
-                       mGet >>=
-                         traceIfDumpConf "bridoc final" _dconf_dump_bridoc_final
-                           . briDocToDoc
-       -- -- convert to Simple type
-       -- simpl <- mGet <&> transformToSimple
-       -- return simpl
-       anns :: ExactPrint.Types.Anns <- mAsk
-       let filteredAnns = filterAnns ast anns
-       let state
-             = LayoutState{_lstate_baseY = 0, _lstate_curY = 0,
-                           _lstate_indLevel = 0, _lstate_indLevelLinger = 0,
-                           _lstate_commentsPrior =
-                             extractCommentsPrior filteredAnns,
-                           _lstate_commentsPost =
-                             extractCommentsPost filteredAnns,
-                           _lstate_commentCol = Nothing,
-                           _lstate_addSepSpace = Nothing,
-                           _lstate_inhibitMTEL = False,
-                           _lstate_isNewline = NewLineStateInit}
-
-       state' <- MultiRWSS.withMultiStateS state $ layoutBriDocM briDoc'
-       let remainingComments
-             = Map.elems (_lstate_commentsPrior state') ++
-                 Map.elems (_lstate_commentsPost state')
-       remainingComments `forM_`
-         (mTell . (: []) . LayoutErrorUnusedComment . show . fmap fst)
-       return $ ()
-~~~~

brittany.cabal

@@ -1,249 +1,149 @@
-name:                brittany
-version:             0.7.1.0
--- synopsis:            
--- description:         
-license:             AllRightsReserved
--- license-file:        LICENSE
-author:              Lennart Spitzner
-maintainer:          lsp@informatik.uni-kiel.de
--- copyright:           
-category:            Language
-build-type:          Simple
-extra-source-files:  ChangeLog.md
-cabal-version:       >=1.10
+cabal-version: 2.2
 
-flag brittany-dev
-  description: dev options
+name:                 brittany
+version:              0.14.0.2
+synopsis:             Haskell source code formatter
+description:
+  See <https://github.com/lspitzner/brittany/blob/master/README.md the README>.
+  .
+  If you are interested in the implementation, have a look at <https://github.com/lspitzner/brittany/blob/master/doc/implementation/theory.md this document>;
+  .
+  The implementation is documented in more detail <https://github.com/lspitzner/brittany/blob/master/doc/implementation/index.md here>.
+license:              AGPL-3.0-only
+license-file:         LICENSE
+author:               Lennart Spitzner
+maintainer:           Lennart Spitzner <hexagoxel@hexagoxel.de>
+copyright:            Copyright (C) 2016-2019 Lennart Spitzner
+                      Copyright (C) 2019 PRODA LTD
+category:             Language
+build-type:           Simple
+homepage:             https://github.com/lspitzner/brittany/
+bug-reports:          https://github.com/lspitzner/brittany/issues
+extra-doc-files:
+  ChangeLog.md
+  README.md
+  doc/implementation/*.md
+extra-source-files:
+  data/brittany.yaml
+  data/*.hs
+
+source-repository head
+  type: git
+  location: https://github.com/lspitzner/brittany.git
+
+flag pedantic
   default: False
+  description: Enables @-Werror@, which turns warnings into errors.
   manual: True
 
-flag brittany-dev-lib
-  description: set buildable false for anything but lib
-  default: False
-  manual: True
-
-library {
-  default-language:
-    Haskell2010
-  hs-source-dirs:
-    src
-  exposed-modules: {
-    Language.Haskell.Brittany
-    Language.Haskell.Brittany.Prelude
-    Language.Haskell.Brittany.Types
-    Language.Haskell.Brittany.Utils
-    Language.Haskell.Brittany.Config
-    Language.Haskell.Brittany.Config.Types
-  }
-  other-modules: {
-    Language.Haskell.Brittany.LayouterBasics
-    Language.Haskell.Brittany.Backend
-    Language.Haskell.Brittany.BackendUtils
-    Language.Haskell.Brittany.ExactPrintUtils
-    Language.Haskell.Brittany.Layouters.Type
-    Language.Haskell.Brittany.Layouters.Decl
-    Language.Haskell.Brittany.Layouters.Expr
-    Language.Haskell.Brittany.Layouters.Stmt
-    Language.Haskell.Brittany.Layouters.Pattern
-    Language.Haskell.Brittany.Transformations.Alt
-    Language.Haskell.Brittany.Transformations.Floating
-    Language.Haskell.Brittany.Transformations.Par
-    Language.Haskell.Brittany.Transformations.Columns
-    Language.Haskell.Brittany.Transformations.Indent
-  }
-  ghc-options: {
-    -Wall
-    -fprof-auto -fprof-cafs -fno-spec-constr
-    -j
-    -fno-warn-unused-imports
-    -fno-warn-orphans
-  }
-  if flag(brittany-dev) {
-    ghc-options: -O0 -Werror -fobject-code
-  }
+common library
   build-depends:
-    { base >=4.9 && <4.10
-    , ghc >=8.0.1 && <8.1
-    , ghc-paths >=0.1.0.9 && <0.2
-    , ghc-exactprint >=0.5.1.1 && <0.6
-    , transformers >=0.5.2.0 && <0.6
-    , containers >=0.5.7.1 && <0.6
-    , mtl >=2.2.1 && <2.3
-    , text >=1.2 && <1.3
-    , multistate >=0.7.1.1 && <0.8
-    , syb >=0.6 && <0.7
-    , neat-interpolation >=0.3.2 && <0.4
-    , data-tree-print
-    , pretty >=1.1.3.3 && <1.2
-    , bytestring >=0.10.8.1 && <0.11
-    , directory >=1.2.6.2 && <1.3
-    , lens
-    , butcher
-    , yaml >=0.8.18 && <0.9
-    , extra >=1.4.10 && <1.5
-    , uniplate >=1.6.12 && <1.7
-    , strict >=0.3.2 && <0.4
-    , monad-memo >=0.4.1 && <0.5
-    , 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
-    }
-  default-extensions: {
-    CPP
+    , aeson ^>= 2.0.1
+    , base ^>= 4.15.0
+    , butcher ^>= 1.3.3
+    , bytestring ^>= 0.10.12
+    , cmdargs ^>= 0.10.21
+    , containers ^>= 0.6.4
+    , czipwith ^>= 1.0.1
+    , data-tree-print ^>= 0.1.0
+    , deepseq ^>= 1.4.5
+    , directory ^>= 1.3.6
+    , extra ^>= 1.7.10
+    , filepath ^>= 1.4.2
+    , ghc ^>= 9.0.1
+    , ghc-boot ^>= 9.0.1
+    , ghc-boot-th ^>= 9.0.1
+    , ghc-exactprint ^>= 0.6.4
+    , monad-memo ^>= 0.5.3
+    , mtl ^>= 2.2.2
+    , multistate ^>= 0.8.0
+    , pretty ^>= 1.1.3
+    , random ^>= 1.2.1
+    , safe ^>= 0.3.19
+    , semigroups ^>= 0.19.2
+    , strict ^>= 0.4.0
+    , syb ^>= 0.7.2
+    , text ^>= 1.2.5
+    , transformers ^>= 0.5.6
+    , uniplate ^>= 1.6.13
+    , yaml ^>= 0.11.7
+  default-language: Haskell2010
+  ghc-options:
+    -Weverything
+    -Wno-all-missed-specialisations
+    -Wno-incomplete-uni-patterns
+    -Wno-missing-deriving-strategies
+    -Wno-missing-export-lists
+    -Wno-missing-import-lists
+    -Wno-missing-local-signatures
+    -Wno-missing-safe-haskell-mode
+    -Wno-monomorphism-restriction
+    -Wno-prepositive-qualified-module
+    -Wno-safe
+    -Wno-unsafe
 
-    NoImplicitPrelude
+  if flag(pedantic)
+    ghc-options: -Werror
 
-    GADTs
+common executable
+  import: library
 
-    FlexibleContexts
-    FlexibleInstances
-    ScopedTypeVariables
-    MonadComprehensions
-    LambdaCase
-    MultiWayIf
-    KindSignatures
-  }
-  include-dirs:
-    srcinc
-}
+  build-depends: brittany
+  ghc-options:
+    -rtsopts
+    -threaded
+    -Wno-implicit-prelude
+    -Wno-unused-packages
+
+library
+  import: library
+
+  autogen-modules: Paths_brittany
+  hs-source-dirs: source/library
+  exposed-modules:
+    Language.Haskell.Brittany
+    Language.Haskell.Brittany.Internal
+    Language.Haskell.Brittany.Internal.Backend
+    Language.Haskell.Brittany.Internal.BackendUtils
+    Language.Haskell.Brittany.Internal.Config
+    Language.Haskell.Brittany.Internal.Config.Types
+    Language.Haskell.Brittany.Internal.Config.Types.Instances
+    Language.Haskell.Brittany.Internal.ExactPrintUtils
+    Language.Haskell.Brittany.Internal.LayouterBasics
+    Language.Haskell.Brittany.Internal.Layouters.DataDecl
+    Language.Haskell.Brittany.Internal.Layouters.Decl
+    Language.Haskell.Brittany.Internal.Layouters.Expr
+    Language.Haskell.Brittany.Internal.Layouters.IE
+    Language.Haskell.Brittany.Internal.Layouters.Import
+    Language.Haskell.Brittany.Internal.Layouters.Module
+    Language.Haskell.Brittany.Internal.Layouters.Pattern
+    Language.Haskell.Brittany.Internal.Layouters.Stmt
+    Language.Haskell.Brittany.Internal.Layouters.Type
+    Language.Haskell.Brittany.Internal.Obfuscation
+    Language.Haskell.Brittany.Internal.ParseModule
+    Language.Haskell.Brittany.Internal.Prelude
+    Language.Haskell.Brittany.Internal.PreludeUtils
+    Language.Haskell.Brittany.Internal.Transformations.Alt
+    Language.Haskell.Brittany.Internal.Transformations.Columns
+    Language.Haskell.Brittany.Internal.Transformations.Floating
+    Language.Haskell.Brittany.Internal.Transformations.Indent
+    Language.Haskell.Brittany.Internal.Transformations.Par
+    Language.Haskell.Brittany.Internal.Types
+    Language.Haskell.Brittany.Internal.Utils
+    Language.Haskell.Brittany.Main
+    Paths_brittany
 
 executable brittany
-  if flag(brittany-dev-lib) {
-    buildable: False
-  } else {
-    buildable: True
-  }
-  main-is:             Main.hs
-  -- other-modules:       
-  -- other-extensions:    
+  import: executable
+
+  hs-source-dirs: source/executable
+  main-is: Main.hs
+
+test-suite brittany-test-suite
+  import: executable
+
   build-depends:
-    { brittany
-    , base >=4.9 && <4.10
-    , ghc
-    , ghc-paths
-    , ghc-exactprint
-    , transformers
-    , containers
-    , mtl
-    , text
-    , multistate
-    , syb
-    , neat-interpolation
-    , hspec
-    , data-tree-print
-    , pretty
-    , bytestring
-    , directory
-    , lens
-    , butcher
-    , yaml
-    , extra
-    , uniplate
-    , strict
-    , monad-memo
-    , safe
-    , filepath >=1.4.1.0 && <1.5
-    , either
-    , ghc-boot-th
-    }
-  hs-source-dirs:      src-brittany
-  default-language:    Haskell2010
-  default-extensions: {
-    CPP
-
-    NoImplicitPrelude
-
-    GADTs
-
-    FlexibleContexts
-    FlexibleInstances
-    ScopedTypeVariables
-    MonadComprehensions
-    LambdaCase
-    MultiWayIf
-    KindSignatures
-  }
-  ghc-options: {
-    -Wall
-    -fprof-auto -fprof-cafs -fno-spec-constr
-    -j
-    -fno-warn-unused-imports
-    -fno-warn-orphans
-    -rtsopts
-    -with-rtsopts "-M2G"
-  }
-  if flag(brittany-dev) {
-    ghc-options: -O0 -Werror -fobject-code
-  }
-
-test-suite unittests
-  if flag(brittany-dev-lib) {
-    buildable: False
-  } else {
-    buildable: True
-  }
-  type:             exitcode-stdio-1.0
-  default-language: Haskell2010
-  build-depends:
-    { brittany
-    , base >=4.9 && <4.10
-    , ghc
-    , ghc-paths
-    , ghc-exactprint
-    , transformers
-    , containers
-    , mtl
-    , text
-    , multistate
-    , syb
-    , neat-interpolation
-    , hspec
-    , data-tree-print
-    , pretty
-    , bytestring
-    , directory
-    , lens
-    , butcher
-    , yaml
-    , extra
-    , uniplate
-    , strict
-    , monad-memo
-    , safe
-    , either
-    }
-  ghc-options:      -Wall
-  main-is:          TestMain.hs
-  other-modules:    IdentityTests
-                    TestUtils
-                    AsymptoticPerfTests
-  hs-source-dirs:   src-unittests
-  default-extensions: {
-    CPP
-
-    NoImplicitPrelude
-
-    GADTs
-
-    FlexibleContexts
-    FlexibleInstances
-    ScopedTypeVariables
-    MonadComprehensions
-    LambdaCase
-    MultiWayIf
-    KindSignatures
-  }
-  ghc-options: {
-    -Wall
-    -j
-    -fno-warn-unused-imports
-    -fno-warn-orphans
-    -rtsopts
-    -with-rtsopts "-M2G"
-  }
-  if flag(brittany-dev) {
-    ghc-options: -O0 -Werror -fobject-code
-  }
+    , hspec ^>= 2.8.3
+  hs-source-dirs: source/test-suite
+  main-is: Main.hs
+  type: exitcode-stdio-1.0

brittany.yaml

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

cabal.project

@@ -0,0 +1,9 @@
+packages: .
+
+allow-newer:
+    -- https://github.com/lspitzner/butcher/issues/7
+    , butcher:base
+    -- https://github.com/lspitzner/data-tree-print/pull/2
+    , data-tree-print:base
+    -- https://github.com/lspitzner/multistate/pull/8
+    , multistate:base

data/Test1.hs

@@ -0,0 +1 @@
+func :: a -> a

data/Test10.hs

@@ -0,0 +1,3 @@
+func
+  :: lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+  -> (lakjsdlkjasldkj -> lakjsdlkjasldkj)

data/Test100.hs

@@ -0,0 +1 @@
+func = klajsdas klajsdas klajsdas

data/Test101.hs

@@ -0,0 +1,3 @@
+func = lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd
+  lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd
+  lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd

data/Test102.hs

@@ -0,0 +1,3 @@
+func = lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd lakjsdlajsdljas
+                                                     lakjsdlajsdljas
+                                                     lakjsdlajsdljas

data/Test103.hs

@@ -0,0 +1 @@
+func = (1 +)

data/Test104.hs

@@ -0,0 +1 @@
+func = (+ 1)

data/Test105.hs

@@ -0,0 +1 @@
+func = (1 `abc`)

data/Test106.hs

@@ -0,0 +1 @@
+func = (`abc` 1)

data/Test107.hs

@@ -0,0 +1 @@
+func = (abc, def)

data/Test108.hs

@@ -0,0 +1 @@
+func = (abc, )

data/Test109.hs

@@ -0,0 +1 @@
+func = (, abc)

data/Test11.hs

@@ -0,0 +1,3 @@
+func
+  :: (lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd -> lakjsdlkjasldkj)
+  -> lakjsdlkjasldkj

data/Test110.hs

@@ -0,0 +1,6 @@
+myTupleSection =
+  ( verylaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaargefirstelement
+  ,
+  , verylaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaargethirdelement
+  ,
+  )

data/Test111.hs

@@ -0,0 +1,4 @@
+func =
+  ( lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd
+  , lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd
+  )

data/Test112.hs

@@ -0,0 +1,6 @@
+foo = if True
+  then
+      -- iiiiii
+    "a                                                                         "
+  else
+    "b                                                                         "

data/Test113.hs

@@ -0,0 +1,5 @@
+func = if cond
+  then pure 42
+  else do
+    -- test
+    abc

data/Test114.hs

@@ -0,0 +1,3 @@
+func = case x of
+  False -> False
+  True  -> True

data/Test115.hs

@@ -0,0 +1,7 @@
+func =
+  case
+      lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd
+        lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd
+    of
+      False -> False
+      True  -> True

data/Test116.hs

@@ -0,0 +1,7 @@
+func = do
+  case
+      lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd
+        lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd
+    of
+      False -> False
+      True  -> True

data/Test117.hs

@@ -0,0 +1 @@
+func = case x of {}

data/Test118.hs

@@ -0,0 +1,5 @@
+func =
+  case
+      lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd
+        lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd
+    of {}

data/Test119.hs

@@ -0,0 +1,5 @@
+func = do
+  case
+      lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd
+        lakjsdlajsdljasdlkjasldjasldjasldjalsdjlaskjd
+    of {}

data/Test12.hs

@@ -0,0 +1,5 @@
+func
+  :: (  lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+     -> lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+     )
+  -> lakjsdlkjasldkj

data/Test120.hs

@@ -0,0 +1,3 @@
+func = do
+  stmt
+  stmt

data/Test121.hs

@@ -0,0 +1,3 @@
+func = do
+  x <- stmt
+  stmt x

data/Test122.hs

@@ -0,0 +1,3 @@
+func = do
+  let x = 13
+  stmt x

data/Test123.hs

@@ -0,0 +1,7 @@
+func =
+  foooooo
+    $ [ case
+          foooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
+        of
+          _ -> True
+      ]

data/Test124.hs

@@ -0,0 +1,4 @@
+testMethod foo bar baz qux =
+  let x = undefined foo bar baz qux qux baz bar :: String
+  -- some comment explaining the in expression
+  in  undefined foo x :: String

data/Test125.hs

@@ -0,0 +1,4 @@
+testMethod foo bar baz qux =
+  let x = undefined :: String
+  -- some comment explaining the in expression
+  in  undefined :: String

data/Test126.hs

@@ -0,0 +1,3 @@
+testMethod foo bar baz qux =
+  -- some comment explaining the in expression
+  let x = undefined :: String in undefined :: String

data/Test127.hs

@@ -0,0 +1,6 @@
+foo foo bar baz qux =
+  let a = 1
+      b = 2
+      c = 3
+  -- some comment explaining the in expression
+  in  undefined :: String

data/Test128.hs

@@ -0,0 +1,6 @@
+func =
+  foo
+    $  [ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+       , bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
+       ]
+    ++ [ccccccccccccccccccccccccccccccccccccccccccccccccccccccccc]

data/Test129.hs

@@ -0,0 +1 @@
+module Main where

data/Test13.hs

@@ -0,0 +1,5 @@
+func
+  :: ( (  lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       -> lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       )
+     )

data/Test130.hs

@@ -0,0 +1 @@
+module Main () where

data/Test131.hs

@@ -0,0 +1 @@
+module Main (main) where

data/Test132.hs

@@ -0,0 +1 @@
+module Main (main, test1, test2) where

data/Test133.hs

@@ -0,0 +1,12 @@
+module Main
+  ( main
+  , test1
+  , test2
+  , test3
+  , test4
+  , test5
+  , test6
+  , test7
+  , test8
+  , test9
+  ) where

data/Test134.hs

@@ -0,0 +1,12 @@
+module Main
+  ( main
+  -- main
+  , test1
+  , test2
+  -- Test 3
+  , test3
+  , test4
+  -- Test 5
+  , test5
+  -- Test 6
+  ) where

data/Test135.hs

@@ -0,0 +1 @@
+module Main (Test(..)) where

data/Test136.hs

@@ -0,0 +1 @@
+module Main (module Main) where

data/Test137.hs

@@ -0,0 +1 @@
+module Main (Test(Test, a, b)) where

data/Test138.hs

@@ -0,0 +1,6 @@
+-- comment1
+module Main
+  ( Test(Test, a, b)
+  , foo -- comment2
+  ) -- comment3
+    where

data/Test139.hs

@@ -0,0 +1 @@
+module Main (Test()) where

data/Test14.hs

@@ -0,0 +1 @@
+func :: asd -> Either a b

data/Test140.hs

@@ -0,0 +1 @@
+-- Intentionally left empty

data/Test141.hs

@@ -0,0 +1 @@
+import           Data.List

data/Test142.hs

@@ -0,0 +1 @@
+import           Data.List                               as L

data/Test143.hs

@@ -0,0 +1 @@
+import qualified Data.List

data/Test144.hs

@@ -0,0 +1 @@
+import qualified Data.List                               as L

data/Test145.hs

@@ -0,0 +1 @@
+import safe      Data.List                               as L

data/Test146.hs

@@ -0,0 +1 @@
+import {-# SOURCE #-} Data.List                           ( )

data/Test147.hs

@@ -0,0 +1 @@
+import safe qualified Data.List

data/Test148.hs

@@ -0,0 +1 @@
+import {-# SOURCE #-} safe qualified Data.List

data/Test149.hs

@@ -0,0 +1 @@
+import qualified "base" Data.List

data/Test15.hs

@@ -0,0 +1,5 @@
+func
+  :: asd
+  -> Either
+       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd

data/Test150.hs

@@ -0,0 +1,3 @@
+import {-# SOURCE #-} safe qualified "base" Data.List    as L
+import {-# SOURCE #-} safe qualified "base" Data.List     ( )
+import {-# SOURCE #-} safe qualified Data.List     hiding ( )

data/Test151.hs

@@ -0,0 +1 @@
+import qualified Data.List                                ( )

data/Test152.hs

@@ -0,0 +1 @@
+import           Data.List                                ( nub )

data/Test153.hs

@@ -0,0 +1,4 @@
+import           Data.List                                ( foldl'
+                                                          , indexElem
+                                                          , nub
+                                                          )

data/Test154.hs

@@ -0,0 +1,14 @@
+import           Test                                     ( Long
+                                                          , anymore
+                                                          , fit
+                                                          , items
+                                                          , line
+                                                          , list
+                                                          , not
+                                                          , onA
+                                                          , quite
+                                                          , single
+                                                          , that
+                                                          , will
+                                                          , with
+                                                          )

data/Test155.hs

@@ -0,0 +1,11 @@
+import           Test                                     ( (+)
+                                                          , (:!)(..)
+                                                          , (:*)((:.), T7, t7)
+                                                          , (:.)
+                                                          , T
+                                                          , T2()
+                                                          , T3(..)
+                                                          , T4(T4)
+                                                          , T5(T5, t5)
+                                                          , T6((<|>))
+                                                          )

data/Test156.hs

@@ -0,0 +1,3 @@
+import           Test                              hiding ( )
+import           Test                                    as T
+                                                   hiding ( )

data/Test157.hs

@@ -0,0 +1,13 @@
+import           Prelude                                 as X
+                                                   hiding ( head
+                                                          , init
+                                                          , last
+                                                          , maximum
+                                                          , minimum
+                                                          , pred
+                                                          , read
+                                                          , readFile
+                                                          , succ
+                                                          , tail
+                                                          , undefined
+                                                          )

data/Test158.hs

@@ -0,0 +1,3 @@
+import           TestJustAbitToLongModuleNameLikeThisOneIs
+                                                          ( )
+import           TestJustShortEnoughModuleNameLikeThisOne ( )

data/Test159.hs

@@ -0,0 +1,3 @@
+import           TestJustAbitToLongModuleNameLikeThisOneI
+                                                         as T
+import           TestJustShortEnoughModuleNameLikeThisOn as T

data/Test16.hs

@@ -0,0 +1,6 @@
+func
+  :: asd
+  -> Trither
+       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd

data/Test160.hs

@@ -0,0 +1,3 @@
+import           TestJustAbitToLongModuleNameLikeTh
+                                                   hiding ( )
+import           TestJustShortEnoughModuleNameLike hiding ( )

data/Test161.hs

@@ -0,0 +1,10 @@
+import           MoreThanSufficientlyLongModuleNameWithSome
+                                                          ( compact
+                                                          , fit
+                                                          , inA
+                                                          , items
+                                                          , layout
+                                                          , not
+                                                          , that
+                                                          , will
+                                                          )

data/Test162.hs

@@ -0,0 +1,11 @@
+import           TestJustAbitToLongModuleNameLikeTh
+                                                   hiding ( abc
+                                                          , def
+                                                          , ghci
+                                                          , jklm
+                                                          )
+import           TestJustShortEnoughModuleNameLike hiding ( abc
+                                                          , def
+                                                          , ghci
+                                                          , jklm
+                                                          )

data/Test163.hs

@@ -0,0 +1,9 @@
+import {-# SOURCE #-} safe qualified "qualifier" A hiding ( )
+import {-# SOURCE #-} safe qualified "qualifiers" A
+                                                   hiding ( )
+import {-# SOURCE #-} safe qualified "qualifiers" AlsoAf as T
+import {-# SOURCE #-} safe qualified "qualifiers" AlsoAff ( )
+import {-# SOURCE #-} safe qualified "qualifiers" AlsoAff
+                                                         as T
+import {-# SOURCE #-} safe qualified "qualifiers" AlsoAffe
+                                                          ( )

data/Test164.hs

@@ -0,0 +1,7 @@
+-- Test
+import           Data.List                                ( nub ) -- Test
+{- Test -}
+import qualified Data.List                               as L
+                                                          ( foldl' ) {- Test -}
+-- Test
+import           Test                                     ( test )

data/Test165.hs

@@ -0,0 +1,4 @@
+import           Test                                     ( abc
+                                                          , def
+                                                          -- comment
+                                                          )

data/Test166.hs

@@ -0,0 +1,3 @@
+import           Test                                     ( abc
+                                                          -- comment
+                                                          )

data/Test167.hs

@@ -0,0 +1,8 @@
+import           Test                                     ( abc
+                                                          -- comment
+                                                          , def
+                                                          , ghi
+                                                          {- comment -}
+                                                          , jkl
+                                                          -- comment
+                                                          )

data/Test168.hs

@@ -0,0 +1,2 @@
+import           Test                                     ( -- comment
+                                                          )

data/Test169.hs

@@ -0,0 +1,8 @@
+import           Test                                     ( longbindingNameThatoverflowsColum
+                                                          )
+import           Test                                     ( Long
+                                                            ( List
+                                                            , Of
+                                                            , Things
+                                                            )
+                                                          )

data/Test17.hs

@@ -0,0 +1,6 @@
+func
+  :: Trither
+       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+       lkasdlkjalsdjlakjsdlkjasldkjalskdjlkajsd
+  -> asd

data/Test170.hs

@@ -0,0 +1,18 @@
+import           Test                                     ( Thing
+                                                            ( -- Comments
+                                                            )
+                                                          )
+import           Test                                     ( Thing
+                                                            ( Item
+                                                            -- and Comment
+                                                            )
+                                                          )
+import           Test                                     ( Thing
+                                                            ( With
+                                                            -- Comments
+                                                            , and
+                                                            -- also
+                                                            , items
+                                                            -- !
+                                                            )
+                                                          )

data/Test171.hs

@@ -0,0 +1,2 @@
+import           VeryLongModuleNameThatCouldEvenCauseAnEmptyBindingListToExpandIntoMultipleLine
+                                                          ( )

data/Test172.hs

@@ -0,0 +1,26 @@
+{-# LANGUAGE BangPatterns #-}
+{-
+ - Test module
+ -}
+module Test
+  ( test1
+  -- ^ test
+  , test2
+  -- | test
+  , test3
+  , test4
+  , test5
+  , test6
+  , test7
+  , test8
+  , test9
+  , test10
+  -- Test 10
+  ) where
+-- Test
+import           Data.List                                ( nub ) -- Test
+{- Test -}
+import qualified Data.List                               as L
+                                                          ( foldl' ) {- Test -}
+-- Test
+import           Test                                     ( test )

data/Test173.hs

@@ -0,0 +1,2 @@
+import           Aaa
+import           Baa

data/Test174.hs

@@ -0,0 +1,5 @@
+import           Zaa
+import           Zab
+
+import           Aaa
+import           Baa

data/Test175.hs

@@ -0,0 +1,2 @@
+import           Boo
+import qualified Zoo

data/Test176.hs

@@ -0,0 +1,3 @@
+import           Boo                                      ( a )
+
+import           Boo                                      ( b )