hindent 5.3.4 → 6.0.0

raw patch · 48 files changed

+10183/−5354 lines, 48 filesdep +ghc-lib-parserdep +ghc-lib-parser-exdep +regex-tdfadep −ghc-primdep −haskell-src-extsdep −unix-compatdep ~basedep ~mtlsetup-changedPVP ok

version bump matches the API change (PVP)

Dependencies added: ghc-lib-parser, ghc-lib-parser-ex, regex-tdfa, split, syb, unicode-show

Dependencies removed: ghc-prim, haskell-src-exts, unix-compat

Dependency ranges changed: base, mtl

API changes (from Hackage documentation)

Files

• CHANGELOG.md +337/−102
• README.md +22/−14
• Setup.hs +1/−0
• TESTS.md +3328/−1807
• app/Main.hs +150/−0
• benchmarks/Main.hs +47/−0
• hindent.cabal +247/−100
• internal/HIndent/Internal/Test/Markdone.hs +133/−0
• src/HIndent.hs +118/−378
• src/HIndent/Applicative.hs +11/−0
• src/HIndent/CabalFile.hs +59/−74
• src/HIndent/CodeBlock.hs +14/−6
• src/HIndent/Config.hs +81/−0
• src/HIndent/Language.hs +23/−0
• src/HIndent/LanguageExtension.hs +121/−0
• src/HIndent/LanguageExtension/Conversion.hs +58/−0
• src/HIndent/LanguageExtension/Types.hs +18/−0
• src/HIndent/ModulePreprocessing.hs +222/−0
• src/HIndent/ModulePreprocessing/CommentRelocation.hs +336/−0
• src/HIndent/Parse.hs +84/−0
• src/HIndent/Path/Find.hs +40/−0
• src/HIndent/Pragma.hs +64/−0
• src/HIndent/Pretty.hs +2239/−2151
• src/HIndent/Pretty/Combinators.hs +24/−0
• src/HIndent/Pretty/Combinators/Comment.hs +12/−0
• src/HIndent/Pretty/Combinators/Getter.hs +31/−0
• src/HIndent/Pretty/Combinators/Indent.hs +67/−0
• src/HIndent/Pretty/Combinators/Lineup.hs +246/−0
• src/HIndent/Pretty/Combinators/Op.hs +24/−0
• src/HIndent/Pretty/Combinators/Outputable.hs +36/−0
• src/HIndent/Pretty/Combinators/RhsSeparator.hs +16/−0
• src/HIndent/Pretty/Combinators/String.hs +78/−0
• src/HIndent/Pretty/Combinators/Switch.hs +25/−0
• src/HIndent/Pretty/Combinators/Wrap.hs +85/−0
• src/HIndent/Pretty/Import.hs +46/−0
• src/HIndent/Pretty/Import/Sort.hs +125/−0
• src/HIndent/Pretty/NodeComments.hs +873/−0
• src/HIndent/Pretty/Pragma.hs +61/−0
• src/HIndent/Pretty/SigBindFamily.hs +73/−0
• src/HIndent/Pretty/Types.hs +336/−0
• src/HIndent/Printer.hs +52/−0
• src/HIndent/Types.hs +0/−143
• src/main/Benchmark.hs +0/−47
• src/main/Main.hs +0/−127
• src/main/Markdone.hs +0/−130
• src/main/Path/Find.hs +0/−98
• src/main/Test.hs +0/−177
• tests/Main.hs +220/−0

@@ -1,136 +1,371 @@-5.3.0:-    * Handle multiple deriving clauses in a DerivingStrategies scenario-    * Ignore non-files in findCabalFiles-    * Allow batch processing of multiple files-    * Prevent hindent from trying to open non-files when searching for-      .cabal files-    * Specify default extensions in configuration file-    * Fix bad output for [p|Foo|] pattern quasi-quotes-    * Parse C preprocessor line continuations-    * Fix pretty printing of '(:)-    * Add parens around symbols (:|) when required-    * Support $p pattern splices-    * Fix associated type families-    * Non-dependent record constructor formatting+# Changelog -5.2.7:-    * Fix -X option bug+## [Unreleased] -5.2.6:-    * Switch to optparse-applicative+### Added -5.2.5:+- ... -    * Support get extensions from `.cabal` file-    * Improve indention with record constructions and updates-    * Fix `let ... in` bug-    * Fix top-level lambda expressions in TemplateHaskell slices-    * Update to haskell-src-exts dependency to version `>= 1.20.0`+### Changed -5.2.4:+- ... -    * Pretty print imports-    * Fix pretty print for string literals for `DataKinds`-    * Support `--validate` option for checking the format without reformatting-    * Support parse `#include`, `#error`, `#warning` directives-    * Support read `LANGUAGE` pragma and parse the declared extensions from source-    * Treat `TypeApplications` extension as 'badExtensions' due to the `@` symbol-    * Improve pretty print for unboxed tuples-    * Fix many issues related to infix operators, includes TH name quotes,-      `INLINE`/`NOINLINE` pragmas, infix type operator and infix constructor-    * Fix pretty print for operators in `INLINE`/`NOINLINE` pragmas-    * Support for `EmptyCases` extension-    * Fix TH name quotes on operator names-    * Optimize pretty print for many fundeps-    * Fix extra linebreaks after short identifiers+### Fixed -5.2.3:+- ... -    * Sort explicit import lists-    * Report the `SrcLoc` when there's a parse error-    * Improve long type signatures pretty printing-    * Support custom line-break operators, add `--line-breaks` argument-    * Fix infix data constructor-    * Disable `RecursiveDo` and `DoRec` extensions by default-    * Add RecStmt support-    * Improve GADT records, data declaration records-    * Complicated type alias and type signatures pretty printing-    * Fix quasi-quoter names+### Removed -5.2.2:+- ... -    * Parallel list comprehensions-    * Leave do, lambda, lambda-case on previous line of $-    * Misc fixes+## [6.0.0] - 2023-02-20 -5.2.1:+### Added -    * Fix hanging on large constraints-    * Render multi-line comments-    * Rename --tab-size to --indent-size-    * Don't add a spurious space for comments at the end of the file-    * Don't add trailing whitespace on <--    * Disable PatternSynonyms-    * Put a newline before the closing bracket on a list+- The getConfig function is exported. -5.2.0:+### Changed -    * Default tab-width is now 2-    * Supports .hindent.yaml file to specify alt tab-width and max-      column-    * Put last paren of export list on a new line-    * Implement tab-size support in Emacs Lisp+- Switched the parser from [`haskell-src-exts`] to [`ghc-lib-parser`].+  This switch causes changes in the formatting results in some cases.+- Changed how to format a data type with a record constructor to follow+  the [Johan Tibell's Haskell Style Guide]. ([#662]).+- A newline is no longer inserted after a pattern signature ([#663]).+- A type with many type applications are now broken into multiple lines.+  ([#664]).+- A long type-level list is broken into multiple lines. ([#665]).+- Spaces around typed expression brackets are removed ([#666]).+- HIndent no longer breaks short class constraints in function signautres into+  multiple lines ([#669]). -5.1.1:+### Fixed -    * Preserve spaces between groups of imports (fixes #200)-    * Support shebangs (closes #208)-    * Output filename for parse errors (fixes #179)-    * Input with newline ends with newline (closes #211)-    * Document -X (closes #212)-    * Fix explicit forall in instances (closes #218)-    * Put last paren of export list on a new line #227+- Fixed the wrong formatting of data family instances inside class instances+  ([#667]).+- Fixed the bug of removing the space before the enclosing parenthesis of a+  record syntax in a signature in a GADT declaration ([#670]).+- Fixed the bug of inserting unnecessary empty lines if a file contains only+  comments ([#672]). -5.1.0:+### Removed -    * Rewrote comment association, more reliable-    * Added --tab-size flag for indentation spaces-    * Fixed some miscellaneous bugs+- Test functions except `testAst`.+- Atom support ([#671]). -5.0.1:+## [5.3.4] - 2022-07-07 -    * Re-implement using bytestring instead of text-    * Made compatible with GHC 7.8 through to GHC 8.0-    * Added test suite and benchmarks in TESTS.md and BENCHMARKS.md+This version is accidentally pushlished, and is the same as 5.3.3. -5.0.0:+## [5.3.3] - 2022-07-07 -	* Drop support for styles+### Added -4.6.4+- Support for GHC 9.2.2.+- Test CI with GitHub Actions (WIP). -	* Copy/delete file instead of renaming+### Fixed -4.4.6+- Fixed a broken link to Servant by [@mattfbacon] in [#579].+- Fixed a build with Cabal 3.6 by [@uhbif19] in [#584].+- Fixed a compile error for GHC 9.2.2 by [@toku-sa-n] in [#588]. -	* Fix whole module printer-	* Accept a filename to reformat+## [5.3.2] - 2022-02-02 -4.4.5+### Fixed -	* Fix bug in infix patterns+- `MonadFix` issues to support newer GHC versions. -4.4.2+## [5.3.1] - 2019-06-28 -	* Bunch of Gibiansky style fixes.-	* Support CPP.-	* Tibell style fixes.+### Fixed -4.3.8+- Comment relocations in where clauses of top-level function declarations. -	* Fixed: bug in printing operators in statements.+## [5.3.0] - 2019-04-29 -4.5.4+### Added -	* Improvements to Tibell style.-	* 6x speed up on rendering operators.+- Allow batch processing of multiple files.+- You can now specify default extensions in the configuration file.++### Fixed++- Handle multiple deriving clauses in the `DerivingStrategies` scenario.+- Ignore non-files in `findCabalFiles`.+- Prevent HIndent from trying to open non-files when searching for `.cabal` files.+- Fix the bad output for `[p|Foo|]` pattern quasi-quotes.+- Fix pretty-printing of `'(:)`.+- Fix parsing C preprocessor line continuations.+- Add parentheses around symbols `(:|)` when required.+- Support `$p` pattern splices.+- Fix formatting of associated type families.+- Fix formatting of non-dependent record constructors.++## [5.2.7] - 2019-03-16++### Fixed++- A bug in the `-X` option++## [5.2.6] - 2019-03-16++### Changed++- Switched to [`optparse-applicative`].++## [5.2.5] - 2018-01-04++### Added++- Support getting extensions from a `.cabal` file++### Changed++- Improved the indentation with record constructions and updates+- Updated [`haskell-src-exts`] dependency to version `>= 1.20.0`++### Fixed++- Fix the `let ... in` bug+- Fix formatting top-level lambda expressions in `TemplateHaskell` slices++## [5.2.4] - 2017-10-20++### Added++- Improved pretty-printing unboxed tuples.+- Support the `--validate` option for checking the format without reformatting+- Support parsing `#include`, `#error`, and `#warning` directives.+- Support reading `LANGUAGE` pragmas and parse the declared extensions from sources.+- Support the `EmptyCases` extension+- Optimize pretty-printing for many functional dependencies.++### Changed++- The `TypeApplications` extension is now disabled-by-default due to the `@` symbol++### Fixed++- Fixed pretty-printing imports+- Fixed pretty-printing string literals for `DataKinds`+- Fixed many issues related to infix operators including TH name quotes,+  `INLINE`/`NOINLINE` pragmas, infix type operators, and infix constructors.+- Fix extra linebreaks after short identifiers.++## [5.2.3] - 2017-05-07++### Added++- HIndent now reports where a parse happened.+- Added `--line-breaks` parameter to support custom line breaks.+- Added the `RecStmt` support++### Changed++- Explicit import lists are now sorted.+- Improved pretty-printing long type signatures.+- Improved pretty-printing GADT records.+- Improved pretty-printing data declaration records.+- The `RecursiveDo` and `DoRec` extensions are now disabled-by-default.++## Fixed++- Fixed pretty-printing for infix data constructors.+- Fixed pretty-printing of quasi-quoter names.+- Fixed pretty-printing of complicated type aliases.+- Fixed pretty-printing of complicated type signatures.++## [5.2.2] - 2017-01-16++### Changed++- HIndent now leaves `do`, lambda (`\x->`), and lambda-case (`\case->`) on the previous line of `$`.++### Fixed++- Fixed pretty-printing of parallel list comprehensions.+- Miscellaneous fixes.++## [5.2.1] - 2016-09-01++### Changed++- The `--tab-size` option is renamed to `--indent-size`.+- The `PatternSynonyms` extension is now disabled by default.+- HIndent now puts a newline before the closing bracket on a list.++### Fixed++- Fixed handling of paragraph overhang when using large constraints.+- Fixed pretty-printing of multi-line comments.+- Fixed bug resulting in adding a spurious space for comments at the end of a file.+- Fixed bug which results in adding a trailing white space on `<-`++## [5.2.0] - 2016-08-30++### Added++- Support the `.hindent.yaml` file to specify alternative tab width and max+  column numbers.+- Implement the tab-size support in Emacs Lisp.++### Changed++- The default number of spaces for a tab is changed to 2.++## [5.1.1] - 2016-08-29++### Added++- Add shebang support (Fixes [#208]).+- Output the filename for parse errors (Fixes [#179]).+- Added a document of the `-X` option (Fixes [#212]).++### Changed++- HIndent now preserves spaces between groups of imports (Fixes [#200]).+- HIndent now preserves the last newline if the input ends with one (Fixes [#211]).+- HIndent now puts the last parenthesis of an export list on a new line (Fixes [#227]).++### Fixed++- Fixed pretty-printing explicit `forall`s in instances (Fixes [#218]).++## [5.1.0] - 2016-08-25++### Added++- Add `--tab-size` parameter to control indentation spaces.++### Changed++- Rewrote comment association for more reliability.++### Fixed++- Some miscellaneous bugs.++## [5.0.1] - 2016-08-20++### Added++- Made HIndent compatible with GHC 7.8 through GHC 8.0+- Added test suites and benchmarks in [`TESTS.md`] and [`BENCHMARKS.md`]++### Changed++- Re-implement using [`bytestring`] instead of [`text`]++## [5.0.0] - 2016-08-11++### Removed++- Support for styles++## [4.6.4] - 2016-07-15++### Changed++- The formatted file is now created by coping/deleting a file instead of renaming.++## [4.6.3] - 2016-04-18++### Added++- Accept a filename to reformat.++### Fixed++- Fixed the whole module printer.++## [4.5.4] - 2015-06-22++### Added++- Improvements to Tibell style.+- 6x speed up on rendering operators.++## [4.4.5] - 2015-11-10++### Fixed++- Fixed a bug in infix patterns.++## [4.4.2] - 2015-04-05++### Added++- Support for CPP.++### Fixed++- Bunch of Gibiansky style bugs.+- Tibell style bugs.++## [4.3.8] - 2015-02-06++### Fixed++- A bug in printing operators in statements.++[unreleased]: https://github.com/mihaimaruseac/hindent/compare/v6.0.0...HEAD+[6.0.0]: https://github.com/mihaimaruseac/hindent/compare/v5.3.4...v6.0.0+[5.3.4]: https://github.com/mihaimaruseac/hindent/compare/v5.3.3...v5.3.4+[5.3.3]: https://github.com/mihaimaruseac/hindent/compare/v5.3.2...v5.3.3+[5.3.2]: https://github.com/mihaimaruseac/hindent/compare/5.3.1...v5.3.2+[5.3.1]: https://github.com/mihaimaruseac/hindent/compare/5.3.0...5.3.1+[5.3.0]: https://github.com/mihaimaruseac/hindent/compare/5.2.7...5.3.0+[5.2.7]: https://github.com/mihaimaruseac/hindent/compare/5.2.6...5.2.7+[5.2.6]: https://github.com/mihaimaruseac/hindent/compare/5.2.5...5.2.6+[5.2.5]: https://github.com/mihaimaruseac/hindent/compare/5.2.4...5.2.5+[5.2.4]: https://github.com/mihaimaruseac/hindent/compare/5.2.3...5.2.4+[5.2.3]: https://github.com/mihaimaruseac/hindent/compare/5.2.2...5.2.3+[5.2.2]: https://github.com/mihaimaruseac/hindent/compare/5.2.1...5.2.2+[5.2.1]: https://github.com/mihaimaruseac/hindent/compare/5.2.0...5.2.1+[5.2.0]: https://github.com/mihaimaruseac/hindent/compare/5.1.1...5.2.0+[5.1.1]: https://github.com/mihaimaruseac/hindent/compare/5.1.0...5.1.1+[5.1.0]: https://github.com/mihaimaruseac/hindent/compare/5.0.1...5.1.0+[5.0.1]: https://github.com/mihaimaruseac/hindent/compare/5.0.0...5.0.1+[5.0.0]: https://github.com/mihaimaruseac/hindent/compare/4.6.4...5.0.0+[4.6.4]: https://github.com/mihaimaruseac/hindent/compare/4.6.3...4.6.4+[4.6.3]: https://github.com/mihaimaruseac/hindent/compare/4.6.2...4.6.3+[4.5.4]: https://github.com/mihaimaruseac/hindent/compare/4.5.3...4.5.4+[4.4.5]: https://github.com/mihaimaruseac/hindent/compare/4.4.4...4.4.5+[4.4.2]: https://github.com/mihaimaruseac/hindent/compare/4.4.1...4.4.2+[4.3.8]: https://github.com/mihaimaruseac/hindent/compare/4.3.7...4.3.8++[@mattfbacon]: https://github.com/mattfbacon+[@uhbif19]: https://github.com/uhbif19+[@toku-sa-n]: https://github.com/toku-sa-n++[#672]: https://github.com/mihaimaruseac/hindent/pull/672+[#671]: https://github.com/mihaimaruseac/hindent/pull/671+[#670]: https://github.com/mihaimaruseac/hindent/pull/670+[#669]: https://github.com/mihaimaruseac/hindent/pull/669+[#667]: https://github.com/mihaimaruseac/hindent/pull/667+[#666]: https://github.com/mihaimaruseac/hindent/pull/666+[#665]: https://github.com/mihaimaruseac/hindent/pull/665+[#664]: https://github.com/mihaimaruseac/hindent/pull/664+[#663]: https://github.com/mihaimaruseac/hindent/pull/663+[#662]: https://github.com/mihaimaruseac/hindent/pull/662+[#588]: https://github.com/mihaimaruseac/hindent/pull/588+[#584]: https://github.com/mihaimaruseac/hindent/pull/584+[#579]: https://github.com/mihaimaruseac/hindent/pull/579+[#227]: https://github.com/mihaimaruseac/hindent/pull/227+[#218]: https://github.com/mihaimaruseac/hindent/pull/218+[#212]: https://github.com/mihaimaruseac/hindent/pull/212+[#211]: https://github.com/mihaimaruseac/hindent/pull/211+[#208]: https://github.com/mihaimaruseac/hindent/pull/208+[#200]: https://github.com/mihaimaruseac/hindent/pull/200+[#179]: https://github.com/mihaimaruseac/hindent/pull/179++[`haskell-src-exts`]: https://hackage.haskell.org/package/haskell-src-exts+[`ghc-lib-parser`]: https://hackage.haskell.org/package/ghc-lib-parser+[`optparse-applicative`]: https://hackage.haskell.org/package/optparse-applicative+[`bytestring`]: https://hackage.haskell.org/package/bytestring+[`text`]: https://hackage.haskell.org/package/text++[`TESTS.md`]: TESTS.md+[`BENCHMARKS.md`]: BENCHMARKS.md++[Johan Tibell's Haskell Style Guide]: https://github.com/tibbe/haskell-style-guide/blob/master/haskell-style.md

@@ -1,5 +1,6 @@-# hindent [![Hackage](https://img.shields.io/hackage/v/hindent.svg?style=flat)](https://hackage.haskell.org/package/hindent) ![CI (Stack)](https://github.com/mihaimaruseac/hindent/workflows/CI%20(Stack)/badge.svg) ![CI (Cabal)](https://github.com/mihaimaruseac/hindent/workflows/CI%20(Cabal)/badge.svg)+# hindent [![Hackage](https://img.shields.io/hackage/v/hindent.svg?style=flat)](https://hackage.haskell.org/package/hindent) ![CI (Stack)](https://github.com/mihaimaruseac/hindent/workflows/CI%20(Stack)/badge.svg) ![CI (Cabal)](https://github.com/mihaimaruseac/hindent/workflows/CI%20(Cabal)/badge.svg) [![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/mihaimaruseac/hindent/badge)](https://api.securityscorecards.dev/projects/github.com/mihaimaruseac/hindent) + Haskell pretty printer  [Examples](https://github.com/mihaimaruseac/hindent/blob/master/TESTS.md)@@ -11,13 +12,26 @@ ## Usage      $ hindent --help-    hindent --version --help --style STYLE --line-length <...> --indent-size <...> --no-force-newline [-X<...>]* [<FILENAME>]-    Version 5.1.1-    Default --indent-size is 2. Specify --indent-size 4 if you prefer that.-    -X to pass extensions e.g. -XMagicHash etc.-    The --style option is now ignored, but preserved for backwards-compatibility.-    Johan Tibell is the default and only style.+    hindent - Reformat Haskell source code +    Usage: hindent [--version | [--line-length ARG]+                     [--indent-size ARG | --tab-size ARG] [--no-force-newline]+                     [--sort-imports | --no-sort-imports] [--style STYLE]+                     [-X GHCEXT] [--validate] [FILENAMES]]++    Available options:+      --version                Print the version+      --line-length ARG        Desired length of lines (default: 80)+      --indent-size ARG        Indentation size in spaces (default: 2)+      --tab-size ARG           Same as --indent-size, for compatibility+      --no-force-newline       Don't force a trailing newline+      --sort-imports           Sort imports in groups+      --no-sort-imports        Don't sort imports+      --style STYLE            Style to print with (historical, now ignored)+      -X GHCEXT                Language extension+      --validate               Check if files are formatted without changing them+      -h,--help                Show this help text+ hindent is used in a pipeline style      $ cat path/to/sourcefile.hs | hindent@@ -109,16 +123,10 @@ [vim-hindent](https://github.com/alx741/vim-hindent) plugin which runs hindent automatically when a Haskell file is saved. -## Atom--Fortunately, you can use https://atom.io/packages/ide-haskell with the-path to hindent specified instead of that to stylish-haskell. Works-like a charm that way!- ## IntelliJ / other JetBrains IDEs 1. Install the "HaskForce" Haskell plugin (this is so we get the language type recognized in the file watcher) 2. Install the "File Watchers" plugin under "Browse Repositories"-3. Add a File Watcher with +3. Add a File Watcher with     1. File type: Haskell Language     2. Program: `/path/to/hindent`     3. Arguments: `$FilePath$`

@@ -1,2 +1,3 @@ import Distribution.Simple+ main = defaultMain

@@ -1,1808 +1,3329 @@-# Introduction--This file is a test suite. Each section maps to an HSpec test, and-each line that is followed by a Haskell code fence is tested to make-sure re-formatting that code snippet produces the same result.--You can browse through this document to see what HIndent's style is-like, or contribute additional sections to it, or regression tests.--# Modules--Empty module--``` haskell-```--Double shebangs--``` haskell-#!/usr/bin/env stack-#!/usr/bin/env stack-main = pure ()-```--Extension pragmas--```haskell-{-# LANGUAGE TypeApplications #-}--fun @Int 12-```--Module header--``` haskell-module X where--x = 1-```--Exports--``` haskell-module X-  ( x-  , y-  , Z-  , P(x, z)-  ) where-```--Exports, indentation 4--``` haskell 4-module X-    ( x-    , y-    , Z-    , P(x, z)-    ) where-```--# Imports--Import lists--``` haskell-import Data.Text-import Data.Text-import qualified Data.Text as T-import qualified Data.Text (a, b, c)-import Data.Text (a, b, c)-import Data.Text hiding (a, b, c)-```--Sorted--```haskell given-import B-import A-```--```haskell expect-import A-import B-```--Explicit imports - capitals first (typeclasses/types), then operators, then identifiers--```haskell given-import qualified MegaModule as M ((>>>), MonadBaseControl, void, MaybeT(..), join, Maybe(Nothing, Just), liftIO, Either, (<<<), Monad(return, (>>=), (>>)))-```--```haskell expect-import qualified MegaModule as M-  ( Either-  , Maybe(Just, Nothing)-  , MaybeT(..)-  , Monad((>>), (>>=), return)-  , MonadBaseControl-  , (<<<)-  , (>>>)-  , join-  , liftIO-  , void-  )-```--Pretty import specification--```haskell-import A hiding-  ( foobarbazqux-  , foobarbazqux-  , foobarbazqux-  , foobarbazqux-  , foobarbazqux-  , foobarbazqux-  , foobarbazqux-  )--import Name hiding ()--import {-# SOURCE #-} safe qualified Module as M hiding (a, b, c, d, e, f)-```--# Declarations--Type declaration--``` haskell-type EventSource a = (AddHandler a, a -> IO ())-```--Type declaration with infix promoted type constructor--```haskell-fun1 :: Def ('[ Ref s (Stored Uint32), IBool] 'T.:-> IBool)-fun1 = undefined--fun2 :: Def ('[ Ref s (Stored Uint32), IBool] ':-> IBool)-fun2 = undefined-```--Instance declaration without decls--``` haskell-instance C a-```--Instance declaration with decls--``` haskell-instance C a where-  foobar = do-    x y-    k p-```--Symbol class constructor in instance declaration--```haskell-instance Bool :?: Bool--instance (:?:) Int Bool-```--GADT declarations--```haskell-data Ty :: (* -> *) where-  TCon-    :: { field1 :: Int-       , field2 :: Bool}-    -> Ty Bool-  TCon' :: (a :: *) -> a -> Ty a-```--# Expressions--Lazy patterns in a lambda--``` haskell-f = \ ~a -> undefined--- \~a yields parse error on input ‘\~’-```--Bang patterns in a lambda--``` haskell-f = \ !a -> undefined--- \!a yields parse error on input ‘\!’-```--List comprehensions, short--``` haskell-map f xs = [f x | x <- xs]-```--List comprehensions, long--``` haskell-defaultExtensions =-  [ e-  | EnableExtension {extensionField1 = extensionField1} <--      knownExtensions knownExtensions-  , let a = b-    -- comment-  , let c = d-    -- comment-  ]-```--List comprehensions with operators--```haskell-defaultExtensions =-  [e | e@EnableExtension {} <- knownExtensions] \\-  map EnableExtension badExtensions-```--Parallel list comprehension, short--```haskell-zip xs ys = [(x, y) | x <- xs | y <- ys]-```--Parallel list comprehension, long--```haskell-fun xs ys =-  [ (alphaBetaGamma, deltaEpsilonZeta)-  | x <- xs-  , z <- zs-  | y <- ys-  , cond-  , let t = t-  ]-```--Record, short--``` haskell-getGitProvider :: EventProvider GitRecord ()-getGitProvider =-  EventProvider {getModuleName = "Git", getEvents = getRepoCommits}-```--Record, medium--``` haskell-commitToEvent :: FolderPath -> TimeZone -> Commit -> Event.Event-commitToEvent gitFolderPath timezone commit =-  Event.Event-    {pluginName = getModuleName getGitProvider, eventIcon = "glyphicon-cog"}-```--Record, long--``` haskell-commitToEvent :: FolderPath -> TimeZone -> Commit -> Event.Event-commitToEvent gitFolderPath timezone commit =-  Event.Event-    { pluginName = getModuleName getGitProvider-    , eventIcon = "glyphicon-cog"-    , eventDate = localTimeToUTC timezone (commitDate commit)-    }-```--Record with symbol constructor--```haskell-f = (:..?) {}-```--Record with symbol field--```haskell-f x = x {(..?) = wat}--g x = Rec {(..?)}-```--Cases--``` haskell-strToMonth :: String -> Int-strToMonth month =-  case month of-    "Jan" -> 1-    "Feb" -> 2-    _ -> error $ "Unknown month " ++ month-```--Operators, bad--``` haskell-x =-  Value <$> thing <*> secondThing <*> thirdThing <*> fourthThing <*>-  Just thisissolong <*>-  Just stilllonger <*>-  evenlonger-```--Operators, good--```haskell pending-x =-  Value <$> thing <*> secondThing <*> thirdThing <*> fourthThing <*>-  Just thisissolong <*> Just stilllonger <*> evenlonger-```--Operator with `do`--```haskell-for xs $ do-  left x-  right x-```--Operator with lambda--```haskell-for xs $ \x -> do-  left x-  right x-```--Operator with lambda-case--```haskell-for xs $ \case-  Left x -> x-```--Operator in parentheses--```haskell-cat = (++)-```--Symbol data constructor in parentheses--```haskell-cons = (:)--cons' = (:|)-```--n+k patterns--``` haskell-f (n+5) = 0-```--Binary symbol data constructor in pattern--```haskell-f (x :| _) = x--f' ((:|) x _) = x--f'' ((Data.List.NonEmpty.:|) x _) = x--g (x:xs) = x--g' ((:) x _) = x-```--Type application--```haskell-{-# LANGUAGE TypeApplications #-}--fun @Int 12-```--Transform list comprehensions--```haskell-list =-  [ (x, y, map the v)-  | x <- [1 .. 10]-  , y <- [1 .. 10]-  , let v = x + y-  , then group by v using groupWith-  , then take 10-  , then group using permutations-  , t <- concat v-  , then takeWhile by t < 3-  ]-```--Type families--```haskell-type family Id a-```--Type family annotations--``` haskell-type family Id a :: *-```--Type family instances--```haskell-type instance Id Int = Int-```--Type family dependencies--```haskell-type family Id a = r | r -> a-```--Binding implicit parameters--```haskell-f =-  let ?x = 42-   in f-```--Closed type families--```haskell-type family Closed (a :: k) :: Bool where-  Closed x = 'True-```--# Template Haskell--Expression brackets--```haskell-add1 x = [|x + 1|]-```--Pattern brackets--```haskell-mkPat = [p|(x, y)|]-```--Type brackets--```haskell-foo :: $([t|Bool|]) -> a-```--Quoted data constructors--```haskell-cons = '(:)-```--Pattern splices--```haskell-f $pat = ()--g =-  case x of-    $(mkPat y z) -> True-    _ -> False-```--# Type signatures--Long argument list should line break--```haskell-longLongFunction ::-     ReaderT r (WriterT w (StateT s m)) a-  -> StateT s (WriterT w (ReaderT r m)) a-```--Class constraints should leave `::` on same line--``` haskell--- see https://github.com/chrisdone/hindent/pull/266#issuecomment-244182805-fun ::-     (Class a, Class b)-  => fooooooooooo bar mu zot-  -> fooooooooooo bar mu zot-  -> c-```--Class constraints--``` haskell-fun :: (Class a, Class b) => a -> b -> c-```--Symbol class constructor in class constraint--```haskell-f :: (a :?: b) => (a, b)-f' :: ((:?:) a b) => (a, b)-```--Tuples--``` haskell-fun :: (a, b, c) -> (a, b)-```--Quasiquotes in types--```haskell-fun :: [a|bc|]-```--Default signatures--```haskell--- https://github.com/chrisdone/hindent/issues/283-class Foo a where-  bar :: a -> a -> a-  default bar :: Monoid a =>-    a -> a -> a-  bar = mappend-```--Implicit parameters--```haskell-f :: (?x :: Int) => Int-```--Symbol type constructor--```haskell-f :: a :?: b-f' :: (:?:) a b-```--Promoted list (issue #348)--```haskell-a :: A '[ 'True]-a = undefined---- nested promoted list with multiple elements.-b :: A '[ '[ 'True, 'False], '[ 'False, 'True]]-b = undefined-```--Promoted list with a tuple (issue #348)--```haskell-a :: A '[ '( a, b, c, d)]-a = undefined---- nested promoted tuples.-b :: A '[ '( 'True, 'False, '[], '( 'False, 'True))]-b = undefined-```--Prefix promoted symbol type constructor--```haskell-a :: '(T.:->) 'True 'False-b :: (T.:->) 'True 'False-c :: '(:->) 'True 'False-d :: (:->) 'True 'False-```--# Function declarations--Prefix notation for operators--``` haskell-(+) :: Num a => a -> a -> a-(+) a b = a-```--Where clause--``` haskell-sayHello = do-  name <- getLine-  putStrLn $ greeting name-  where-    greeting name = "Hello, " ++ name ++ "!"-```--Guards and pattern guards--``` haskell-f x-  | x <- Just x-  , x <- Just x =-    case x of-      Just x -> e-  | otherwise = do e-  where-    x = y-```--Multi-way if--``` haskell-x =-  if | x <- Just x,-       x <- Just x ->-       case x of-         Just x -> e-         Nothing -> p-     | otherwise -> e-```--Case inside a `where` and `do`--``` haskell-g x =-  case x of-    a -> x-  where-    foo =-      case x of-        _ -> do-          launchMissiles-      where-        y = 2-```--Let inside a `where`--``` haskell-g x =-  let x = 1-   in x-  where-    foo =-      let y = 2-          z = 3-       in y-```--Lists--``` haskell-exceptions = [InvalidStatusCode, MissingContentHeader, InternalServerError]--exceptions =-  [ InvalidStatusCode-  , MissingContentHeader-  , InternalServerError-  , InvalidStatusCode-  , MissingContentHeader-  , InternalServerError-  ]-```--Long line, function application--```haskell-test = do-  alphaBetaGamma deltaEpsilonZeta etaThetaIota kappaLambdaMu nuXiOmicron piRh79-  alphaBetaGamma deltaEpsilonZeta etaThetaIota kappaLambdaMu nuXiOmicron piRho80-  alphaBetaGamma-    deltaEpsilonZeta-    etaThetaIota-    kappaLambdaMu-    nuXiOmicron-    piRhoS81-```--Long line, tuple--```haskell-test-  (alphaBetaGamma, deltaEpsilonZeta, etaThetaIota, kappaLambdaMu, nuXiOmicro79)-  (alphaBetaGamma, deltaEpsilonZeta, etaThetaIota, kappaLambdaMu, nuXiOmicron80)-  ( alphaBetaGamma-  , deltaEpsilonZeta-  , etaThetaIota-  , kappaLambdaMu-  , nuXiOmicronP81)-```--Long line, tuple section--```haskell-test-  (, alphaBetaGamma, , deltaEpsilonZeta, , etaThetaIota, kappaLambdaMu, nu79, )-  (, alphaBetaGamma, , deltaEpsilonZeta, , etaThetaIota, kappaLambdaMu, , n80, )-  (-  , alphaBetaGamma-  ,-  , deltaEpsilonZeta-  ,-  , etaThetaIota-  , kappaLambdaMu-  ,-  , nu81-  ,)-```--# Record syntax--Pattern matching, short--```haskell-fun Rec {alpha = beta, gamma = delta, epsilon = zeta, eta = theta, iota = kappa} = do-  beta + delta + zeta + theta + kappa-```--Pattern matching, long--```haskell-fun Rec { alpha = beta-        , gamma = delta-        , epsilon = zeta-        , eta = theta-        , iota = kappa-        , lambda = mu-        } =-  beta + delta + zeta + theta + kappa + mu + beta + delta + zeta + theta + kappa-```--Symbol constructor, short--```haskell-fun ((:..?) {}) = undefined-```--Symbol constructor, long--```-fun (:..?) { alpha = beta-           , gamma = delta-           , epsilon = zeta-           , eta = theta-           , iota = kappa-           , lambda = mu-           } =-  beta + delta + zeta + theta + kappa + mu + beta + delta + zeta + theta + kappa-```--Symbol field--```haskell-f (X {(..?) = x}) = x-```--Punned symbol field--```haskell-f' (X {(..?)}) = (..?)-```--# Johan Tibell compatibility checks--Basic example from Tibbe's style--``` haskell-sayHello :: IO ()-sayHello = do-  name <- getLine-  putStrLn $ greeting name-  where-    greeting name = "Hello, " ++ name ++ "!"--filter :: (a -> Bool) -> [a] -> [a]-filter _ [] = []-filter p (x:xs)-  | p x = x : filter p xs-  | otherwise = filter p xs-```--Data declarations--``` haskell-data Tree a-  = Branch !a !(Tree a) !(Tree a)-  | Leaf--data Tree a-  = Branch-      !a-      !(Tree a)-      !(Tree a)-      !(Tree a)-      !(Tree a)-      !(Tree a)-      !(Tree a)-      !(Tree a)-  | Leaf--data HttpException-  = InvalidStatusCode Int-  | MissingContentHeader--data Person =-  Person-    { firstName :: !String -- ^ First name-    , lastName :: !String -- ^ Last name-    , age :: !Int -- ^ Age-    }--data Expression a-  = VariableExpression-      { id :: Id Expression-      , label :: a-      }-  | FunctionExpression-      { var :: Id Expression-      , body :: Expression a-      , label :: a-      }-  | ApplyExpression-      { func :: Expression a-      , arg :: Expression a-      , label :: a-      }-  | ConstructorExpression-      { id :: Id Constructor-      , label :: a-      }-```--Spaces between deriving classes--``` haskell--- From https://github.com/chrisdone/hindent/issues/167-data Person =-  Person-    { firstName :: !String -- ^ First name-    , lastName :: !String -- ^ Last name-    , age :: !Int -- ^ Age-    }-  deriving (Eq, Show)-```--Hanging lambdas--``` haskell-bar :: IO ()-bar =-  forM_ [1, 2, 3] $ \n -> do-    putStrLn "Here comes a number!"-    print n--foo :: IO ()-foo =-  alloca 10 $ \a ->-    alloca 20 $ \b ->-      cFunction fooo barrr muuu (fooo barrr muuu) (fooo barrr muuu)-```--# Comments--Comments within a declaration--``` haskell-bob -- after bob- =-  foo -- next to foo-  -- line after foo-    (bar-       foo -- next to bar foo-       bar -- next to bar-     ) -- next to the end paren of (bar)-    -- line after (bar)-    mu -- next to mu-    -- line after mu-    -- another line after mu-    zot -- next to zot-    -- line after zot-    (case casey -- after casey-           of-       Just -- after Just-        -> do-         justice -- after justice-          *-           foo-             (blah * blah + z + 2 / 4 + a - -- before a line break-              2 * -- inside this mess-              z /-              2 /-              2 /-              aooooo /-              aaaaa -- bob comment-              ) +-           (sdfsdfsd fsdfsdf) -- blah comment-         putStrLn "")-    [1, 2, 3]-    [ 1 -- foo-    , ( 2 -- bar-      , 2.5 -- mu-       )-    , 3-    ]-    -- in the end of the function-  where-    alpha = alpha-    -- between alpha and beta-    beta = beta-    -- after beta--foo = 1 -- after foo--gamma = do-  delta-  epsilon-  -- in the end of a do-block 1--gamma = do-  delta-  epsilon-  -- the very last block is detected differently-```--Doesn't work yet (wrong comment position detection)--```haskell pending-gamma = do-  -- in the beginning of a do-block-  delta-  where-    -- before alpha-    alpha = alpha-```--Haddock comments--``` haskell--- | Module comment.-module X where---- | Main doc.-main :: IO ()-main = return ()--data X-  = X -- ^ X is for xylophone.-  | Y -- ^ Y is for why did I eat that pizza.--data X =-  X-    { field1 :: Int -- ^ Field1 is the first field.-    , field11 :: Char-      -- ^ This field comment is on its own line.-    , field2 :: Int -- ^ Field2 is the second field.-    , field3 :: Char -- ^ This is a long comment which starts next to-      -- the field but continues onto the next line, it aligns exactly-      -- with the field name.-    , field4 :: Char-      -- ^ This is a long comment which starts on the following line-      -- from from the field, lines continue at the sme column.-    }-```--Comments around regular declarations--``` haskell--- This is some random comment.--- | Main entry point.-main = putStrLn "Hello, World!"--- This is another random comment.-```--Multi-line comments--``` haskell-bob {- after bob -}- =-  foo {- next to foo -}-  {- line after foo -}-    (bar-       foo {- next to bar foo -}-       bar {- next to bar -}-     ) {- next to the end paren of (bar) -}-    {- line after (bar) -}-    mu {- next to mu -}-    {- line after mu -}-    {- another line after mu -}-    zot {- next to zot -}-    {- line after zot -}-    (case casey {- after casey -}-           of-       Just {- after Just -}-        -> do-         justice {- after justice -}-          *-           foo-             (blah * blah + z + 2 / 4 + a - {- before a line break -}-              2 * {- inside this mess -}-              z /-              2 /-              2 /-              aooooo /-              aaaaa {- bob comment -}-              ) +-           (sdfsdfsd fsdfsdf) {- blah comment -}-         putStrLn "")-    [1, 2, 3]-    [ 1 {- foo -}-    , ( 2 {- bar -}-      , 2.5 {- mu -}-       )-    , 3-    ]--foo = 1 {- after foo -}-```--Multi-line comments with multi-line contents--``` haskell-{- | This is some random comment.-Here is more docs and such.-Etc.--}-main = putStrLn "Hello, World!"-{- This is another random comment. -}-```--# MINIMAL pragma--Monad example--```haskell-class A where-  {-# MINIMAL return, ((>>=) | (join, fmap)) #-}-```--Very long names #310--```haskell-class A where-  {-# MINIMAL averylongnamewithnoparticularmeaning-            | ananotherverylongnamewithnomoremeaning #-}-```--# Behaviour checks--Unicode--``` haskell-α = γ * "ω"--- υ-```--Empty module--``` haskell-```--Trailing newline is preserved--``` haskell-module X where--foo = 123-```--# Complex input--A complex, slow-to-print decl--``` haskell-quasiQuotes =-  [ ( ''[]-    , \(typeVariable:_) _automaticPrinter ->-        (let presentVar = varE (presentVarName typeVariable)-          in lamE-               [varP (presentVarName typeVariable)]-               [|(let typeString = "[" ++ fst $(presentVar) ++ "]"-                   in ( typeString-                      , \xs ->-                          case fst $(presentVar) of-                            "GHC.Types.Char" ->-                              ChoicePresentation-                                "String"-                                [ ( "String"-                                  , StringPresentation-                                      "String"-                                      (concatMap-                                         getCh-                                         (map (snd $(presentVar)) xs)))-                                , ( "List of characters"-                                  , ListPresentation-                                      typeString-                                      (map (snd $(presentVar)) xs))-                                ]-                              where getCh (CharPresentation "GHC.Types.Char" ch) =-                                      ch-                                    getCh (ChoicePresentation _ ((_, CharPresentation _ ch):_)) =-                                      ch-                                    getCh _ = ""-                            _ ->-                              ListPresentation-                                typeString-                                (map (snd $(presentVar)) xs)))|]))-  ]-```--Random snippet from hindent itself--``` haskell-exp' (App _ op a) = do-  (fits, st) <- fitsOnOneLine (spaced (map pretty (f : args)))-  if fits-    then put st-    else do-      pretty f-      newline-      spaces <- getIndentSpaces-      indented spaces (lined (map pretty args))-  where-    (f, args) = flatten op [a]-    flatten :: Exp NodeInfo -> [Exp NodeInfo] -> (Exp NodeInfo, [Exp NodeInfo])-    flatten (App _ f' a') b = flatten f' (a' : b)-    flatten f' as = (f', as)-```--Quasi quotes--```haskell-exp = [name|exp|]--f [qq|pattern|] = ()-```--# C preprocessor--Conditionals (`#if`)--```haskell-isDebug :: Bool-#if DEBUG-isDebug = True-#else-isDebug = False-#endif-```--Macro definitions (`#define`)--```haskell-#define STRINGIFY(x) #x-f = STRINGIFY (y)-```--Escaped newlines--```haskell-#define LONG_MACRO_DEFINITION \-  data Pair a b = Pair \-    { first :: a \-    , second :: b \-    }-#define SHORT_MACRO_DEFINITION \-  x-```--# Regression tests--jml Adds trailing whitespace when wrapping #221--``` haskell-x = do-  config <- execParser options-  comments <--    case config of-      Diff False args -> commentsFromDiff args-      Diff True args -> commentsFromDiff ("--cached" : args)-      Files args -> commentsFromFiles args-  mapM_ (putStrLn . Fixme.formatTodo) (concatMap Fixme.getTodos comments)-```--meditans hindent freezes when trying to format this code #222--``` haskell-c :: forall new.-     ( Settable "pitch" Pitch (Map.AsMap (new Map.:\ "pitch")) new-     , Default (Book' (Map.AsMap (new Map.:\ "pitch")))-     )-  => Book' new-c = set #pitch C (def :: Book' (Map.AsMap (new Map.:\ "pitch")))--foo ::-     ( Foooooooooooooooooooooooooooooooooooooooooo-     , Foooooooooooooooooooooooooooooooooooooooooo-     )-  => A-```--bitemyapp wonky multiline comment handling #231--``` haskell-module Woo where--hi = "hello"-{--test comment--}--- blah blah--- blah blah--- blah blah-```--cocreature removed from declaration issue #186--``` haskell--- https://github.com/chrisdone/hindent/issues/186-trans One e n =-  M.singleton-    (Query Unmarked (Mark NonExistent)) -- The goal of this is to fail always-    (emptyImage {notPresent = S.singleton (TransitionResult Two (Just A) n)})-```--sheyll explicit forall in instances #218--``` haskell--- https://github.com/chrisdone/hindent/issues/218-instance forall x. C--instance forall x. Show x => C x-```--tfausak support shebangs #208--``` haskell given-#!/usr/bin/env stack--- stack runghc-main =- pure ()--- https://github.com/chrisdone/hindent/issues/208-```--``` haskell expect-#!/usr/bin/env stack--- stack runghc-main = pure ()--- https://github.com/chrisdone/hindent/issues/208-```--joe9 preserve newlines between import groups--``` haskell--- https://github.com/chrisdone/hindent/issues/200-import Data.List-import Data.Maybe--import FooBar-import MyProject--import GHC.Monad---- blah-import Hello--import CommentAfter -- Comment here shouldn't affect newlines-import HelloWorld--import CommentAfter -- Comment here shouldn't affect newlines--import HelloWorld---- Comment here shouldn't affect newlines-import CommentAfter--import HelloWorld-```--Wrapped import list shouldn't add newline--```haskell given-import ATooLongList-       (alpha, beta, gamma, delta, epsilon, zeta, eta, theta)-import B-```--```haskell expect-import ATooLongList (alpha, beta, delta, epsilon, eta, gamma, theta, zeta)-import B-```--radupopescu `deriving` keyword not aligned with pipe symbol for type declarations--``` haskell-data Stuffs-  = Things-  | This-  | That-  deriving (Show)--data Simple =-  Simple-  deriving (Show)-```--sgraf812 top-level pragmas should not add an additional newline #255--``` haskell--- https://github.com/chrisdone/hindent/issues/255-{-# INLINE f #-}-f :: Int -> Int-f n = n-```--ivan-timokhin breaks code with type operators #277--```haskell--- https://github.com/chrisdone/hindent/issues/277-{-# LANGUAGE TypeOperators #-}-{-# LANGUAGE MultiParamTypeClasses #-}--type m ~> n = ()--class (a :< b) c-```--ivan-timokhin variables swapped around in constraints #278--```haskell--- https://github.com/chrisdone/hindent/issues/278-data Link c1 c2 a c =-  forall b. (c1 a b, c2 b c) =>-            Link (Proxy b)-```--ttuegel qualified infix sections get mangled #273--```haskell--- https://github.com/chrisdone/hindent/issues/273-import qualified Data.Vector as V--main :: IO ()-main = do-  let _ = foldr1 (V.++) [V.empty, V.empty]-  pure ()---- more corner cases.-xs = V.empty V.++ V.empty--ys = (++) [] []--cons :: V.Vector a -> V.Vector a -> V.Vector a-cons = (V.++)-```--ivan-timokhin breaks operators type signatures #301--```haskell--- https://github.com/chrisdone/hindent/issues/301-(+) :: ()-```--cdepillabout Long deriving clauses are not reformatted #289--```haskell-newtype Foo =-  Foo Proxy-  deriving ( Functor-           , Applicative-           , Monad-           , Semigroup-           , Monoid-           , Alternative-           , MonadPlus-           , Foldable-           , Traversable-           )-```--ivan-timokhin Breaks instances with type operators #342--```haskell--- https://github.com/chrisdone/hindent/issues/342-instance Foo (->)--instance Foo (^>)--instance Foo (T.<^)-```--Indents record constructions and updates #358-```haskell-foo =-  assert-    sanityCheck-    BomSnapshotAggr-      { snapshot = Just bs-      , previousId = M.bomSnapshotHistoryPreviousId . entityVal <$> bsp-      , nextId = M.bomSnapshotHistoryNextId . entityVal <$> bsn-      , bomEx = bx''-      , orderSubstitutes =-          S.fromList . map OrderSubstituteAggrByCreatedAtAsc $ subs-      , snapshotSubstitute = msub-      }-```--paraseba Deriving strategies with multiple deriving clauses-```haskell--- https://github.com/commercialhaskell/hindent/issues/503-{-# LANGUAGE DerivingStrategies #-}-{-# LANGUAGE DeriveAnyClass #-}-{-# LANGUAGE DeriveGeneric #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Foo where--import Data.Typeable-import GHC.Generics--newtype Number a =-  Number a-  deriving (Generic)-  deriving newtype (Show, Eq)-  deriving anyclass (Typeable)-```--neongreen "{" is lost when formatting "Foo{}" #366--```haskell--- https://github.com/chrisdone/hindent/issues/366-foo = Nothing {}-```--jparoz Trailing space in list comprehension #357--```haskell--- https://github.com/chrisdone/hindent/issues/357-foo =-  [ (x, y)-  | x <- [1 .. 10]-  , y <- [11 .. 20]-  , even x-  , even x-  , even x-  , even x-  , even x-  , odd y-  ]-```--ttuegel Record formatting applied to expressions with RecordWildCards #274--```haskell--- https://github.com/chrisdone/hindent/issues/274-foo (Bar {..}) = Bar {..}-```--RecursiveDo `rec` and `mdo` keyword #328--```haskell-rec = undefined--mdo = undefined-```--sophie-h Record syntax change in 5.2.2 #393--```haskell--- https://github.com/commercialhaskell/hindent/issues/393-data X-  = X-      { x :: Int-      }-  | X'--data X =-  X-    { x :: Int-    , x' :: Int-    }--data X-  = X-      { x :: Int-      , x' :: Int-      }-  | X'-```--k-bx Infix data constructor gets reformatted into a parse error #328--```haskell--- https://github.com/commercialhaskell/hindent/issues/328-data Expect =-  String :--> String-  deriving (Show)-```--tfausak Class constraints cause too many newlines #244--```haskell--- https://github.com/commercialhaskell/hindent/issues/244-x :: Num a => a-x = undefined---- instance-instance Num a => C a---- long instance-instance Nuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuum a =>-         C a where-  f = undefined-```--expipiplus1 Always break before `::` on overlong signatures #390--```haskell--- https://github.com/commercialhaskell/hindent/issues/390-fun :: Is => Short-fun = undefined--someFunctionSignature ::-     Wiiiiiiiiiiiiiiiiith-  -> Enough-  -> (Arguments -> To ())-  -> Overflow (The Line Limit)-```--duog Long Type Constraint Synonyms are not reformatted #290--```haskell--- https://github.com/commercialhaskell/hindent/issues/290-type MyContext m-   = ( MonadState Int m-     , MonadReader Int m-     , MonadError Text m-     , MonadMask m-     , Monoid m-     , Functor m)-```--ocharles Type application differs from function application (leading to long lines) #359--```haskell--- https://github.com/commercialhaskell/hindent/issues/359-thing ::-     ( ResB.BomEx-     , Maybe [( Entity BomSnapshot-              , ( [ResBS.OrderSubstituteAggr]-                , ( Maybe (Entity BomSnapshotHistory)-                  , Maybe (Entity BomSnapshotHistory))))])-  -> [(ResB.BomEx, Maybe ResBS.BomSnapshotAggr)]-```--NorfairKing Do as left-hand side of an infix operation #296--```haskell--- https://github.com/commercialhaskell/hindent/issues/296-block =-  do ds <- inBraces $ inWhiteSpace declarations-     return $ Block ds-     <?> "block"-```--NorfairKing Hindent linebreaks after very short names if the total line length goes over 80 #405--```haskell--- https://github.com/commercialhaskell/hindent/issues/405-t =-  f "this is a very loooooooooooooooooooooooooooong string that goes over the line length"-    argx-    argy-    argz--t =-  function-    "this is a very loooooooooooooooooooooooooooong string that goes over the line length"-    argx-    argy-    argz-```--ivan-timokhin No linebreaks for long functional dependency declarations #323--```haskell--- https://github.com/commercialhaskell/hindent/issues/323-class Foo a b | a -> b where-  f :: a -> b--class Foo a b c d e f-  | a b c d e -> f-  , a b c d f -> e-  , a b c e f -> d-  , a b d e f -> c-  , a c d e f -> b-  , b c d e f -> a-  where-  foo :: a -> b -> c -> d -> e -> f-```--utdemir Hindent breaks TH name captures of operators #412--```haskell--- https://github.com/commercialhaskell/hindent/issues/412-data T =-  (-)--q = '(-)--data (-)--q = ''(-)-```--utdemir Hindent can not parse empty case statements #414--```haskell--- https://github.com/commercialhaskell/hindent/issues/414-{-# LANGUAGE EmptyCase #-}-{-# LANGUAGE LambdaCase #-}--f1 = case () of {}--f2 = \case {}-```--TimoFreiberg INLINE (and other) pragmas for operators are reformatted without parens #415--```haskell--- https://github.com/commercialhaskell/hindent/issues/415-{-# NOINLINE (<>) #-}-```--NorfairKing Hindent breaks servant API's #417--```haskell--- https://github.com/commercialhaskell/hindent/issues/417-type API = api1 :<|> api2-```--andersk Cannot parse @: operator #421--```haskell--- https://github.com/commercialhaskell/hindent/issues/421-a @: b = a + b--main = print (2 @: 2)-```--andersk Corrupts parenthesized type operators #422--```haskell--- https://github.com/commercialhaskell/hindent/issues/422-data T a =-  a :@ a--test = (:@)-```--NorfairKing Infix constructor pattern is broken #424--```haskell--- https://github.com/commercialhaskell/hindent/issues/424-from $ \(author `InnerJoin` post) -> pure ()-```--NorfairKing Hindent can no longer parse type applications code #426--```haskell--- https://github.com/commercialhaskell/hindent/issues/426-{-# LANGUAGE TypeApplications #-}--f :: Num a => a-f = id--x = f @Int 12-```--michalrus Multiline `GHC.TypeLits.Symbol`s are being broken #451--```haskell--- https://github.com/commercialhaskell/hindent/issues/451-import GHC.TypeLits (Symbol)--data X (sym :: Symbol)-  deriving (Typeable)--type Y = X "abc\n\n\ndef"-```--DavidEichmann Existential Quantification reordered #443--```haskell--- https://github.com/commercialhaskell/hindent/issues/443-{-# LANGUAGE ExistentialQuantification #-}--data D =-  forall a b c. D a b c-```--sophie-h Regression: Breaks basic type class code by inserting "|" #459--```haskell--- https://github.com/commercialhaskell/hindent/issues/459-class Class1 a =>-      Class2 a-  where-  f :: a -> Int--class (Eq a, Show a) =>-      Num a-  where-  (+), (-), (*) :: a -> a -> a-  negate :: a -> a-  abs, signum :: a -> a-  fromInteger :: Integer -> a-```--michalrus `let … in …` inside of `do` breaks compilation #467--```haskell--- https://github.com/commercialhaskell/hindent/issues/467-main :: IO ()-main = do-  let x = 5-   in when (x > 0) (return ())-```--sophie-h Breaking valid top-level template haskell #473--```haskell--- https://github.com/commercialhaskell/hindent/issues/473-template $-  haskell-    [ ''SomeVeryLongName-    , ''AnotherLongNameEvenLongToBreakTheLine-    , ''LastLongNameInList-    ]-```--schroffl Hindent produces invalid Syntax from FFI exports #479--```haskell--- https://github.com/commercialhaskell/hindent/issues/479-foreign export ccall "test" test :: IO ()--foreign import ccall "test" test :: IO ()--foreign import ccall safe "test" test :: IO ()--foreign import ccall unsafe "test" test :: IO ()-```--ptek Reformatting of the {-# OVERLAPPING #-} pragma #386--```haskell--- https://github.com/commercialhaskell/hindent/issues/386-instance {-# OVERLAPPING #-} Arbitrary (Set Int) where-  arbitrary = undefined-```--cdsmith Quotes are dropped from package imports #480--```haskell--- https://github.com/commercialhaskell/hindent/issues/480-{-# LANGUAGE PackageImports #-}--import qualified "base" Prelude as P-```--alexwl Hindent breaks associated type families annotated with injectivity information #528--```haskell--- https://github.com/commercialhaskell/hindent/issues/528-class C a where-  type F a = b | b -> a-```--sophie-h Fails to create required indentation for infix #238--```haskell--- https://github.com/commercialhaskell/hindent/issues/238-{-# LANGUAGE ScopedTypeVariables #-}--import Control.Exception--x :: IO Int-x =-  do putStrLn "ok"-     error "ok"-     `catch` (\(_ :: IOException) -> pure 1) `catch`-  (\(_ :: ErrorCall) -> pure 2)--```--lippirk Comments on functions in where clause not quite right #540--```haskell--- https://github.com/chrisdone/hindent/issues/540-topLevelFunc1 = f-  where-    -- comment on func in where clause-    -- stays in the where clause-    f = undefined--topLevelFunc2 = f . g-  where-    {- multi-       line-       comment -}-    f = undefined-    -- single line comment-    g = undefined+# HIndent test codes++This file is a test suite. Each section maps to an HSpec test, and+each line that is followed by a Haskell code fence is tested to make+sure re-formatting that code snippet produces the same result.++You can browse through this document to see what HIndent's style is+like, or contribute additional sections to it, or regression tests.++## Shebangs++No newlines after a shebang++```haskell given+#!/usr/bin/env stack++-- stack runghc+main =+ pure ()+-- https://github.com/mihaimaruseac/hindent/issues/208+```++```haskell expect+#!/usr/bin/env stack+-- stack runghc+main = pure ()+-- https://github.com/mihaimaruseac/hindent/issues/208+```++Double shebangs++```haskell+#!/usr/bin/env stack+#!/usr/bin/env stack+main = pure ()+```++## Modules++Empty module++```haskell+```++### Module headers++Without an export list++```haskell+module X where++x = 1+```++With an export list++```haskell+module X+  ( x+  , y+  , Z+  , P(x, z)+  , module Foo+  ) where+```++With an export list; indentation 4++```haskell 4+module X+    ( x+    , y+    , Z+    , P(x, z)+    ) where+```++### Module-level pragmas++A `WARNING` for a module without an export list.++```haskell+module Foo {-# WARNING "Debug purpose only." #-} where+```++A `DEPRECATED` for a module with an export list.++```haskell+module Foo {-# DEPRECATED "Use Bar." #-}+  ( x+  , y+  , z+  ) where+```++A pragma's name is converted to the SHOUT_CASE.++```haskell given+{-# lAnGuAgE CPP #-}+```++```haskell expect+{-# LANGUAGE CPP #-}+```++Pragmas, GHC options, and haddock options.++```haskell+{-# LANGUAGE CPP #-}+{-# LANGUAGE NoRebindableSyntax #-}+{-# OPTIONS_GHC -fno-warn-missing-import-lists #-}+{-# OPTIONS_GHC -w #-}+{-# OPTIONS_HADDOCK show-extensions #-}++module Foo where+```++Accept pragmas via `OPTIONS -XFOO`++```haskell+{-# OPTIONS -XPatternSynonyms #-}++import Foo (pattern Bar)+```++Accept pragmas via `OPTIONS_GHC -XFOO`++```haskell+{-# OPTIONS_GHC -XPatternSynonyms #-}++import Foo (pattern Bar)+```++A pragma's length is adjusted automatically++```haskell given+{-#         LANGUAGE OverloadedStrings          #-}+```++```haskell expect+{-# LANGUAGE OverloadedStrings #-}+```++Collect multiple extensions correctly++```haskell+{-# LANGUAGE DerivingStrategies #-}+{-# LANGUAGE PatternSynonyms #-}++import Language.C.Types (pattern TypeName)+```++Collect multiple extensions separated by commas correctly++```haskell given+{-# LANGUAGE TypeApplications,+    PatternSynonyms #-}++import Foo (pattern Bar)++foo = bar @Int 3+```++```haskell expect+{-# LANGUAGE TypeApplications, PatternSynonyms #-}++import Foo (pattern Bar)++foo = bar @Int 3+```++Do not collect pragma-like comments++```haskell+-- {-# LANGUAGE StaticPointers #-}+{-++{-# LANGUAGE StaticPointers #-}++-}+-- @static@ is no longer a valid identifier+-- once `StaticPointers` is enabled.+static = 3+```++## Imports, foreign imports, and foreign exports++Import lists++```haskell+import Control.Lens (_2, _Just)+import Data.Text+import Data.Text+import qualified Data.Text as T+import qualified Data.Text (a, b, c)+import Data.Text (a, b, c)+import Data.Text hiding (a, b, c)+```++Shorter identifiers come first++```haskell+import Foo ((!), (!!))+```++Import with `ExplicitNamespaces`.++```haskell+{-# LANGUAGE ExplicitNamespaces #-}++import Prlude (type FilePath)+```++Import a pattern++```haskell+{-# LANGUAGE PatternSynonyms #-}++import Foo (pattern Bar)+```++Sorted++```haskell given+import B+import A+```++```haskell expect+import A+import B+```++Explicit imports - capitals first (typeclasses/types), then operators, then identifiers++```haskell given+import qualified MegaModule as M ((>>>), MonadBaseControl, void, MaybeT(..), join, Maybe(Nothing, Just), liftIO, Either, (<<<), Monad(return, (>>=), (>>)))+```++```haskell expect+import qualified MegaModule as M+  ( Either+  , Maybe(Just, Nothing)+  , MaybeT(..)+  , Monad((>>), (>>=), return)+  , MonadBaseControl+  , (<<<)+  , (>>>)+  , join+  , liftIO+  , void+  )+```++Pretty import specification++```haskell+import A hiding+  ( foobarbazqux+  , foobarbazqux+  , foobarbazqux+  , foobarbazqux+  , foobarbazqux+  , foobarbazqux+  , foobarbazqux+  )++import Name hiding ()++import {-# SOURCE #-} safe qualified Module as M hiding (a, b, c, d, e, f)+```++An import declaration importing lots of data constructors++```haskell+import Direction+  ( Direction(East, North, NorthEast, NorthWest, South, SouthEast,+          SouthWest, West)+  , allDirections+  )+```++Preserve newlines between import groups++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/200+import GHC.Monad++import CommentAfter -- Comment here shouldn't affect newlines+import HelloWorld++import CommentAfter -- Comment here shouldn't affect newlines++-- Comment here shouldn't affect newlines+import CommentAfter+```++`PackageImports`++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/480+{-# LANGUAGE PackageImports #-}++import qualified "base" Prelude as P+```++Importing a `#`++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/547+import Diagrams.Prelude ((#))+```++### Foreign imports and exports++A `ccall` foreign export++```haskell+{-# LANGUAGE ForeignFunctionInterface #-}++foreign export ccall "test" test :: IO ()+```++A `ccall` unsafe foreign import++```haskell+{-# LANGUAGE ForeignFunctionInterface #-}++foreign import ccall unsafe "test" test :: IO ()+```++A `capi` foreign import++```haskell+{-# LANGUAGE CApiFFI #-}+{-# LANGUAGE ForeignFunctionInterface #-}++foreign import capi safe "foo" test :: IO Int+```++A `stdcall` foreign import++```haskell+{-# LANGUAGE ForeignFunctionInterface #-}++foreign import stdcall safe "test" bar :: IO ()+```++A `prim` foreign import++```haskell+{-# LANGUAGE ForeignFunctionInterface #-}++foreign import prim safe "test" test :: IO ()+```++A `javascript` foreign import++```haskell+{-# LANGUAGE ForeignFunctionInterface #-}++foreign import javascript safe "test" test :: IO ()+```++## Declarations++Data family++```haskell+data family Foo a+```++`StandaloneKindSignatures`++```haskell+{-# LANGUAGE StandaloneKindSignatures #-}++type Foo :: Type -> Type -> Type+```++Default declaration++```haskell+default (Integer, Double)+```++### `ANN` pragmas++Value annotation.++```haskell+{-# ANN foo "annotation" #-}+```++Type annotation.++```haskell+{-# ANN type Foo "annotation" #-}+```++Module annotation.++```haskell+{-# ANN module "annotation" #-}+```++### Class declarations++Default signatures++```haskell+-- https://github.com/chrisdone/hindent/issues/283+class Foo a where+  bar :: a -> a -> a+  default bar :: Monoid a => a -> a -> a+  bar = mappend+```++`TypeOperators` and `MultiParamTypeClasses`++```haskell+-- https://github.com/chrisdone/hindent/issues/277+{-# LANGUAGE TypeOperators #-}+{-# LANGUAGE MultiParamTypeClasses #-}++class (a :< b) c+```++#### Class constraints++Empty++```haskell+class () =>+      Foo a+```++Long++```haskell+class ( Foo a+      , Bar a+      , Baz a+      , Hoge a+      , Fuga a+      , Piyo a+      , Hogera a+      , Hogehoge a+      , Spam a+      , Ham a+      ) =>+      Quux a+```++#### Class methods++With class constraints++```haskell+class Foo f where+  myEq :: (Eq a) => f a -> f a -> Bool+```++Long signatures++```haskell+class Foo a where+  fooBarBazQuuxHogeFuga ::+       a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a+```++#### Associated type synonyms++Associated type synonyms++```haskell+class Foo a where+  type Bar b+```++Associated type synonyms annotated with injectivity information++```haskell+-- https://github.com/commercialhaskell/hindent/issues/528+class C a where+  type F a = b | b -> a+```++### Class instance declarations++Without methods++```haskell+instance C a+```++With methods++```haskell+instance C a where+  foobar = do+    x y+    k p+```++With type operators++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/342+instance Foo (->)++instance Foo (^>)++instance Foo (T.<^)+```++With a type alias++```haskell+instance Foo a where+  type Bar a = Int+```++A `where` clause between instance functions++```haskell+instance Pretty HsModule where+  pretty' = undefined+    where+      a = b+  commentsBefore = Nothing+```++With a `SPECIALISE` pragma++```haskell+instance (Show a) => Show (Foo a) where+  {-# SPECIALISE instance Show (Foo String) #-}+  show = undefined+```++With associated data types++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/493+instance GM 'Practice where+  data MatchConfig 'Practice = MatchConfig'Practice+    { teamSize :: Int+    , ladder :: Ladder+    }+```++#### With overlapping pragmas++`OVERLAPPING`++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/386+instance {-# OVERLAPPING #-} Arbitrary (Set Int) where+  arbitrary = undefined+```++`OVERLAPPABLE`++```haskell+instance {-# OVERLAPPABLE #-} Arbitrary Int where+  arbitrary = undefined+```++`OVERLAPS`++```haskell+instance {-# OVERLAPS #-} Arbitrary String where+  arbitrary = undefined+```++`INCOHERENT`++```haskell+instance {-# INCOHERENT #-} Arbitrary String where+  arbitrary = undefined+```++#### With class constraints++Short name++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/244+instance Num a => C a+```++Long name++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/244+instance Nuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuum a =>+         C a where+  f = undefined+```++#### Explicit foralls++Without class constraints++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/218+instance forall x. C+```++With class constraints++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/218+instance forall x. Show x => C x+```++#### Symbol class constructor++Infix++```haskell+instance Bool :?: Bool+```++Prefix++```haskell+instance (:?:) Int Bool+```++### Data declarations++Data declaration with underscore++```haskell+data Stanza = MkStanza+  { _stanzaBuildInfo :: BuildInfo+  , stanzaIsSourceFilePath :: FilePath -> Bool+  }+```++A data declaration with typeclass constraints++```haskell+data Ord a =>+     Foo =+  Foo a+```++Multiple constructors at once++```haskell+data Foo = Foo+  { foo, bar, baz, qux, quux :: Int+  }+```++No fields++```haskell+data Foo+```++Single field++```haskell+data Foo =+  Foo+```++Multiple unnamed fields++```haskell+data HttpException+  = InvalidStatusCode Int+  | MissingContentHeader+```++A lot of unnamed fields in a constructor++```haskell+data Foo =+  Foo+    String+    String+    String+    String+    String+    String+    String+    String+    String+    String+    String+```++A banged field++```haskell+data Foo =+  Foo !Int+```++A record constructor with a field++```haskell+data Foo = Foo+  { foo :: Int+  }+```++Multiple constructors with fields++```haskell+data Expression a+  = VariableExpression+      { id :: Id Expression+      , label :: a+      }+  | FunctionExpression+      { var :: Id Expression+      , body :: Expression a+      , label :: a+      }+  | ApplyExpression+      { func :: Expression a+      , arg :: Expression a+      , label :: a+      }+  | ConstructorExpression+      { id :: Id Constructor+      , label :: a+      }+```++A mixture of constructors with unnamed fields and record constructors++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/393+data X+  = X+      { x :: Int+      , x' :: Int+      }+  | X'+```++An infix data constructor++```haskell+data Foo =+  Int :--> Int+```++An `UNPACK`ed field.++```haskell+data Foo = Foo+  { x :: {-# UNPACK #-} Int+  }+```++An `NOUNPACK`ed field.++```haskell+data Foo = Foo+  { x :: {-# NOUNPACK #-} !Int+  }+```++A lazy field.++```haskell+data Foo = Foo+  { x :: ~Int+  }+```++#### Fields with `forall` constraints++Single++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/278+data Link c1 c2 a c =+  forall b. (c1 a b, c2 b c) =>+            Link (Proxy b)+```++Multiple++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/443+{-# LANGUAGE ExistentialQuantification #-}++data D =+  forall a b c. D a b c+```++#### Derivings++With a single constructor++```haskell+data Simple =+  Simple+  deriving (Show)+```++With multiple constructors++```haskell+data Stuffs+  = Things+  | This+  | That+  deriving (Show)+```++With a record constructor++```haskell+-- From https://github.com/mihaimaruseac/hindent/issues/167+data Person = Person+  { firstName :: !String -- ^ First name+  , lastName :: !String -- ^ Last name+  , age :: !Int -- ^ Age+  } deriving (Eq, Show)+```++Multiple derivings++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/289+newtype Foo =+  Foo Proxy+  deriving ( Functor+           , Applicative+           , Monad+           , Semigroup+           , Monoid+           , Alternative+           , MonadPlus+           , Foldable+           , Traversable+           )+```++Various deriving strategies++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/503+{-# LANGUAGE DerivingStrategies #-}+{-# LANGUAGE DeriveAnyClass #-}+{-# LANGUAGE DeriveGeneric #-}+{-# LANGUAGE DeriveVia #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}++module Foo where++import Data.Typeable+import GHC.Generics++newtype Number a =+  Number a+  deriving (Generic)+  deriving stock (Ord)+  deriving newtype (Eq)+  deriving anyclass (Typeable)+  deriving (Show) via a+```++`StandaloneDeriving`++```haskell+{-# LANGUAGE DerivingVia #-}+{-# LANGUAGE StandaloneDeriving #-}++data Foo =+  Foo++deriving instance Eq Foo++deriving stock instance Ord Foo++deriving via (Foo a) instance Show (Bar a)+```++#### GADT declarations++With a kind signature++```haskell+data Ty :: (* -> *) where+  TCon+    :: { field1 :: Int+       , field2 :: Bool}+    -> Ty Bool+  TCon' :: (a :: *) -> a -> Ty a+```++Without a kind signature++```haskell+data Foo where+  Foo+    :: forall v. Ord v+    => v+    -> v+    -> Foo+```++With a `forall` but no contexts++```haskell+data Foo where+  Foo :: forall v. v -> v -> Foo+```++With a context but no `forall`s++```haskell+data Foo where+  Foo :: (Ord v) => v -> v -> Foo+```++With methods with record signatures++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/581+data Test where+  Test :: Eq a => { test :: a } -> Test+```++### Data instance declarations++Without type applications++```haskell+data instance Foo Int =+  FInt+```++With type applications++```haskell+data instance Foo @k a =+  FString+```++### Function declarations++Case inside `do` and lambda++```haskell+foo =+  \x -> do+    case x of+      Just _ -> 1+      Nothing -> 2+```++A `case` inside a `let`.++```haskell+f = do+  let (x, xs) =+        case gs of+          [] -> undefined+          (x':xs') -> (x', xs')+  undefined+```++A `do` inside a lambda.++```haskell+printCommentsAfter =+  case commentsAfter p of+    xs -> do+      forM_ xs $ \(L loc c) -> do+        eolCommentsArePrinted+```++Case with natural pattern (See NPat of https://hackage.haskell.org/package/ghc-lib-parser-9.2.3.20220527/docs/Language-Haskell-Syntax-Pat.html#t:Pat)++```haskell+foo =+  case x of+    0 -> pure ()+    _ -> undefined+```++```haskell+s8_stripPrefix bs1@(S.PS _ _ l1) bs2+  | bs1 `S.isPrefixOf` bs2 = Just (S.unsafeDrop l1 bs2)+  | otherwise = Nothing+```++A `do` inside a guard arm++```haskell+f+  | x == 1 = do+    a+    b+```++`if` having a long condition++```haskell+foo =+  if fooooooo ||+     baaaaaaaaaaaaaaaaaaaaa || apsdgiuhasdpfgiuahdfpgiuah || bazzzzzzzzzzzzz+    then a+    else b+```++A long signature inside a where clause++```haskell+cppSplitBlocks :: ByteString -> [CodeBlock]+cppSplitBlocks inp = undefined+  where+    spanCPPLines ::+         [(Int, ByteString)] -> ([(Int, ByteString)], [(Int, ByteString)])+    spanCPPLines = undefined+```++A `forall` type inside a where clause++```haskell+replaceAllNotUsedAnns :: HsModule -> HsModule+replaceAllNotUsedAnns = everywhere app+  where+    app ::+         forall a. Data a+      => (a -> a)+    app = undefined++f :: a+f = undefined+  where+    ggg ::+         forall a. Typeable a+      => a+      -> a+    ggg = undefined+```++Prefix notation for operators++```haskell+(+) a b = a+```++Guards and pattern guards++```haskell+f x+  | x <- Just x+  , x <- Just x =+    case x of+      Just x -> e+  | otherwise = do e+  where+    x = y+```++Where clause++```haskell+sayHello = do+  name <- getLine+  putStrLn $ greeting name+  where+    greeting name = "Hello, " ++ name ++ "!"+```++An empty line is inserted after an empty `where`++```haskell given+f = evalState+    -- A comment+  where+```++```haskell expect+f = evalState+    -- A comment+  where++```++Multiple function declarations with an empty `where`++```haskell+f = undefined+  where+++g = undefined+```++Let inside a `where`++```haskell+g x =+  let x = 1+   in x+  where+    foo =+      let y = 2+          z = 3+       in y+```++The indent after a top-level `where` has always 2 spaces.++```haskell 4+f = undefined+  where+    g = undefined+```++The indent after a `where` inside a `case` depends on the indent space setting++```haskell 4+f =+    case x of+        x -> undefined+            where y = undefined+```++#### Pattern matchings++View pattern++```haskell+foo (f -> Just x) = print x+foo _ = Nothing+```++Match against a list++```haskell+head [] = undefined+head [x] = x+head xs = head $ init xs++foo [Coord _ _, Coord _ _] = undefined+```++Multiple matchings++```haskell+head' [] = Nothing+head' (x:_) = Just x+```++n+k patterns++```haskell+f (n+5) = 0+```++Binary symbol data constructor in pattern++```haskell+f (x :| _) = x++f' ((:|) x _) = x++f'' ((Data.List.NonEmpty.:|) x _) = x++g (x:xs) = x++g' ((:) x _) = x+```++Infix constructor pattern++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/424+from $ \(author `InnerJoin` post) -> pure ()+```++Unboxed sum pattern matching.++```haskell+{-# LANGUAGE UnboxedSums #-}++f (# (# n, _ #) | #) = (# n | #)+f (# | b #) = (# | b #)+```++Pattern matching against a infix constructor with a module name prefix++```haskell+foo (a FOO.:@: b) = undefined+```++##### Pattern matchings against record++Short++```haskell+fun Rec {alpha = beta, gamma = delta, epsilon = zeta, eta = theta, iota = kappa} = do+  beta + delta + zeta + theta + kappa+```++Long++```haskell+fun Rec { alpha = beta+        , gamma = delta+        , epsilon = zeta+        , eta = theta+        , iota = kappa+        , lambda = mu+        } =+  beta + delta + zeta + theta + kappa + mu + beta + delta + zeta + theta + kappa+```++Another long one++```haskell+resetModuleStartLine m@HsModule { hsmodAnn = epa@EpAnn {..}+                                , hsmodName = Just (L (SrcSpanAnn _ (RealSrcSpan sp _)) _)+                                } = undefined+```++Symbol constructor, short++```haskell+fun ((:..?) {}) = undefined+```++Symbol constructor, long++```haskell+fun (:..?) { alpha = beta+           , gamma = delta+           , epsilon = zeta+           , eta = theta+           , iota = kappa+           , lambda = mu+           } =+  beta + delta + zeta + theta + kappa + mu + beta + delta + zeta + theta + kappa+```++Symbol field++```haskell+f (X {(..?) = x}) = x+```++Punned symbol field++```haskell+f' (X {(..?)}) = (..?)+```++`RecordWileCards`++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/274+foo (bar@Bar {..}) = Bar {..}++resetModuleNameColumn m@HsModule {hsmodName = Just (L (SrcSpanAnn epa@EpAnn {..} sp) name)} =+  m++bar Bar {baz = before, ..} = Bar {baz = after, ..}+```++As pattern++```haskell+f all@(x:xs) = all+```++### Infix declarations++infixl++```haskell+infixl 1 ^-^+```++infixr++```haskell+infixr 1 ^-^+```++infix++```haskell+infix 1 ^-^+```++### Pattern synonym declarations++Unidirectional with a pattern type signature++```haskell+{-# LANGUAGE PatternSynonyms #-}++pattern Foo :: Int -> Int -> [Int]+pattern Foo x y <- [x, y]+```++Bidirectional record pattern++```haskell+{-# LANGUAGE PatternSynonyms #-}++pattern Pair {x, y} = (x, y)+```++#### Explicit bidirectional++With a prefix constructor++```haskell+{-# LANGUAGE PatternSynonyms #-}++pattern Fst x <- (x, x)+  where Fst x = (x, 0)+```++With an infix constructor++```haskell+{-# LANGUAGE PatternSynonyms #-}++pattern x :| xs <- x : xs+  where a :| b = a : b+```++### Pragma declarations++`INLINE`++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/255+{-# INLINE f #-}+f :: Int -> Int+f n = n+```++`NOINLINE` with an operator enclosed by parentheses++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/415+{-# NOINLINE (<>) #-}+```++`INLINABLE`++```haskell+{-# INLINABLE f #-}+f :: a+f = undefined+```++`OPAQUE`++```haskell since 9.4.0+{-# OPAQUE f #-}+f :: a+f = undefined+```++`INLINE` with levels++```haskell+{-# INLINE [0] f #-}+{-# INLINE [~1] g #-}+```++A `DEPRECATED`.++```haskell+{-# DEPRECATED+giveUp "Never give up."+ #-}++giveUp = undefined+```++A `WARNING`.++```haskell+{-# WARNING+debugCode "The use of 'debugCode'"+ #-}+```++A `COMPLETE`++```haskell+{-# COMPLETE Single, Anylist #-}+```++Top-level `SPECIALISE`++```haskell+{-# SPECIALISE lookup :: [(Int, Int)] -> Int -> Maybe Int #-}+```++A `SCC`++```haskell+{-# SCC bar #-}+```++#### Rule declarations++Without `forall`s++```haskell+{-# RULES+"foo/bar" foo = bar+ #-}+```++With `forall` but no type signatures++```haskell+{-# RULES+"piyo/pochi" forall a. piyo a = pochi a a+ #-}+```++With `forall` and type signatures++```haskell+{-# RULES+"hoge/fuga" forall (a :: Int). hoge a = fuga a a+ #-}+```++### Role annotation declarations++`normal`++```haskell+{-# LANGUAGE RoleAnnotations #-}++type role Foo nominal+```++`representational`++```haskell+{-# LANGUAGE RoleAnnotations #-}++type role Bar representational+```++`phantom`++```haskell+{-# LANGUAGE RoleAnnotations #-}++type role Baz phantom+```++### Type family declarations++Without annotations++```haskell+type family Id a+```++With annotations++```haskell+type family Id a :: *+```++With injectivity annotations++```haskell+type family Id a = r | r -> a+```++Closed type families++```haskell+type family Closed (a :: k) :: Bool where+  Closed (x @Int) = 'Int+  Closed x = 'True+```++### Type family instance declarations++Without holes++```haskell+type instance Id Int = Int+```++With a hole++```haskell+type instance Id _ = String+```++### Type signature declarations++Multiple function signatures at once++```haskell+a, b, c :: Int+```++Type using a numeric value++```haskell+f :: Foo 0+```++Type using a character value++```haskell+f :: Foo 'a'+```++Type using a unicode string value++```haskell+f :: Foo "あ"+```++A dot not enclosed by spaces is printed correctly if `OverloadedRecordDot` is not enabled.++```haskell given+f :: forall a.(Data a, Typeable a) => a+```++```haskell expect+f :: forall a. (Data a, Typeable a)+  => a+```++Short++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/390+fun :: Short+fun = undefined+```++Always break after `::` on overlong signatures++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/390+someFunctionSignature ::+     Wiiiiiiiiiiiiiiiiith+  -> Enough+  -> (Arguments -> To ())+  -> Overflow (The Line Limit)+```++A long type is broken into lines++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/359+thing ::+     ( ResB.BomEx+     , Maybe+         [( Entity BomSnapshot+          , ( [ResBS.OrderSubstituteAggr]+            , ( Maybe (Entity BomSnapshotHistory)+              , Maybe (Entity BomSnapshotHistory))))])+  -> [(ResB.BomEx, Maybe ResBS.BomSnapshotAggr)]+```++Long parameter list with a `forall`++```haskell+fooooooooo ::+     forall a.+     Fooooooooooooooo a+  -> Fooooooooooooooo a+  -> Fooooooooooooooo a+  -> Fooooooooooooooo a+```++Implicit parameters++```haskell+f :: (?x :: Int) => Int+```++Quasiquotes in types++```haskell+fun :: [a|bc|]+```++Implicit parameters++```haskell+f :: (?x :: Int) => Int+```++Tuples++```haskell+fun :: (a, b, c) -> (a, b)+```++Infix operator++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/301+(+) :: ()+```++With a record++```haskell+url :: r {url :: String} => r -> Integer+```++`forall` type++```haskell+f :: (forall a. Data a => a -> a) -> (forall a b. Data a => a -> b)+g :: forall a b. a -> b+```+++An infix operator containing `#`++```haskell+(#!) :: Int -> Int -> Int+```++Multiple line function signature inside a `where`++```haskell 4+foo = undefined+  where+    go :: Fooooooooooooooooooooooo+       -> Fooooooooooooooooooooooo+       -> Fooooooooooooooooooooooo+       -> Fooooooooooooooooooooooo+    go = undefined+```++Types with many type applications++```haskell+foo ::+     Foo+       LongLongType+       LongLongType+       LongLongType+       LongLongType+       LongLongType+       LongLongType+  -> Int+```++#### Promoted types++Class constraints should leave `::` on same line++``` haskell+-- see https://github.com/chrisdone/hindent/pull/266#issuecomment-244182805+fun ::+     (Class a, Class b)+  => fooooooooooo bar mu zot+  -> fooooooooooo bar mu zot+  -> c+```++An infix operator containing `#`++```haskell+(#!) :: Int -> Int -> Int+```++Prefix promoted symbol type constructor++```haskell+a :: '(T.:->) 'True 'False+b :: (T.:->) 'True 'False+c :: '(:->) 'True 'False+d :: (:->) 'True 'False+```++##### Promoted lists++Short++```haskell+fun1 :: Def ('[ Ref s (Stored Uint32), IBool] T.:-> IBool)+fun1 = undefined++fun2 :: Def ('[ Ref s (Stored Uint32), IBool] :-> IBool)+fun2 = undefined+```++Long++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/522+type OurContext+  = '[ AuthHandler W.Request (ExtendedPayloadWrapper UserSession)+     , BasicAuthCheck GameInstanceId+     , BasicAuthCheck (RegionId, RegionName)+     , BasicAuthCheck Alert.SourceId+     , M.MultipartOptions M.Tmp+     ]+```++Nested++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/348+a :: A '[ 'True]+-- nested promoted list with multiple elements.+b :: A '[ '[ 'True, 'False], '[ 'False, 'True]]+```++#### Symbol type constructors++Infix++```haskell+f :: a :?: b+```++Prefix++```haskell+f' :: (:?:) a b+```++#### Type signature with class constraints++Single++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/244+x :: Num a => a+x = undefined+```++Multiple++```haskell+fun :: (Class a, Class b) => a -> b -> c+```++Multiple without parentheses++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/554+g :: Semigroup a => Monoid a => Maybe a -> a+```++Long constraints++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/222+foo ::+     ( Foooooooooooooooooooooooooooooooooooooooooo+     , Foooooooooooooooooooooooooooooooooooooooooo+     )+  => A+```++Class constraints should leave `::` on same line++```haskell+-- see https://github.com/mihaimaruseac/hindent/pull/266#issuecomment-244182805+fun ::+     (Class a, Class b)+  => fooooooooooo bar mu zot+  -> fooooooooooo bar mu zot+  -> c+```++Symbol class constructor in class constraint++```haskell+f :: (a :?: b) => (a, b)+f' :: ((:?:) a b) => (a, b)+```++#### Unboxed types++Short unboxed sums++```haskell+{-# LANGUAGE UnboxedSums #-}++f :: (# (# Int, String #) | String #) -> (# Int | String #)+```++Long unboxed sums++```haskell+{-# LANGUAGE UnboxedSums #-}++f' ::+     (# (# Int, String #)+      | Either Bool Int+      | Either Bool Int+      | Either Bool Int+      | Either Bool Int+      | Either Bool Int+      | String #)+  -> (# Int | String #)+```++Large unboxed tuples++```haskell+{-# LANGUAGE UnboxedTuples #-}++f :: (# Looooooooooooooooooooooooooooooooooooooooooooong+      , Looooooooooooooooooooooooooooooooooooooooooooong+      , Looooooooooooooooooooooooooooooooooooooooooooong #)+```++### Type synonym declarations++Short++```haskell+type EventSource a = (AddHandler a, a -> IO ())+```++Long++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/290+type MyContext m+  = ( MonadState Int m+    , MonadReader Int m+    , MonadError Text m+    , MonadMask m+    , Monoid m+    , Functor m)+```++Very higher-kinded type++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/534+type SomeTypeSynonym+  = RecordWithManyFields+      FieldNumber1+      FieldNumber2+      FieldNumber3+      FieldNumber4+      FieldNumber5+      FieldNumber6+      FieldNumber7+      FieldNumber8+      FieldNumber9+      FieldNumber10+      FieldNumber11+      FieldNumber12+      FieldNumber13+      FieldNumber14+      FieldNumber15+```++Infix type constructor++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/417+type API = api1 :<|> api2+```++Type with a string++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/451+type Y = X "abc\n\n\ndef"+```++`TypeOperators`++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/277+{-# LANGUAGE TypeOperators #-}++type m ~> n = ()+```++#### Functional dependencies++Short++```haskell+-- https://github.com/commercialhaskell/hindent/issues/323+class Foo a b | a -> b where+  f :: a -> b+```++Long++```haskell+-- https://github.com/commercialhaskell/hindent/issues/323+class Foo a b c d e f+  | a b c d e -> f+  , a b c d f -> e+  , a b c e f -> d+  , a b d e f -> c+  , a c d e f -> b+  , b c d e f -> a+  where+  foo :: a -> b -> c -> d -> e -> f+```++#### With class constraints++Single++```haskell+-- https://github.com/commercialhaskell/hindent/issues/459+class Class1 a =>+      Class2 a+  where+  f :: a -> Int+```++Multiple++```haskell+-- https://github.com/commercialhaskell/hindent/issues/459+class (Eq a, Show a) =>+      Num a+  where+  (+), (-), (*) :: a -> a -> a+  negate :: a -> a+  abs, signum :: a -> a+  fromInteger :: Integer -> a+```++#### MINIMAL pragmas++Monad example++```haskell+class A where+  {-# MINIMAL return, ((>>=) | (join, fmap)) #-}+```++Very long names #310++```haskell+class A where+  {-# MINIMAL averylongnamewithnoparticularmeaning+            | ananotherverylongnamewithnomoremeaning #-}+```++## Expressions++A minus sign++```haskell+f = -(3 + 5)+```++Lists++```haskell+exceptions = [InvalidStatusCode, MissingContentHeader, InternalServerError]++exceptions =+  [ InvalidStatusCode+  , MissingContentHeader+  , InternalServerError+  , InvalidStatusCode+  , MissingContentHeader+  , InternalServerError+  ]+```++Multi-way if++```haskell+x =+  if | x <- Just x+     , x <- Just x ->+       case x of+         Just x -> e+         Nothing -> p+     | otherwise -> e+```++Type application++```haskell+{-# LANGUAGE TypeApplications #-}++fun @Int 12+```++An expression with a SCC pragma++```haskell+foo = {-# SCC foo #-} undefined+```++A hole++```haskell+foo = 3 + _+```++Implicit value++```haskell+foo = ?undefined+```++`UnboxedSums`++```haskell+{-# LANGUAGE UnboxedSums #-}++f = (# | Bool #)+```++`StaticPointers`++```haskell+{-# LANGUAGE StaticPointers #-}++f = static 1+```++`OverloadedLabels`++```haskell+{-# LANGUAGE OverloadedLabels #-}++f = #foo+```++### Arrows++`-<`++```haskell+{-# LANGUAGE Arrows #-}++f =+  proc foo -> do+    bar -< baz+    aaa >- bbb+```++`-<<`++```haskell+{-# LANGUAGE Arrows #-}++f =+  proc foo -> do+    g bar -<< baz+    aaaaa >>- h bbb+```++`(| ... |)`++```haskell+{-# LANGUAGE Arrows #-}++f = proc g -> (|foo (bar -< g) (baz -< g)|) zz+```++Lambda equation.++```haskell+{-# LANGUAGE Arrows #-}++f = proc g -> \x -> x -< g+```++Case expression.++```haskell+{-# LANGUAGE Arrows #-}++f =+  proc g ->+    case h of+      [] -> i -< ()+      (_:_) -> j -< ()+```++Lambda case++```haskell+{-# LANGUAGE Arrows #-}+{-# LANGUAGE LambdaCase #-}++f =+  proc g ->+    \case+      _ -> h -< ()+```++`if ... then ... else`++```haskell+{-# LANGUAGE Arrows #-}++f =+  proc g ->+    if x+      then h -< g+      else t -< g+```++`let ... in`++```haskell+{-# LANGUAGE Arrows #-}++f =+  proc g ->+    let x = undefined+        y = undefined+     in returnA -< g+```++### Case expressions++Normal case++```haskell+strToMonth :: String -> Int+strToMonth month =+  case month of+    "Jan" -> 1+    "Feb" -> 2+    _ -> error $ "Unknown month " ++ month+```++Inside a `where` and `do`++```haskell+g x =+  case x of+    a -> x+  where+    foo =+      case x of+        _ -> do+          launchMissiles+      where+        y = 2+```++Empty case++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/414+{-# LANGUAGE EmptyCase #-}++f1 = case () of {}+```++Empty lambda case++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/414+{-# LANGUAGE EmptyCase #-}+{-# LANGUAGE LambdaCase #-}++f2 = \case {}+```++A guard in a case++```haskell+f =+  case g of+    []+      | even h -> Nothing+    _ -> undefined+```++cases++```haskell since 9.4.1+foo =+  \cases+    1 1 -> 1+    _ _ -> 2+```++### `do` expressions++Long function applications++```haskell+test = do+  alphaBetaGamma deltaEpsilonZeta etaThetaIota kappaLambdaMu nuXiOmicron piRh79+  alphaBetaGamma deltaEpsilonZeta etaThetaIota kappaLambdaMu nuXiOmicron piRho80+  alphaBetaGamma+    deltaEpsilonZeta+    etaThetaIota+    kappaLambdaMu+    nuXiOmicron+    piRhoS81+```++Do as a left-hand side of an infix operation++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/238+-- https://github.com/mihaimaruseac/hindent/issues/296+block =+  do ds <- inBraces $ inWhiteSpace declarations+     return $ Block ds+     <?> "block"+```++#### Bindings++Short++```haskell+foo = do+  mcp <- findCabalFiles (takeDirectory abssrcpath) (takeFileName abssrcpath)+  print mcp+```++Large++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/221+x = do+  config <- execParser options+  comments <-+    case config of+      Diff False args -> commentsFromDiff args+      Diff True args -> commentsFromDiff ("--cached" : args)+      Files args -> commentsFromFiles args+  mapM_ (putStrLn . Fixme.formatTodo) (concatMap Fixme.getTodos comments)+```++#### `let` bindings++With type signatures but no class constraints++```haskell+f = do+  let g :: Int+      g = 3+  print g+```++With both type signatures and class constraints++```haskell+f = do+  let try :: Typeable b => b+      try = undefined+  undefined+```++#### `RecursiveDo`++`rec`++```haskell+{-# LANGUAGE RecursiveDo #-}++f = do+  a <- foo+  rec b <- a c+      c <- a b+  return $ b + c+```++`mdo`++```haskell+{-# LANGUAGE RecursiveDo #-}++g = mdo+  foo+  bar+```++### Function applications++Long line, tuple++```haskell+test+  (alphaBetaGamma, deltaEpsilonZeta, etaThetaIota, kappaLambdaMu, nuXiOmicro79)+  (alphaBetaGamma, deltaEpsilonZeta, etaThetaIota, kappaLambdaMu, nuXiOmicron80)+  ( alphaBetaGamma+  , deltaEpsilonZeta+  , etaThetaIota+  , kappaLambdaMu+  , nuXiOmicronP81)+```++Long line, tuple section++```haskell+test+  (, alphaBetaGamma, , deltaEpsilonZeta, , etaThetaIota, kappaLambdaMu, nu79, )+  (, alphaBetaGamma, , deltaEpsilonZeta, , etaThetaIota, kappaLambdaMu, , n80, )+  (+  , alphaBetaGamma+  ,+  , deltaEpsilonZeta+  ,+  , etaThetaIota+  , kappaLambdaMu+  ,+  , nu81+  ,)+```++Linebreaks after very short names if the total line length goes over the limit++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/405+t =+  f "this is a very loooooooooooooooooooooooooooong string that goes over the line length"+    argx+    argy+    argz++t =+  function+    "this is a very loooooooooooooooooooooooooooong string that goes over the line length"+    argx+    argy+    argz+```++### Lambda expressions++Lazy patterns++```haskell+f = \ ~a -> undefined+-- \~a yields parse error on input ‘\~’+```++Bang patterns++```haskell+f = \ !a -> undefined+-- \!a yields parse error on input ‘\!’+```++An infix operator with a lambda expression++```haskell+for xs $ \x -> do+  left x+  right x+```++Nested lambdas++```haskell+foo :: IO ()+foo =+  alloca 10 $ \a ->+    alloca 20 $ \b ->+      cFunction fooo barrr muuu (fooo barrr muuu) (fooo barrr muuu)+```++In a `case`++```haskell+f x =+  case filter (\y -> isHappy y x) of+    [] -> Nothing+    (z:_) -> Just (\a b -> makeSmile z a b)+```++### Let ... in expressions++With bang parameters++```haskell+f =+  let !x = 3+   in x+```++With implicit parameters++```haskell+f =+  let ?x = 42+   in f+```++inside a `do`++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/467+main :: IO ()+main = do+  let x = 5+   in when (x > 0) (return ())+```++### List comprehensions++Short++```haskell+map f xs = [f x | x <- xs]+```++Long++```haskell+defaultExtensions =+  [ e+  | EnableExtension {extensionField1 = extensionField1} <-+      knownExtensions knownExtensions+  , let a = b+    -- comment+  , let c = d+    -- comment+  ]+```++Another long one++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/357+foo =+  [ (x, y)+  | x <- [1 .. 10]+  , y <- [11 .. 20]+  , even x+  , even x+  , even x+  , even x+  , even x+  , odd y+  ]+```++With operators++```haskell+defaultExtensions =+  [e | e@EnableExtension {} <- knownExtensions] \\+  map EnableExtension badExtensions+```++Transform list comprehensions++```haskell+list =+  [ (x, y, map the v)+  | x <- [1 .. 10]+  , y <- [1 .. 10]+  , let v = x + y+  , then group by v using groupWith+  , then take 10+  , then group using permutations+  , t <- concat v+  , then takeWhile by t < 3+  ]+```++#### Parallel list comprehensions++Short++```haskell+zip xs ys = [(x, y) | x <- xs | y <- ys]+```++Long++```haskell+fun xs ys =+  [ (alphaBetaGamma, deltaEpsilonZeta)+  | x <- xs+  , z <- zs+  | y <- ys+  , cond+  , let t = t+  ]+```++### Operators++Bad++```haskell+x =+  Value <$> thing <*> secondThing <*> thirdThing <*> fourthThing <*>+  Just thisissolong <*>+  Just stilllonger <*>+  evenlonger+```++Good++```haskell pending+x =+  Value <$> thing <*> secondThing <*> thirdThing <*> fourthThing <*>+  Just thisissolong <*> Just stilllonger <*> evenlonger+```++With `do`++```haskell+for xs $ do+  left x+  right x+```++With lambda-case++```haskell+for xs $ \case+  Left x -> x+```++`$` chain++```haskell+f =+  Right $+  S.lazyByteStrings $ addPrefix prefix $ S.toLazyByteString $ prettyPrint m+```++Qualified operator as an argument++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/273+foo = foldr1 (V.++) [V.empty, V.empty]+```++Apply an infix operator in prefix style++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/273+ys = (++) [] []+```++Qualified operator++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/273+xs = V.empty V.++ V.empty+```++In parentheses++```haskell+cat = (++)+```++Qualified operator in parentheses++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/273+cons = (V.++)+```++A list constructor enclosed by parentheses++```haskell+cons = (:)+```++A data constructor enclosed by parentheses++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/422+data T a =+  a :@ a++test = (:@)+```++Force indent and print RHS in a top-level expression++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/473+template $+  haskell+    [ SomeVeryLongName+    , AnotherLongNameEvenLongToBreakTheLine+    , LastLongNameInList+    ]+```++### Primitive type values++`Char`++```haskell+a = 'a'+```++`\n` as a `Char`++```haskell+a = '\n'+```++`String` with a `\n`++```haskell+a = "bcd\nefgh"+```++Multiple line string++```haskell+foo =+  "hoge \+ \ fuga"+  where+    bar =+      "foo \+     \ bar"+```++Hex integers++```haskell+a = 0xa5+```++Unboxed integers++```haskell+a = 0#+```++Unboxed floating point numbers++```haskell+a = 3.3#+```++Unboxed `Char`++```haskell+a = 'c'#+```++Unboxed `String`++```haskell+a = "Foo"#+```++`NumericUnderscores`++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/542+{-# LANGUAGE NumericUnderscores #-}++foo = 10_000+```++### Quasi-quotes++Body has multiple lines.++```haskell+{-# LANGUAGE QuasiQuotes #-}++f =+  [s|First line+Second line|]+```++Body has a top-level declaration.++```haskell+{-# LANGUAGE QuasiQuotes #-}++f =+  [d| f :: Int -> Int+      f = undefined |]+```++Typed quote.++```haskell+f = [||a||]+```++Preserve the trailing newline.++```haskell+{-# LANGUAGE QuasiQuotes #-}++f =+  [s|foo+|]+```+### Ranges++from++```haskell+a = [1 ..]+```++from to++```haskell+a = [1 .. 9]+```++from then++```haskell+b = [1,3 ..]+```++from then to++```haskell+c = [1,3 .. 9]+```++### Records++No fields++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/366+foo = Nothing {}+```++Short++```haskell+getGitProvider :: EventProvider GitRecord ()+getGitProvider =+  EventProvider {getModuleName = "Git", getEvents = getRepoCommits}+```++Medium++```haskell+commitToEvent :: FolderPath -> TimeZone -> Commit -> Event.Event+commitToEvent gitFolderPath timezone commit =+  Event.Event+    {pluginName = getModuleName getGitProvider, eventIcon = "glyphicon-cog"}+```++Long++```haskell+commitToEvent :: FolderPath -> TimeZone -> Commit -> Event.Event+commitToEvent gitFolderPath timezone commit =+  Event.Event+    { pluginName = getModuleName getGitProvider+    , eventIcon = "glyphicon-cog"+    , eventDate = localTimeToUTC timezone (commitDate commit)+    }+```++Another long one++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/358+foo =+  assert+    sanityCheck+    BomSnapshotAggr+      { snapshot = Just bs+      , previousId = M.bomSnapshotHistoryPreviousId . entityVal <$> bsp+      , nextId = M.bomSnapshotHistoryNextId . entityVal <$> bsn+      , bomEx = bx''+      , orderSubstitutes =+          S.fromList . map OrderSubstituteAggrByCreatedAtAsc $ subs+      , snapshotSubstitute = msub+      }+```++Record body may be in one line even if a new line is inserted after the variable name.++```haskell+addCommentsToNode mkNodeComment newComments nodeInfo@(NodeInfo (SrcSpanInfo _ _) existingComments) =+  nodeInfo+    {nodeInfoComments = existingComments <> map mkBeforeNodeComment newComments}+```++Symbol constructor++```haskell+f = (:..?) {}+```++Symbol field++```haskell+f x = x {(..?) = wat}++g x = Rec {(..?)}+```++A field updater in a `do` inside a `let ... in`.++```haskell+f = undefined+  where+    g h =+      let x = undefined+       in do foo+             pure+               h+                 { grhssLocalBinds =+                     HsValBinds x (ValBinds (newSigs newSigMethods))+                 }+```++`OverloadedRecordDot`++```haskell since 9.2.2+{-# LANGUAGE OverloadedRecordDot #-}++data Rectangle = Rectangle+  { width :: Int+  , height :: Int+  }++area :: Rectangle -> Int+area r = r.width * r.height++foo = (.x.y)+```++`OverloadedRecordUpdate`++```haskell since 9.2.0+{-# LANGUAGE OverloadedRecordDot #-}+{-# LANGUAGE OverloadedRecordUpdate #-}++foo = bar {baz.qux = 1}+```++### Sections++With a LHS++```haskell+double = (2 *)+```++With a RHS++```haskell+halve = (/ 2)+```++With a large RHS++```haskell+foo =+  (`elem` concat+            [ [20, 68, 92, 112, 28, 124, 116, 80]+            , [21, 84, 87, 221, 127, 255, 241, 17]+            ])+```++## Template Haskell++Expression brackets++```haskell+add1 x = [|x + 1|]+```++Pattern brackets++```haskell+mkPat = [p|(x, y)|]+```++Type brackets++```haskell+foo :: $([t|Bool|]) -> a+```++A quoted TH name from a type name++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/412+data (-)++q = ''(-)+```++Quoted list constructors++```haskell+cons = '(:)+```++Pattern splices++```haskell+f $pat = ()++g =+  case x of+    $(mkPat y z) -> True+    _ -> False+```++Typed splice++```haskell+foo = $$bar+```++## Comments++Only comments++```haskell+-- foo+```++Double comments in a line++```haskell+f = undefined {- Comment 1 -} {- Comment 2 -} -- Comment 3+```++Comments within a declaration++```haskell+bob -- after bob+ =+  foo -- next to foo+  -- line after foo+    (bar+       foo -- next to bar foo+       bar -- next to bar+     ) -- next to the end paren of (bar)+    -- line after (bar)+    mu -- next to mu+    -- line after mu+    -- another line after mu+    zot -- next to zot+    -- line after zot+    (case casey -- after casey+           of+       Just -- after Just+        -> do+         justice -- after justice+          *+           foo+             (blah * blah + z + 2 / 4 + a - -- before a line break+              2 * -- inside this mess+              z /+              2 /+              2 /+              aooooo /+              aaaaa -- bob comment+              ) ++           (sdfsdfsd fsdfsdf) -- blah comment+         putStrLn "")+    [1, 2, 3]+    [ 1 -- foo+    , ( 2 -- bar+      , 2.5 -- mu+       )+    , 3+    ]+    -- in the end of the function+  where+    alpha = alpha+    -- between alpha and beta+    beta = beta+    -- after beta++foo = 1 -- after foo++gamma = do+  delta+  epsilon+  -- in the end of a do-block 1++gamma = do+  delta+  epsilon+  -- the very last block is detected differently+```++Doesn't work yet (wrong comment position detection)++```haskell pending+gamma = do+  -- in the beginning of a do-block+  delta+  where+    -- before alpha+    alpha = alpha+```++Comments in a class declaration++```haskell+class Foo a+    -- A comment+  where+  foo :: a -> Int+```++Comments in a class instance++```haskell+instance Pretty MatchForCase+  -- TODO: Do not forget to handle comments!+                                             where+  pretty' = undefined+```++Haddock comments++```haskell+-- | Module comment.+module X where++-- | Main doc.+main :: IO ()+main = return ()++data X+  = X -- ^ X is for xylophone.+  | Y -- ^ Y is for why did I eat that pizza.++data X = X+  { field1 :: Int -- ^ Field1 is the first field.+  , field11 :: Char+    -- ^ This field comment is on its own line.+  , field2 :: Int -- ^ Field2 is the second field.+  , field3 :: Char -- ^ This is a long comment which starts next to+    -- the field but continues onto the next line, it aligns exactly+    -- with the field name.+  , field4 :: Char+    -- ^ This is a long comment which starts on the following line+    -- from from the field, lines continue at the sme column.+  }++foo ::+     String -- ^ Reason for eating pizza.+  -> Int -- ^ How many did you eat pizza?+  -> String -- ^ The report.+foo = undefined+```++Module header with haddock comments++```haskell+-- | A module+module HIndent -- Foo+  ( -- * Formatting functions.+    reformat+  , -- * Testing+    test+  ) where+```++Comments around regular declarations++```haskell+-- This is some random comment.+-- | Main entry point.+main = putStrLn "Hello, World!"+-- This is another random comment.+```++Multi-line comments++```haskell+bob {- after bob -}+ =+  foo {- next to foo -}+  {- line after foo -}+    (bar+       foo {- next to bar foo -}+       bar {- next to bar -}+     ) {- next to the end paren of (bar) -}+    {- line after (bar) -}+    mu {- next to mu -}+    {- line after mu -}+    {- another line after mu -}+    zot {- next to zot -}+    {- line after zot -}+    (case casey {- after casey -}+           of+       Just {- after Just -}+        -> do+         justice {- after justice -}+          *+           foo+             (blah * blah + z + 2 / 4 + a - {- before a line break -}+              2 * {- inside this mess -}+              z /+              2 /+              2 /+              aooooo /+              aaaaa {- bob comment -}+              ) ++           (sdfsdfsd fsdfsdf) {- blah comment -}+         putStrLn "")+    [1, 2, 3]+    [ 1 {- foo -}+    , ( 2 {- bar -}+      , 2.5 {- mu -}+       )+    , 3+    ]++foo = 1 {- after foo -}+```++Multi-line comments with multi-line contents++```haskell+{- | This is some random comment.+Here is more docs and such.+Etc.+-}+main = putStrLn "Hello, World!"+{- This is another random comment. -}+```++Comments on functions in where clause++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/540+topLevelFunc1 = f+  where+    -- comment on func in where clause+    -- stays in the where clause+    f = undefined++topLevelFunc2 = f . g+    -- Another comment+  where+    {- multi+       line+       comment -}+    f = undefined -- single line comment+    -- single line comment+        -- Different size of indent+    g :: a+    g = undefined+```++Comments in a 'where' clause++```haskell+foo = undefined+  where+    bar+      -- A comment+     = undefined+      where+        a = b+    baz = undefined+```++Haddocks around data constructors++```haskell+data Foo+    -- | A haddock comment for 'Bar'.+  = Bar+    -- | A haddock comment for 'Baz'.+  | Baz+    -- | A haddock comment for 'Quuz'.+  | Quuz+```++## Identifiers++Unicode++```haskell+α = γ * "ω"+-- υ+```++`rec` and `mdo` are valid identifiers unless `RecursiveDo` is enabled++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/328+rec = undefined++mdo = undefined+```++The first character of an infix operator can be `@` unless `TypeApplications` is enabled.++```haskell+-- https://github.com/mihaimaruseac/hindent/issues/421+a @: b = a + b++main = print (2 @: 2)+```++## Complex input++A complex, slow-to-print decl++```haskell+quasiQuotes =+  [ ( ''[]+    , \(typeVariable:_) _automaticPrinter ->+        (let presentVar = varE (presentVarName typeVariable)+          in lamE+               [varP (presentVarName typeVariable)]+               [|(let typeString = "[" ++ fst $(presentVar) ++ "]"+                   in ( typeString+                      , \xs ->+                          case fst $(presentVar) of+                            "GHC.Types.Char" ->+                              ChoicePresentation+                                "String"+                                [ ( "String"+                                  , StringPresentation+                                      "String"+                                      (concatMap+                                         getCh+                                         (map (snd $(presentVar)) xs)))+                                , ( "List of characters"+                                  , ListPresentation+                                      typeString+                                      (map (snd $(presentVar)) xs))+                                ]+                              where getCh (CharPresentation "GHC.Types.Char" ch) =+                                      ch+                                    getCh (ChoicePresentation _ ((_, CharPresentation _ ch):_)) =+                                      ch+                                    getCh _ = ""+                            _ ->+                              ListPresentation+                                typeString+                                (map (snd $(presentVar)) xs)))|]))+  ]+```++Random snippet from hindent itself++```haskell+exp' (App _ op a) = do+  (fits, st) <- fitsOnOneLine (spaced (map pretty (f : args)))+  if fits+    then put st+    else do+      pretty f+      newline+      spaces <- getIndentSpaces+      indented spaces (lined (map pretty args))+  where+    (f, args) = flatten op [a]+    flatten :: Exp NodeInfo -> [Exp NodeInfo] -> (Exp NodeInfo, [Exp NodeInfo])+    flatten (App _ f' a') b = flatten f' (a' : b)+    flatten f' as = (f', as)+```++Quasi quotes++```haskell+exp = [name|exp|]++f [qq|pattern|] = ()+```++## C preprocessor++Conditionals (`#if`)++```haskell+isDebug :: Bool+#if DEBUG+isDebug = True+#else+isDebug = False+#endif+```++Macro definitions (`#define`)++```haskell+#define STRINGIFY(x) #x+f = STRINGIFY (y)+```++Escaped newlines++```haskell+#define LONG_MACRO_DEFINITION \+  data Pair a b = Pair \+    { first :: a \+    , second :: b \+    }+#define SHORT_MACRO_DEFINITION \+  x ```

@@ -0,0 +1,150 @@+{-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE Unsafe #-}++-- | Main entry point to hindent.+--+-- hindent+module Main+  ( main+  ) where++import Control.Applicative+import Control.Exception+import Control.Monad+import qualified Data.ByteString as S+import qualified Data.ByteString.Builder as S+import qualified Data.ByteString.Lazy.Char8 as L8+import Data.Maybe+import qualified Data.Text as T+import Data.Version (showVersion)+import Foreign.C.Error+import GHC.IO.Exception+import HIndent+import HIndent.CabalFile+import HIndent.Config+import HIndent.LanguageExtension+import HIndent.LanguageExtension.Types+import Options.Applicative hiding (action, style)+import Paths_hindent (version)+import qualified System.Directory as IO+import System.Exit (exitWith)+import qualified System.IO as IO++data Action+  = Validate+  | Reformat++data RunMode+  = ShowVersion+  | Run Config [Extension] Action [FilePath]++-- | Main entry point.+main :: IO ()+main = do+  config <- getConfig+  runMode <-+    execParser+      (info+         (options config <**> helper)+         (header "hindent - Reformat Haskell source code"))+  case runMode of+    ShowVersion -> putStrLn ("hindent " ++ showVersion version)+    Run style exts action paths ->+      if null paths+        then L8.interact+               (either error S.toLazyByteString .+                reformat style (Just exts) Nothing . L8.toStrict)+        else forM_ paths $ \filepath -> do+               cabalexts <- getCabalExtensionsForSourcePath filepath+               text <- S.readFile filepath+               case reformat+                      style+                      (Just $ cabalexts ++ exts)+                      (Just filepath)+                      text of+                 Left e -> error e+                 Right out ->+                   unless (L8.fromStrict text == S.toLazyByteString out) $+                   case action of+                     Validate -> do+                       IO.putStrLn $ filepath ++ " is not formatted"+                       exitWith (ExitFailure 1)+                     Reformat -> do+                       tmpDir <- IO.getTemporaryDirectory+                       (fp, h) <- IO.openTempFile tmpDir "hindent.hs"+                       L8.hPutStr h (S.toLazyByteString out)+                       IO.hFlush h+                       IO.hClose h+                       let exdev e =+                             if ioe_errno e == Just ((\(Errno a) -> a) eXDEV)+                               then IO.copyFile fp filepath >> IO.removeFile fp+                               else throw e+                       IO.copyPermissions filepath fp+                       IO.renameFile fp filepath `catch` exdev++-- | Program options.+options :: Config -> Parser RunMode+options config =+  flag' ShowVersion (long "version" <> help "Print the version") <|>+  (Run <$> style <*> exts <*> action <*> files)+  where+    style =+      (makeStyle config <$> lineLen <*> indentSpaces <*> trailingNewline <*>+       sortImports) <*+      optional+        (strOption+           (long "style" <>+            help "Style to print with (historical, now ignored)" <>+            metavar "STYLE") :: Parser String)+    exts =+      fmap+        getExtensions+        (many+           (T.pack <$>+            strOption+              (short 'X' <> help "Language extension" <> metavar "GHCEXT")))+    indentSpaces =+      option+        auto+        (long "indent-size" <>+         help "Indentation size in spaces" <>+         value (configIndentSpaces config) <> showDefault) <|>+      option+        auto+        (long "tab-size" <> help "Same as --indent-size, for compatibility")+    lineLen =+      option+        auto+        (long "line-length" <>+         help "Desired length of lines" <>+         value (configMaxColumns config) <> showDefault)+    trailingNewline =+      not <$>+      flag+        (not (configTrailingNewline config))+        (configTrailingNewline config)+        (long "no-force-newline" <>+         help "Don't force a trailing newline" <> showDefault)+    sortImports =+      flag+        Nothing+        (Just True)+        (long "sort-imports" <> help "Sort imports in groups" <> showDefault) <|>+      flag+        Nothing+        (Just False)+        (long "no-sort-imports" <> help "Don't sort imports")+    action =+      flag+        Reformat+        Validate+        (long "validate" <>+         help "Check if files are formatted without changing them")+    makeStyle s mlen tabs trailing imports =+      s+        { configMaxColumns = mlen+        , configIndentSpaces = tabs+        , configTrailingNewline = trailing+        , configSortImports = fromMaybe (configSortImports s) imports+        }+    files = many (strArgument (metavar "FILENAMES"))

@@ -0,0 +1,47 @@+{-# LANGUAGE BangPatterns #-}+{-# LANGUAGE OverloadedStrings #-}++-- | Benchmark the pretty printer.+module Main where++import Control.DeepSeq+import Criterion+import Criterion.Main+import qualified Data.ByteString as S+import qualified Data.ByteString.Builder as S+import qualified Data.ByteString.Char8 as S8+import qualified Data.ByteString.UTF8 as UTF8+import HIndent+import HIndent.Config+import HIndent.Internal.Test.Markdone+import HIndent.LanguageExtension++-- | Main benchmarks.+main :: IO ()+main = do+  bytes <- S.readFile "BENCHMARKS.md"+  !forest <- fmap force (parse (tokenize bytes))+  defaultMain (toCriterion forest)++-- | Convert the Markdone document to Criterion benchmarks.+toCriterion :: [Markdone] -> [Benchmark]+toCriterion = go+  where+    go (Section name children:next) =+      bgroup (S8.unpack name) (go children) : go next+    go (PlainText desc:CodeFence lang code:next) =+      if lang == "haskell"+        then (bench+                (UTF8.toString desc)+                (nf+                   (either error S.toLazyByteString .+                    reformat+                      HIndent.Config.defaultConfig+                      (Just defaultExtensions)+                      Nothing)+                   code)) :+             go next+        else go next+    go (PlainText {}:next) = go next+    go (CodeFence {}:next) = go next+    go [] = []

@@ -1,113 +1,260 @@-name:                hindent-version:             5.3.4-synopsis:            Extensible Haskell pretty printer-description:         Extensible Haskell pretty printer. Both a library and an executable.-                     .-                     See the Github page for usage\/explanation: <https://github.com/mihaimaruseac/hindent>-license:             BSD3-stability:           Unstable-license-file:        LICENSE.md-author:              Mihai Maruseac, Chris Done, Andrew Gibiansky, Tobias Pflug, Pierre Radermecker-maintainer:          Mihai Maruseac-copyright:           2014 Chris Done, 2015 Andrew Gibiansky, 2021 Mihai Maruseac-category:            Development-build-type:          Simple-cabal-version:       >=1.10-homepage:            https://github.com/mihaimaruseac/hindent-bug-reports:         https://github.com/mihaimaruseac/hindent/issues-data-files:          elisp/hindent.el+cabal-version: 2.0++-- This file has been generated from package.yaml by hpack version 0.34.4.+--+-- see: https://github.com/sol/hpack++name:           hindent+version:        6.0.0+synopsis:       Extensible Haskell pretty printer+description:    Extensible Haskell pretty printer. Both a library and an executable. See the GitHub page for usage/explanation: <https://github.com/mihaimaruseac/hindent>+category:       Development+stability:      Unstable+homepage:       https://github.com/mihaimaruseac/hindent+bug-reports:    https://github.com/mihaimaruseac/hindent/issues+author:         Mihai Maruseac, Chris Done, Andrew Gibiansky, Tobias Pflug, Pierre Radermecker+maintainer:     Mihai Maruseac+copyright:      2014 Chris Done, 2015 Andrew Gibiansky, 2021 Mihai Maruseac+license:        BSD3+license-file:   LICENSE.md+build-type:     Simple extra-source-files:- README.md- CHANGELOG.md- BENCHMARKS.md- TESTS.md+    README.md+    CHANGELOG.md+    BENCHMARKS.md+    TESTS.md+data-files:+    elisp/hindent.el  source-repository head-    type:           git-    location:       https://github.com/mihaimaruseac/hindent+  type: git+  location: https://github.com/mihaimaruseac/hindent  library-  hs-source-dirs:    src/-  ghc-options:       -Wall -O2-  default-language:  Haskell2010-  exposed-modules:   HIndent-                     HIndent.Types-                     HIndent.Pretty-                     HIndent.CabalFile-                     HIndent.CodeBlock-  build-depends:     base >= 4.7 && <5-                   , containers-                   , Cabal-                   , filepath-                   , directory-                   , haskell-src-exts >= 1.20-                   , monad-loops-                   , mtl-                   , bytestring-                   , utf8-string-                   , transformers-                   , exceptions-                   , text-                   , yaml+  exposed-modules:+      HIndent+      HIndent.Applicative+      HIndent.CabalFile+      HIndent.CodeBlock+      HIndent.Config+      HIndent.Language+      HIndent.LanguageExtension+      HIndent.LanguageExtension.Conversion+      HIndent.LanguageExtension.Types+      HIndent.ModulePreprocessing+      HIndent.ModulePreprocessing.CommentRelocation+      HIndent.Parse+      HIndent.Path.Find+      HIndent.Pragma+      HIndent.Pretty+      HIndent.Pretty.Combinators+      HIndent.Pretty.Combinators.Comment+      HIndent.Pretty.Combinators.Getter+      HIndent.Pretty.Combinators.Indent+      HIndent.Pretty.Combinators.Lineup+      HIndent.Pretty.Combinators.Op+      HIndent.Pretty.Combinators.Outputable+      HIndent.Pretty.Combinators.RhsSeparator+      HIndent.Pretty.Combinators.String+      HIndent.Pretty.Combinators.Switch+      HIndent.Pretty.Combinators.Wrap+      HIndent.Pretty.Import+      HIndent.Pretty.Import.Sort+      HIndent.Pretty.NodeComments+      HIndent.Pretty.Pragma+      HIndent.Pretty.SigBindFamily+      HIndent.Pretty.Types+      HIndent.Printer+  other-modules:+      Paths_hindent+  hs-source-dirs:+      src+  ghc-options: -Wall -O2+  build-depends:+      Cabal+    , base >=4.7 && <5+    , bytestring+    , containers+    , directory+    , exceptions+    , filepath+    , ghc-lib-parser-ex+    , monad-loops+    , mtl+    , path+    , path-io+    , regex-tdfa+    , split+    , syb+    , text+    , transformers+    , unicode-show+    , utf8-string+    , yaml+  if impl(ghc >= 9.4.1)+    build-depends:+        ghc-lib-parser >=9.4.1.20220807 && <9.5+  else+    build-depends:+        ghc-lib-parser >=9.2.3.20220527 && <9.3+  default-language: Haskell2010 +library hindent-internal+  exposed-modules:+      HIndent.Internal.Test.Markdone+  other-modules:+      Paths_hindent+  hs-source-dirs:+      internal+  ghc-options: -Wall -O2+  build-depends:+      Cabal+    , base >=4.7 && <5+    , bytestring+    , containers+    , deepseq+    , directory+    , exceptions+    , filepath+    , ghc-lib-parser-ex+    , monad-loops+    , mtl+    , path+    , path-io+    , regex-tdfa+    , split+    , syb+    , text+    , transformers+    , unicode-show+    , utf8-string+    , yaml+  if impl(ghc >= 9.4.1)+    build-depends:+        ghc-lib-parser >=9.4.1.20220807 && <9.5+  else+    build-depends:+        ghc-lib-parser >=9.2.3.20220527 && <9.3+  default-language: Haskell2010+ executable hindent-  hs-source-dirs:    src/main-  ghc-options:       -Wall -O2-  default-language:  Haskell2010-  main-is:           Main.hs-  other-modules: Path.Find-  build-depends:     base >= 4 && < 5-                   , hindent-                   , bytestring-                   , utf8-string-                   , haskell-src-exts-                   , ghc-prim-                   , directory-                   , text-                   , yaml-                   , unix-compat-                   , deepseq-                   , path-                   , path-io-                   , transformers-                   , exceptions-                   , optparse-applicative+  main-is: Main.hs+  other-modules:+      Paths_hindent+  autogen-modules:+      Paths_hindent+  hs-source-dirs:+      app+  ghc-options: -Wall -O2+  build-depends:+      Cabal+    , base >=4.7 && <5+    , bytestring+    , containers+    , directory+    , exceptions+    , filepath+    , ghc-lib-parser-ex+    , hindent+    , monad-loops+    , mtl+    , optparse-applicative+    , path+    , path-io+    , regex-tdfa+    , split+    , syb+    , text+    , transformers+    , unicode-show+    , utf8-string+    , yaml+  if impl(ghc >= 9.4.1)+    build-depends:+        ghc-lib-parser >=9.4.1.20220807 && <9.5+  else+    build-depends:+        ghc-lib-parser >=9.2.3.20220527 && <9.3+  default-language: Haskell2010  test-suite hindent-test   type: exitcode-stdio-1.0-  hs-source-dirs: src/main/-  default-language:  Haskell2010-  main-is: Test.hs-  other-modules: Markdone-  build-depends:     base >= 4 && <5-                   , hindent-                   , haskell-src-exts-                   , monad-loops-                   , mtl-                   , bytestring-                   , utf8-string-                   , hspec-                   , directory-                   , deepseq-                   , exceptions-                   , utf8-string-                   , Diff+  main-is: Main.hs+  other-modules:+      Paths_hindent+  hs-source-dirs:+      tests+  ghc-options: -Wall -O2+  build-depends:+      Cabal+    , Diff+    , base >=4.7 && <5+    , bytestring+    , containers+    , directory+    , exceptions+    , filepath+    , ghc-lib-parser-ex+    , hindent+    , hindent-internal+    , hspec+    , monad-loops+    , mtl+    , path+    , path-io+    , regex-tdfa+    , split+    , syb+    , text+    , transformers+    , unicode-show+    , utf8-string+    , yaml+  if impl(ghc >= 9.4.1)+    build-depends:+        ghc-lib-parser >=9.4.1.20220807 && <9.5+  else+    build-depends:+        ghc-lib-parser >=9.2.3.20220527 && <9.3+  default-language: Haskell2010  benchmark hindent-bench   type: exitcode-stdio-1.0-  hs-source-dirs:    src/main-  default-language:  Haskell2010-  ghc-options:       -Wall -O2 -rtsopts-  main-is:           Benchmark.hs-  other-modules: Markdone-  build-depends:     base >= 4 && < 5-                   , hindent-                   , bytestring-                   , utf8-string-                   , haskell-src-exts-                   , ghc-prim-                   , directory-                   , criterion-                   , deepseq-                   , exceptions-                   , mtl+  main-is: Main.hs+  other-modules:+      Paths_hindent+  hs-source-dirs:+      benchmarks+  ghc-options: -Wall -O2+  build-depends:+      Cabal+    , base >=4.7 && <5+    , bytestring+    , containers+    , criterion+    , deepseq+    , directory+    , exceptions+    , filepath+    , ghc-lib-parser-ex+    , hindent+    , hindent-internal+    , monad-loops+    , mtl+    , path+    , path-io+    , regex-tdfa+    , split+    , syb+    , text+    , transformers+    , unicode-show+    , utf8-string+    , yaml+  if impl(ghc >= 9.4.1)+    build-depends:+        ghc-lib-parser >=9.4.1.20220807 && <9.5+  else+    build-depends:+        ghc-lib-parser >=9.2.3.20220527 && <9.3+  default-language: Haskell2010

@@ -0,0 +1,133 @@+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE DeriveGeneric #-}+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE OverloadedStrings #-}++-- | A subset of markdown that only supports @#headings@ and code+-- fences.+--+-- All content must be in section headings with proper hierarchy,+-- anything else is rejected.+module HIndent.Internal.Test.Markdone+  ( Token(..)+  , Markdone(..)+  , tokenize+  , parse+  ) where++import Control.DeepSeq+import Control.Monad.Catch+import Control.Monad.State.Strict (State, evalState, get, put)+import Data.ByteString (ByteString)+import qualified Data.ByteString.Char8 as S8+import Data.Char+import Data.Typeable+import GHC.Generics++-- | A markdone token.+data Token+  = Heading !Int !ByteString+  | PlainLine !ByteString+  | BeginFence !ByteString+  | EndFence+  deriving (Eq, Show)++-- | A markdone document.+data Markdone+  = Section !ByteString ![Markdone]+  | CodeFence !ByteString !ByteString+  | PlainText !ByteString+  deriving (Eq, Show, Generic)++instance NFData Markdone++-- | Parse error.+data MarkdownError+  = NoFenceEnd+  | ExpectedSection+  deriving (Typeable, Show)++instance Exception MarkdownError++data TokenizerMode+  = Normal+  | Fenced++-- | Tokenize the bytestring.+tokenize :: ByteString -> [Token]+tokenize input =+  evalState (mapM token (S8.filter (/= '\r') <$> S8.lines input)) Normal+  where+    token :: ByteString -> State TokenizerMode Token+    token line = do+      mode <- get+      case mode of+        Normal ->+          if S8.isPrefixOf "#" line+            then let (hashes, title) = S8.span (== '#') line+                  in return $+                     Heading (S8.length hashes) (S8.dropWhile isSpace title)+            else if S8.isPrefixOf "```" line+                   then do+                     put Fenced+                     return $+                       BeginFence+                         (S8.dropWhile (\c -> c == '`' || c == ' ') line)+                   else return $ PlainLine line+        Fenced ->+          if line == "```"+            then do+              put Normal+              return EndFence+            else return $ PlainLine line++-- | Parse into a forest.+parse :: (Functor m, MonadThrow m) => [Token] -> m [Markdone]+parse = go (0 :: Int)+  where+    go level =+      \case+        (Heading n label:rest) ->+          let (children, rest') =+                span+                  (\case+                     Heading nextN _ -> nextN > n+                     _ -> True)+                  rest+           in do childs <- go (level + 1) children+                 siblings <- go level rest'+                 return (Section label childs : siblings)+        (BeginFence label:rest)+          | level > 0 ->+            let (content, rest') =+                  span+                    (\case+                       PlainLine {} -> True+                       _ -> False)+                    rest+             in case rest' of+                  (EndFence:rest'') ->+                    fmap+                      (CodeFence+                         label+                         (S8.intercalate "\n" (map getPlain content)) :)+                      (go level rest'')+                  _ -> throwM NoFenceEnd+        PlainLine p:rest+          | level > 0 ->+            let (content, rest') =+                  span+                    (\case+                       PlainLine {} -> True+                       _ -> False)+                    (PlainLine p : rest)+             in fmap+                  (PlainText+                     (S8.intercalate+                        "\n"+                        (filter (not . S8.null) (map getPlain content))) :)+                  (go level rest')+        [] -> return []+        _ -> throwM ExpectedSection+    getPlain (PlainLine x) = x+    getPlain _ = ""

@@ -1,29 +1,22 @@-{-# OPTIONS_GHC -fno-warn-name-shadowing #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RankNTypes #-}-{-# LANGUAGE OverloadedStrings, ScopedTypeVariables, PatternGuards #-}+{-# LANGUAGE ScopedTypeVariables #-}  -- | Haskell indenter.- module HIndent-  (-- * Formatting functions.-   reformat-  ,prettyPrint-  ,parseMode-  -- * Testing-  ,test-  ,testFile-  ,testAst-  ,testFileAst-  ,defaultExtensions-  ,getExtensions-  )-  where+  ( -- * Formatting functions.+    reformat+  , prettyPrint+  , -- * Testing+    testAst+  ) where -import           Control.Monad.State.Strict-import           Control.Monad.Trans.Maybe-import           Data.ByteString (ByteString)+import Control.Monad.State.Strict+import Control.Monad.Trans.Maybe+import Data.ByteString (ByteString) import qualified Data.ByteString as S-import           Data.ByteString.Builder (Builder)+import Data.ByteString.Builder (Builder) import qualified Data.ByteString.Builder as S import qualified Data.ByteString.Char8 as S8 import qualified Data.ByteString.Internal as S@@ -31,135 +24,128 @@ import qualified Data.ByteString.Lazy.Char8 as L8 import qualified Data.ByteString.UTF8 as UTF8 import qualified Data.ByteString.Unsafe as S-import           Data.Char-import           Data.Foldable (foldr')-import           Data.Either-import           Data.Function-import           Data.Functor.Identity-import           Data.List-import           Data.Maybe-import           Data.Monoid-import           Data.Text (Text)-import qualified Data.Text as T-import           Data.Traversable hiding (mapM)-import           HIndent.CodeBlock-import           HIndent.Pretty-import           HIndent.Types-import qualified Language.Haskell.Exts as Exts-import           Language.Haskell.Exts hiding (Style, prettyPrint, Pretty, style, parse)-import           Prelude+import Data.Char+import Data.Either+import Data.Function+import Data.Functor.Identity+import Data.List hiding (stripPrefix)+import Data.Maybe+import Data.Monoid+import GHC.Hs+import GHC.Parser.Lexer hiding (buffer)+import GHC.Types.SrcLoc+import HIndent.CodeBlock+import HIndent.Config+import HIndent.LanguageExtension+import qualified HIndent.LanguageExtension.Conversion as CE+import HIndent.LanguageExtension.Types+import HIndent.ModulePreprocessing+import HIndent.Parse+import HIndent.Pretty+import HIndent.Printer+import Prelude  -- | Format the given source.-reformat :: Config -> Maybe [Extension] -> Maybe FilePath -> ByteString -> Either String Builder+reformat ::+     Config+  -> Maybe [Extension]+  -> Maybe FilePath+  -> ByteString+  -> Either String Builder reformat config mexts mfilepath =-    preserveTrailingNewline-        (fmap (mconcat . intersperse "\n") . mapM processBlock . cppSplitBlocks)+  preserveTrailingNewline+    (fmap (mconcat . intersperse "\n") . mapM processBlock . cppSplitBlocks)   where     processBlock :: CodeBlock -> Either String Builder     processBlock (Shebang text) = Right $ S.byteString text     processBlock (CPPDirectives text) = Right $ S.byteString text-    processBlock (HaskellSource line text) =-        let ls = S8.lines text-            prefix = findPrefix ls-            code = unlines' (map (stripPrefix prefix) ls)-            exts = readExtensions (UTF8.toString code)-            mode'' = case exts of-                       Nothing -> mode'-                       Just (Nothing, exts') ->-                         mode' { extensions =-                                   exts'-                                   ++ configExtensions config-                                   ++ extensions mode' }-                       Just (Just lang, exts') ->-                         mode' { baseLanguage = lang-                               , extensions =-                                   exts'-                                   ++ configExtensions config-                                   ++ extensions mode' }-        in case parseModuleWithComments mode'' (UTF8.toString code) of-               ParseOk (m, comments) ->-                   fmap-                       (S.lazyByteString . addPrefix prefix . S.toLazyByteString)-                       (prettyPrint config m comments)-               ParseFailed loc e ->-                 Left (Exts.prettyPrint (loc {srcLine = srcLine loc + line}) ++ ": " ++ e)+    processBlock (HaskellSource yPos text) =+      let ls = S8.lines text+          prefix = findPrefix ls+          code = unlines' (map (stripPrefix prefix) ls)+          allExts =+            fromMaybe allExtensions mexts +++            configExtensions config +++            collectLanguageExtensionsFromSource (UTF8.toString code)+          exts = CE.uniqueExtensions allExts+       in case parseModule mfilepath exts (UTF8.toString code) of+            POk _ m ->+              Right $+              S.lazyByteString $+              addPrefix prefix $ S.toLazyByteString $ prettyPrint config m+            PFailed st ->+              let rawErrLoc = psRealLoc $ loc st+                  adjustedLoc =+                    (srcLocLine rawErrLoc + yPos, srcLocCol rawErrLoc)+               in Left $ "Parse failed near " ++ show adjustedLoc     unlines' = S.concat . intersperse "\n"     unlines'' = L.concat . intersperse "\n"     addPrefix :: ByteString -> L8.ByteString -> L8.ByteString     addPrefix prefix = unlines'' . map (L8.fromStrict prefix <>) . L8.lines     stripPrefix :: ByteString -> ByteString -> ByteString     stripPrefix prefix line =-        if S.null (S8.dropWhile (== '\n') line)-            then line-            else fromMaybe (error "Missing expected prefix") . s8_stripPrefix prefix $-                 line+      if S.null (S8.dropWhile (== '\n') line)+        then line+        else fromMaybe (error "Missing expected prefix") . s8_stripPrefix prefix $+             line     findPrefix :: [ByteString] -> ByteString     findPrefix = takePrefix False . findSmallestPrefix . dropNewlines     dropNewlines :: [ByteString] -> [ByteString]     dropNewlines = filter (not . S.null . S8.dropWhile (== '\n'))     takePrefix :: Bool -> ByteString -> ByteString     takePrefix bracketUsed txt =-        case S8.uncons txt of-            Nothing -> ""-            Just ('>', txt') ->-                if not bracketUsed-                    then S8.cons '>' (takePrefix True txt')-                    else ""-            Just (c, txt') ->-                if c == ' ' || c == '\t'-                    then S8.cons c (takePrefix bracketUsed txt')-                    else ""+      case S8.uncons txt of+        Nothing -> ""+        Just ('>', txt') ->+          if not bracketUsed+            then S8.cons '>' (takePrefix True txt')+            else ""+        Just (c, txt') ->+          if c == ' ' || c == '\t'+            then S8.cons c (takePrefix bracketUsed txt')+            else ""     findSmallestPrefix :: [ByteString] -> ByteString     findSmallestPrefix [] = ""     findSmallestPrefix ("":_) = ""     findSmallestPrefix (p:ps) =-        let first = S8.head p-            startsWithChar c x = S8.length x > 0 && S8.head x == c-        in if all (startsWithChar first) ps-               then S8.cons-                        first-                        (findSmallestPrefix (S.tail p : map S.tail ps))-               else ""-    mode' =-        let m = case mexts of-                  Just exts ->-                    parseMode-                    { extensions = exts-                    }-                  Nothing -> parseMode-        in m { parseFilename = fromMaybe "<interactive>" mfilepath }-    preserveTrailingNewline f x =-        if S8.null x || S8.all isSpace x-            then return mempty-            else if hasTrailingLine x || configTrailingNewline config-                     then fmap-                              (\x' ->-                                    if hasTrailingLine-                                           (L.toStrict (S.toLazyByteString x'))-                                        then x'-                                        else x' <> "\n")-                              (f x)-                     else f x+      let first = S8.head p+          startsWithChar c x = S8.length x > 0 && S8.head x == c+       in if all (startsWithChar first) ps+            then S8.cons first (findSmallestPrefix (S.tail p : map S.tail ps))+            else ""+    preserveTrailingNewline f x+      | S8.null x || S8.all isSpace x = return mempty+      | hasTrailingLine x || configTrailingNewline config =+        fmap+          (\x' ->+             if hasTrailingLine (L.toStrict (S.toLazyByteString x'))+               then x'+               else x' <> "\n")+          (f x)+      | otherwise = f x +-- | Generate an AST from the given module for debugging.+testAst :: ByteString -> Either String HsModule+testAst x =+  case parseModule Nothing exts (UTF8.toString x) of+    POk _ m -> Right $ modifyASTForPrettyPrinting m+    PFailed st ->+      Left $+      "Parse failed near " +++      show ((,) <$> srcLocLine <*> srcLocCol $ psRealLoc $ loc st)+  where+    exts =+      CE.uniqueExtensions $+      collectLanguageExtensionsFromSource $ UTF8.toString x+ -- | Does the strict bytestring have a trailing newline? hasTrailingLine :: ByteString -> Bool-hasTrailingLine xs =-    if S8.null xs-        then False-        else S8.last xs == '\n'+hasTrailingLine xs = not (S8.null xs) && S8.last xs == '\n'  -- | Print the module.-prettyPrint :: Config-            -> Module SrcSpanInfo-            -> [Comment]-            -> Either a Builder-prettyPrint config m comments =-  let ast =-        evalState-          (collectAllComments-             (fromMaybe m (applyFixities baseFixities m)))-          comments-  in Right (runPrinterStyle config (pretty ast))+prettyPrint :: Config -> HsModule -> Builder+prettyPrint config m =+  runPrinterStyle config (pretty $ modifyASTForPrettyPrinting m)  -- | Pretty print the given printable thing. runPrinterStyle :: Config -> Printer () -> Builder@@ -172,263 +158,17 @@           (execStateT              (runPrinter m)              (PrintState-              { psIndentLevel = 0-              , psOutput = mempty-              , psNewline = False-              , psColumn = 0-              , psLine = 1-              , psConfig = config-              , psInsideCase = False-              , psFitOnOneLine = False-              , psEolComment = False-              }))))---- | Parse mode, includes all extensions, doesn't assume any fixities.-parseMode :: ParseMode-parseMode =-  defaultParseMode {extensions = allExtensions-                   ,fixities = Nothing}-  where allExtensions =-          filter isDisabledExtension knownExtensions-        isDisabledExtension (DisableExtension _) = False-        isDisabledExtension _ = True---- | Test the given file.-testFile :: FilePath -> IO ()-testFile fp  = S.readFile fp >>= test---- | Test the given file.-testFileAst :: FilePath -> IO ()-testFileAst fp  = S.readFile fp >>= print . testAst---- | Test with the given style, prints to stdout.-test :: ByteString -> IO ()-test =-  either error (L8.putStrLn . S.toLazyByteString) .-  reformat defaultConfig Nothing Nothing---- | Parse the source and annotate it with comments, yielding the resulting AST.-testAst :: ByteString -> Either String (Module NodeInfo)-testAst x =-  case parseModuleWithComments parseMode (UTF8.toString x) of-    ParseOk (m,comments) ->-      Right-        (let ast =-               evalState-                 (collectAllComments-                    (fromMaybe m (applyFixities baseFixities m)))-                 comments-         in ast)-    ParseFailed _ e -> Left e---- | Default extensions.-defaultExtensions :: [Extension]-defaultExtensions =-  [ e-  | e@EnableExtension {} <- knownExtensions ] \\-  map EnableExtension badExtensions---- | Extensions which steal too much syntax.-badExtensions :: [KnownExtension]-badExtensions =-    [Arrows -- steals proc-    ,TransformListComp -- steals the group keyword-    ,XmlSyntax, RegularPatterns -- steals a-b-    ,UnboxedTuples -- breaks (#) lens operator-    -- ,QuasiQuotes -- breaks [x| ...], making whitespace free list comps break-    ,PatternSynonyms -- steals the pattern keyword-    ,RecursiveDo -- steals the rec keyword-    ,DoRec -- same-    ,TypeApplications -- since GHC 8 and haskell-src-exts-1.19-    ]-+                { psIndentLevel = 0+                , psOutput = mempty+                , psNewline = False+                , psColumn = 0+                , psLine = 1+                , psConfig = config+                , psFitOnOneLine = False+                , psEolComment = False+                }))))  s8_stripPrefix :: ByteString -> ByteString -> Maybe ByteString s8_stripPrefix bs1@(S.PS _ _ l1) bs2-   | bs1 `S.isPrefixOf` bs2 = Just (S.unsafeDrop l1 bs2)-   | otherwise = Nothing------------------------------------------------------------------------------------- Extensions stuff stolen from hlint---- | Consume an extensions list from arguments.-getExtensions :: [Text] -> [Extension]-getExtensions = foldl f defaultExtensions . map T.unpack-  where f _ "Haskell98" = []-        f a ('N':'o':x)-          | Just x' <- readExtension x =-            delete x' a-        f a x-          | Just x' <- readExtension x =-            x' :-            delete x' a-        f _ x = error $ "Unknown extension: " ++ x------------------------------------------------------------------------------------- Comments---- | Traverse the structure backwards.-traverseInOrder-  :: (Monad m, Traversable t, Functor m)-  => (b -> b -> Ordering) -> (b -> m b) -> t b -> m (t b)-traverseInOrder cmp f ast = do-  indexed <--    fmap (zip [0 :: Integer ..] . reverse) (execStateT (traverse (modify . (:)) ast) [])-  let sorted = sortBy (\(_,x) (_,y) -> cmp x y) indexed-  results <--    mapM-      (\(i,m) -> do-         v <- f m-         return (i, v))-      sorted-  evalStateT-    (traverse-       (const-          (do i <- gets head-              modify tail-              case lookup i results of-                Nothing -> error "traverseInOrder"-                Just x -> return x))-       ast)-    [0 ..]---- | Collect all comments in the module by traversing the tree. Read--- this from bottom to top.-collectAllComments :: Module SrcSpanInfo -> State [Comment] (Module NodeInfo)-collectAllComments =-  shortCircuit-    (traverseBackwards-     -- Finally, collect backwards comments which come after each node.-       (collectCommentsBy-          CommentAfterLine-          (\nodeSpan commentSpan ->-              fst (srcSpanStart commentSpan) >= fst (srcSpanEnd nodeSpan)))) <=<-  shortCircuit addCommentsToTopLevelWhereClauses <=<-  shortCircuit-    (traverse-     -- Collect forwards comments which start at the end line of a-     -- node: Does the start line of the comment match the end-line-     -- of the node?-       (collectCommentsBy-          CommentSameLine-          (\nodeSpan commentSpan ->-              fst (srcSpanStart commentSpan) == fst (srcSpanEnd nodeSpan)))) <=<-  shortCircuit-    (traverseBackwards-     -- Collect backwards comments which are on the same line as a-     -- node: Does the start line & end line of the comment match-     -- that of the node?-       (collectCommentsBy-          CommentSameLine-          (\nodeSpan commentSpan ->-              fst (srcSpanStart commentSpan) == fst (srcSpanStart nodeSpan) &&-              fst (srcSpanStart commentSpan) == fst (srcSpanEnd nodeSpan)))) <=<-  shortCircuit-    (traverse-     -- First, collect forwards comments for declarations which both-     -- start on column 1 and occur before the declaration.-       (collectCommentsBy-          CommentBeforeLine-          (\nodeSpan commentSpan ->-              (snd (srcSpanStart nodeSpan) == 1 &&-               snd (srcSpanStart commentSpan) == 1) &&-              fst (srcSpanStart commentSpan) < fst (srcSpanStart nodeSpan)))) .-  fmap nodify-  where-    nodify s = NodeInfo s mempty-    -- Sort the comments by their end position.-    traverseBackwards =-      traverseInOrder-        (\x y -> on (flip compare) (srcSpanEnd . srcInfoSpan . nodeInfoSpan) x y)-    -- Stop traversing if all comments have been consumed.-    shortCircuit m v = do-      comments <- get-      if null comments-        then return v-        else m v---- | Collect comments by satisfying the given predicate, to collect a--- comment means to remove it from the pool of available comments in--- the State. This allows for a multiple pass approach.-collectCommentsBy-  :: (SrcSpan -> SomeComment -> NodeComment)-  -> (SrcSpan -> SrcSpan -> Bool)-  -> NodeInfo-  -> State [Comment] NodeInfo-collectCommentsBy cons predicate nodeInfo@(NodeInfo (SrcSpanInfo nodeSpan _) _) = do-  comments <- get-  let (others, mine) =-        partitionEithers-          (map-             (\comment@(Comment _ commentSpan _) ->-                 if predicate nodeSpan commentSpan-                   then Right comment-                   else Left comment)-             comments)-  put others-  return $ addCommentsToNode cons mine nodeInfo---- | Reintroduce comments which were immediately above declarations in where clauses.--- Affects where clauses of top level declarations only.-addCommentsToTopLevelWhereClauses ::-     Module NodeInfo -> State [Comment] (Module NodeInfo)-addCommentsToTopLevelWhereClauses (Module x x' x'' x''' topLevelDecls) =-  Module x x' x'' x''' <$>-  traverse addCommentsToWhereClauses topLevelDecls-  where-    addCommentsToWhereClauses ::-         Decl NodeInfo -> State [Comment] (Decl NodeInfo)-    addCommentsToWhereClauses (PatBind x x' x'' (Just (BDecls x''' whereDecls))) = do-      newWhereDecls <- traverse addCommentsToPatBind whereDecls-      return $ PatBind x x' x'' (Just (BDecls x''' newWhereDecls))-    addCommentsToWhereClauses other = return other-    addCommentsToPatBind :: Decl NodeInfo -> State [Comment] (Decl NodeInfo)-    addCommentsToPatBind (PatBind bindInfo (PVar x (Ident declNodeInfo declString)) x' x'') = do-      bindInfoWithComments <- addCommentsBeforeNode bindInfo-      return $-        PatBind-          bindInfoWithComments-          (PVar x (Ident declNodeInfo declString))-          x'-          x''-    addCommentsToPatBind other = return other-    addCommentsBeforeNode :: NodeInfo -> State [Comment] NodeInfo-    addCommentsBeforeNode nodeInfo = do-      comments <- get-      let (notAbove, above) = partitionAboveNotAbove comments nodeInfo-      put notAbove-      return $ addCommentsToNode CommentBeforeLine above nodeInfo-    partitionAboveNotAbove :: [Comment] -> NodeInfo -> ([Comment], [Comment])-    partitionAboveNotAbove cs (NodeInfo (SrcSpanInfo nodeSpan _) _) =-      fst $-      foldr'-        (\comment@(Comment _ commentSpan _) ((ls, rs), lastSpan) ->-           if comment `isAbove` lastSpan-             then ((ls, comment : rs), commentSpan)-             else ((comment : ls, rs), lastSpan))-        (([], []), nodeSpan)-        cs-    isAbove :: Comment -> SrcSpan -> Bool-    isAbove (Comment _ commentSpan _) span =-      let (_, commentColStart) = srcSpanStart commentSpan-          (commentLnEnd, _) = srcSpanEnd commentSpan-          (lnStart, colStart) = srcSpanStart span-       in commentColStart == colStart && commentLnEnd + 1 == lnStart-addCommentsToTopLevelWhereClauses other = return other--addCommentsToNode :: (SrcSpan -> SomeComment -> NodeComment)-                  -> [Comment]-                  -> NodeInfo-                  -> NodeInfo-addCommentsToNode mkNodeComment newComments nodeInfo@(NodeInfo (SrcSpanInfo _ _) existingComments) =-  nodeInfo-    {nodeInfoComments = existingComments <> map mkBeforeNodeComment newComments}-  where-    mkBeforeNodeComment :: Comment -> NodeComment-    mkBeforeNodeComment (Comment multiLine commentSpan commentString) =-      mkNodeComment-        commentSpan-        ((if multiLine-            then MultiLine-            else EndOfLine)-           commentString)+  | bs1 `S.isPrefixOf` bs2 = Just (S.unsafeDrop l1 bs2)+  | otherwise = Nothing

@@ -0,0 +1,11 @@+-- | Helper functions to handle 'Applicative's+module HIndent.Applicative+  ( whenJust+  ) where++-- | If the first argument is a 'Just' value, this function applies its+-- internal value to the function passed as the second argument. Otherwise,+-- this function returne a 'pure ()'.+whenJust :: (Applicative m) => Maybe a -> (a -> m ()) -> m ()+whenJust Nothing _ = pure ()+whenJust (Just x) f = f x

@@ -20,11 +20,13 @@ #else import Distribution.PackageDescription.Parse #endif-import Language.Haskell.Extension-import qualified Language.Haskell.Exts.Extension as HSE+import HIndent.Language+import HIndent.LanguageExtension hiding (defaultExtensions)+import HIndent.LanguageExtension.Conversion+import HIndent.LanguageExtension.Types+import Language.Haskell.Extension hiding (Extension) import System.Directory import System.FilePath-import Text.Read  data Stanza = MkStanza   { _stanzaBuildInfo :: BuildInfo@@ -33,60 +35,60 @@  -- | Find the relative path of a child path in a parent, if it is a child toRelative :: FilePath -> FilePath -> Maybe FilePath-toRelative parent child = let-  rel = makeRelative parent child-  in if rel == child-       then Nothing-       else Just rel+toRelative parent child =+  let rel = makeRelative parent child+   in if rel == child+        then Nothing+        else Just rel  -- | Create a Stanza from `BuildInfo` and names of modules and paths mkStanza :: BuildInfo -> [ModuleName] -> [FilePath] -> Stanza mkStanza bi mnames fpaths =-  MkStanza bi $ \path -> let-    modpaths = fmap toFilePath $ otherModules bi ++ mnames-    inDir dir =-      case toRelative dir path of-        Nothing -> False-        Just relpath ->-          any (equalFilePath $ dropExtension relpath) modpaths ||-          any (equalFilePath relpath) fpaths-    in any inDir $ hsSourceDirs' bi-      where+  MkStanza bi $ \path ->+    let modpaths = fmap toFilePath $ otherModules bi ++ mnames+        inDir dir =+          case toRelative dir path of+            Nothing -> False+            Just relpath ->+              any (equalFilePath $ dropExtension relpath) modpaths ||+              any (equalFilePath relpath) fpaths+     in any inDir $ hsSourceDirs' bi+  where+ #if MIN_VERSION_Cabal(3, 6, 0)-        hsSourceDirs' =  (map getSymbolicPath) . hsSourceDirs+        hsSourceDirs' = (map getSymbolicPath) . hsSourceDirs #else         hsSourceDirs' = hsSourceDirs #endif- -- | Extract `Stanza`s from a package packageStanzas :: PackageDescription -> [Stanza]-packageStanzas pd = let-  libStanza :: Library -> Stanza-  libStanza lib = mkStanza (libBuildInfo lib) (exposedModules lib) []-  exeStanza :: Executable -> Stanza-  exeStanza exe = mkStanza (buildInfo exe) [] [modulePath exe]-  testStanza :: TestSuite -> Stanza-  testStanza ts =-    mkStanza-      (testBuildInfo ts)-      (case testInterface ts of-         TestSuiteLibV09 _ mname -> [mname]-         _ -> [])-      (case testInterface ts of-         TestSuiteExeV10 _ path -> [path]-         _ -> [])-  benchStanza :: Benchmark -> Stanza-  benchStanza bn =-    mkStanza (benchmarkBuildInfo bn) [] $-    case benchmarkInterface bn of-      BenchmarkExeV10 _ path -> [path]-      _ -> []-  in mconcat-       [ maybeToList $ fmap libStanza $ library pd-       , fmap exeStanza $ executables pd-       , fmap testStanza $ testSuites pd-       , fmap benchStanza $ benchmarks pd-       ]+packageStanzas pd =+  let libStanza :: Library -> Stanza+      libStanza lib = mkStanza (libBuildInfo lib) (exposedModules lib) []+      exeStanza :: Executable -> Stanza+      exeStanza exe = mkStanza (buildInfo exe) [] [modulePath exe]+      testStanza :: TestSuite -> Stanza+      testStanza ts =+        mkStanza+          (testBuildInfo ts)+          (case testInterface ts of+             TestSuiteLibV09 _ mname -> [mname]+             _ -> [])+          (case testInterface ts of+             TestSuiteExeV10 _ path -> [path]+             _ -> [])+      benchStanza :: Benchmark -> Stanza+      benchStanza bn =+        mkStanza (benchmarkBuildInfo bn) [] $+        case benchmarkInterface bn of+          BenchmarkExeV10 _ path -> [path]+          _ -> []+   in mconcat+        [ maybeToList $ fmap libStanza $ library pd+        , fmap exeStanza $ executables pd+        , fmap testStanza $ testSuites pd+        , fmap benchStanza $ benchmarks pd+        ]  -- | Find cabal files that are "above" the source path findCabalFiles :: FilePath -> FilePath -> IO (Maybe ([FilePath], FilePath))@@ -103,16 +105,15 @@ getGenericPackageDescription :: FilePath -> IO (Maybe GenericPackageDescription) #if MIN_VERSION_Cabal(2, 2, 0) getGenericPackageDescription cabalPath = do-    cabaltext <- BS.readFile cabalPath-    return $ parseGenericPackageDescriptionMaybe cabaltext+  cabaltext <- BS.readFile cabalPath+  return $ parseGenericPackageDescriptionMaybe cabaltext #else getGenericPackageDescription cabalPath = do   cabaltext <- readFile cabalPath   case parsePackageDescription cabaltext of     ParseOk _ gpd -> return $ Just gpd-    _             -> return Nothing+    _ -> return Nothing #endif- -- | Find the `Stanza` that refers to this source path getCabalStanza :: FilePath -> IO (Maybe Stanza) getCabalStanza srcpath = do@@ -134,36 +135,20 @@           (stanza:_) -> Just stanza -- just pick the first one     Nothing -> return Nothing --- | Get (Cabal package) language and extensions from the cabal file for this source path+-- | Get language and extensions from the cabal file for this source path getCabalExtensions :: FilePath -> IO (Language, [Extension]) getCabalExtensions srcpath = do   mstanza <- getCabalStanza srcpath   return $     case mstanza of       Nothing -> (Haskell98, [])-      Just (MkStanza bi _) -> do-        (fromMaybe Haskell98 $ defaultLanguage bi, defaultExtensions bi)--convertLanguage :: Language -> HSE.Language-convertLanguage lang = read $ show lang--convertKnownExtension :: KnownExtension -> Maybe HSE.KnownExtension-convertKnownExtension ext =-  case readEither $ show ext of-    Left _ -> Nothing-    Right hext -> Just hext--convertExtension :: Extension -> Maybe HSE.Extension-convertExtension (EnableExtension ke) =-  fmap HSE.EnableExtension $ convertKnownExtension ke-convertExtension (DisableExtension ke) =-  fmap HSE.DisableExtension $ convertKnownExtension ke-convertExtension (UnknownExtension s) = Just $ HSE.UnknownExtension s+      Just (MkStanza bi _) ->+        ( fromMaybe Haskell98 $ defaultLanguage bi+        , mapMaybe fromCabalExtension $ defaultExtensions bi)  -- | Get extensions from the cabal file for this source path-getCabalExtensionsForSourcePath :: FilePath -> IO [HSE.Extension]+getCabalExtensionsForSourcePath :: FilePath -> IO [Extension] getCabalExtensionsForSourcePath srcpath = do   (lang, exts) <- getCabalExtensions srcpath-  return $-    fmap HSE.EnableExtension $-    HSE.toExtensionList (convertLanguage lang) $ mapMaybe convertExtension exts+  let allExts = exts ++ implicitExtensions (convertLanguage lang)+  return $ concatMap extensionImplies allExts

@@ -7,15 +7,14 @@  import Data.ByteString (ByteString) import qualified Data.ByteString.Char8 as S8-import Data.Monoid  -- | A block of code. data CodeBlock-    = Shebang ByteString-    | HaskellSource Int ByteString+  = Shebang ByteString+  | HaskellSource Int ByteString     -- ^ Includes the starting line (indexed from 0) for error reporting-    | CPPDirectives ByteString-     deriving (Show, Eq)+  | CPPDirectives ByteString+  deriving (Show, Eq)  -- | Break a Haskell code string into chunks, using CPP as a delimiter. -- Lines that start with '#if', '#end', or '#else' are their own chunks, and@@ -57,7 +56,16 @@     cppLine src =       any         (`S8.isPrefixOf` src)-        ["#if", "#end", "#else", "#define", "#undef", "#elif", "#include", "#error", "#warning"]+        [ "#if"+        , "#end"+        , "#else"+        , "#define"+        , "#undef"+        , "#elif"+        , "#include"+        , "#error"+        , "#warning"+        ]         -- Note: #ifdef and #ifndef are handled by #if     hasEscapedTrailingNewline :: ByteString -> Bool     hasEscapedTrailingNewline src = "\\" `S8.isSuffixOf` src