ormolu

A formatter for Haskell source code

https://github.com/tweag/ormolu

Version on this page:0.5.0.1
LTS Haskell 22.14:0.7.2.0
Stackage Nightly 2023-12-26:0.7.2.0
Latest on Hackage:0.7.4.0

See all snapshots ormolu appears in

BSD-3-Clause licensed
Maintained by Mark Karpov
This version can be pinned in stack with:ormolu-0.5.0.1@sha256:ee16d06453db683899ced95c64dfb6fd321def78141b5201131905884ebcbbb3,5782

Ormolu

License BSD3 Hackage Stackage Nightly Stackage LTS Build status

Ormolu is a formatter for Haskell source code. The project was created with the following goals in mind:

  • Using GHC’s own parser to avoid parsing problems caused by haskell-src-exts.
  • Let some whitespace be programmable. The layout of the input influences the layout choices in the output. This means that the choices between single-line/multi-line layouts in certain situations are made by the user, not by an algorithm. This makes the implementation simpler and leaves some control to the user while still guaranteeing that the formatted code is stylistically consistent.
  • Writing code in such a way so it’s easy to modify and maintain.
  • Implementing one “true” formatting style which admits no configuration.
  • The formatting style aims to result in minimal diffs.
  • Choose a style compatible with modern dialects of Haskell. As new Haskell extensions enter broad use, we may change the style to accommodate them.
  • Idempotence: formatting already formatted code doesn’t change it.
  • Be well-tested and robust so that the formatter can be used in large projects.

Try it out in your browser at https://ormolu-live.tweag.io! See Ormolu Live for more info.

Installation

The release page has binaries for Linux, macOS and Windows.

You can also install using cabal or stack:

$ cabal install ormolu
$ stack install ormolu

Ormolu is also included in several package repositories. E.g., on Arch Linux, one can use the package on AUR:

$ yay -S ormolu

Building from source

The easiest way to build the project is with Nix:

$ nix-build -A ormolu

Note that you will need to add IOHK Hydra binary cache, otherwise building may take a very long time.

Alternatively, stack could be used as follows:

$ stack build # to build
$ stack install # to install

To use Ormolu directly from GitHub with Nix, this snippet may come in handy:

let
  pkgs = import <nixpkgs> { };
  source = pkgs.fetchFromGitHub {
      owner = "tweag";
      repo = "ormolu";
      rev = "c1d8a8083cf1492545b8deed342c6399fe9873ea"; # update as necessary
      # do not forget to update the hash:
      sha256 = "sha256-3XxKuWqZnFa9s3mY7OBD+uEn/fGxPmC8jdevx7exy9o=";
    };
in (import source {  }).ormoluExe # this is e.g. the executable derivation

Usage

The following will print the formatted output to the standard output.

$ ormolu Module.hs

Add --mode inplace to replace the contents of the input file with the formatted output.

$ ormolu --mode inplace Module.hs

Use find to format a tree recursively:

$ ormolu --mode inplace $(find . -name '*.hs')

Or find all files in a project with git ls-files:

$ ormolu --mode inplace $(git ls-files '*.hs')

To check if files are are already formatted (useful on CI):

$ ormolu --mode check $(find . -name '*.hs')

:zap: Beware git’s core.autocrlf on Windows :zap:

Ormolu’s output always uses LF line endings. In particular, ormolu --mode check will fail if its input is correctly formatted except that it has CRLF line endings. This situation can happen on Windows when checking out a git repository without having set core.autocrlf to false.

Ormolu Live

On every new commit to master, Ormolu Live is deployed to https://ormolu-live.tweag.io. Older versions are available at https://COMMITHASH--ormolu-live.netlify.app.

Editor integration

We know of the following editor integrations:

Haskell Language Server

Haskell Language Server has built-in support for using Ormolu as a formatter.

GitHub actions

ormolu-action is the recommended way to ensure that a project is formatted with Ormolu.

Language extensions, dependencies, and fixities

Ormolu automatically locates the Cabal file that corresponds to a given source code file. When input comes from stdin, one can pass --stdin-input-file which will give Ormolu the location of the Haskell source file that should be used as the starting point for searching for a suitable Cabal file. Cabal files are used to extract both default extensions and dependencies. Default extensions directly affect behavior of the GHC parser, while dependencies are used to figure out fixities of operators that appear in the source code. Fixities can also be overridden if .ormolu file is found next to the corresponding Cabal file, i.e. they should be siblings in the same directory.

Here is an example of .ormolu file:

infixr 9  .
infixr 5  ++
infixl 4  <$
infixl 1  >>, >>=
infixr 1  =<<
infixr 0  $, $!
infixl 4 <*>, <*, *>, <**>

It uses exactly the same syntax as usual Haskell fixity declarations to make it easier for Haskellers to edit and maintain.

Besides, all of the above-mentioned parameters can be controlled from the command line:

  • Language extensions can be specified with the -o or --ghc-opt flag.
  • Dependencies can be specified with the -p or --package flag.
  • Fixities can be specified with the -f or --fixity flag.

Searching for both .cabal and .ormolu files can be disabled by passing --no-cabal.

Magic comments

Ormolu understands two magic comments:

{- ORMOLU_DISABLE -}

and

{- ORMOLU_ENABLE -}

This allows us to disable formatting selectively for code between these markers or disable it for the entire file. To achieve the latter, just put {- ORMOLU_DISABLE -} at the very top. Note that for Ormolu to work the fragments where Ormolu is enabled must be parseable on their own. Because of that the magic comments cannot be placed arbitrarily, but rather must enclose independent top-level definitions.

Regions

One can ask Ormolu to format a region of input and leave the rest unformatted. This is accomplished by passing the --start-line and --end-line command line options. --start-line defaults to the beginning of the file, while --end-line defaults to the end.

Exit codes

Exit code Meaning
0 Success
1 General problem
2 CPP used (deprecated)
3 Parsing of original input failed
4 Parsing of formatted code failed
5 AST of original and formatted code differs
6 Formatting is not idempotent
7 Unrecognized GHC options
8 Cabal file parsing failed
9 Missing input file path when using stdin input and accounting for .cabal files
10 Parse error while parsing fixity overrides
100 In checking mode: unformatted files
101 Inplace mode does not work with stdin
102 Other issue (with multiple input files)

Limitations

  • CPP support is experimental. CPP is virtually impossible to handle correctly, so we process them as a sort of unchangeable snippets. This works only in simple cases when CPP conditionals surround top-level declarations. See the CPP section in the design notes for a discussion of the dangers.
  • Input modules should be parsable by Haddock, which is a bit stricter criterion than just being valid Haskell modules.

Running on Hackage

It’s possible to try Ormolu on arbitrary packages from Hackage. For that execute (from the root of the cloned repo):

$ nix-build -A hackage.<package>

Then inspect result/log.txt for possible problems. The derivation will also contain formatted .hs files for inspection and original inputs with .hs-original extension (those are with CPP dropped, exactly what is fed into Ormolu).

Forks and modifications

We know of the following actively maintained forks:

  • Fourmolu, which uses 4-space indentation and allows arbitrary configuration.

Contributing

See CONTRIBUTING.md.

License

See LICENSE.md.

Copyright © 2018–present Tweag I/O

Changes

Ormolu 0.5.0.1

  • Fixed a bug in the diff printing functionality. Issue 886.

  • Indent closing bracket for list comprehensions in do blocks. Issue 893.

  • Fix hs-source-dirs: . resulting in failing to find a .cabal file for a Haskell source file. Issue 909.

  • Comments in closed type family declarations are now indented correctly. Issue 913.

  • Cache .cabal file parsing and processing when given multiple input files in the same project. This results in dramatic speedups on projects which have both huge .cabal files and a large number of individual modules. Issue 897.

Ormolu 0.5.0.0

  • Changed the way operator fixities and precedences are inferred.

    • Ormolu now tries to locate .cabal files of source files by default and in addition to default extensions it also infers the list of dependencies.
    • Ormolu comes equipped with extensive knowledge of all packages on Hackage and operators that those packages define. Knowing the names of the dependencies it can select the right fixity and precedence info from its knowledge base.
    • You can ask Ormolu not to look for .cabal files by using the --no-cabal switch.
    • Dependencies can be selected manually by using the -p / --package option (can be repeated many times).
    • The default heuristic algorithm will still try to guess the right fixities and precedence.
    • Fixity overrides can be provided by the user in the familiar Haskell notation (e.g. infixr 9 ., one declaration per line). They are loaded by default from the .ormolu file that is expected to be in the same directory as the .cabal file of a given source file. However, if --no-cabal is supplied, the .ormolu file will not be looked for either. Fixity declarations can be also provided by using the -f / --fixity command line option, which see.
    • This resolves the following issues: Issue 826, Issue 785, Issue 690, Issue 825.
  • Invalid haddock comments are formatted in a more consistent way. Leading haddock triggers (|, ^) in an invalid haddock comment block are now escaped with a backslash \. Issue 816.

  • Type synonyms and families are now formatted correctly when the equals sign is preceded by a comment. Issue 829.

  • Bidirectional pattern synonyms are formatted nicer in certain cases. Issue 843.

  • Magic comments (like {- ORMOLU_DISABLED -}) now allow arbitrary succeeding text. This fixes use cases like Issue 856.

  • Remove discrepancies between unboxed types and terms. Issue 856 .

    • Unboxed sum types are now formatted with a space before each |.
    • Unboxed unit tuples on type and value levels are formatted as (# #).
  • Errors caused by AST differences now print before/after diffs. Issue 877.

  • Improved formatting of data declarations in the case of single-constructor record with a Haddock. Issue 881.

Ormolu 0.4.0.0

  • When a guard is located on its own line, the body associated with this guard is indented by one extra level, so that it can easily be distinguished from the guard predicate or pattern. Issue 806.

  • Now a space is forced after -- in line comments. Issue 808.

  • Allow formatting Backpack signature files (.hsig). The switch between regular module mode and signature mode is based on the file extension by default, but can be overridden with the -t / --source-type command line option. Issue 600.

  • Blank Haddock comments are now eliminated. This also fixes issues with differing ASTs in some special cases. Issue 726.

  • Rewrite rules that are never active are now formatted correctly. Issue 823.

  • Promoted infix data constructors are now formatted correctly. Issue 768.

  • Switched to ghc-lib-parser-9.2. Issue 794.

    • Support for the new syntax-related language extensions: OverloadedRecordDot and OverloadedRecordUpdate (disabled by default). Issue 709.
    • Removed support for record-dot-preprocessor. For the getter syntax, consider using OverloadedRecordDot instead. Issue 659. Issue 705.
    • Support for the GHC2021 language.

Ormolu 0.3.1.0

  • Allow check mode when working with stdin input. Issue 634.

  • Now guards are printed on a new line if at least one guard is multiline or if all guards together occupy more than one line. The body of each guard is also indented one level deeper in that case. Issue 712.

  • Invalid Haddock comments are no longer silently deleted, but rather converted into regular comments. Issue 474.

Ormolu 0.3.0.1

  • Improvements to .cabal file handling:

    • When looking for a .cabal file, directories were previously erroneously also considered. Issue 781.
    • We now print a note if Ormolu was told to consider .cabal files, but no suitable one could be found.
    • Handle an empty hs-source-dirs correctly.
    • Also consider modules which are only conditionally listed in the .cabal file.
  • The special handling of CPP is now only applied if CPP is actually enabled. Issue 782.

  • The left hand side of the : operator now uses braces if necessary. Issue 780.

Ormolu 0.3.0.0

  • Data declarations with multiline kind signatures are now formatted correctly. Issue 749.

  • Infix arrow command formations are formatted like usual operators. This fixes Issue 748.

  • do arrow commands are formatted more flexibly. Fixes Issue 753.

  • Source code is always read and written using UTF8 and ignoring the native line ending conventions. Issue 717.

  • Opt-in support to respect default-extensions and default-language from .cabal files. Issue 517.

  • Empty case expressions are now rendered with braces. Issue 765.

  • Omit braces on repeated application of do blocks. Issue 735.

  • Improved handling of disabled regions. PR 773.

    • Disabled regions are now exactly preserved, in particular empty lines and trailing spaces. Issue 673.
    • Strings like -} can now be present in disabled regions. Issue 708.

    This means that using CPP or magic comments in certain ways which were only supported as a side effect previously (like in Issue 601) will now result in formatting failures. Also see Issue 774.

Ormolu 0.2.0.0

  • Now standalone kind signatures are grouped with type synonyms. Issue 683.

  • TemplateHaskell is not enabled by default anymore. Issue 699.

  • Made record dot pre-processor rendering idempotent in certain specific cases. Issue 701.

  • Added support for arrow command application. Issue 716.

  • Switched to ghc-lib-parser-9.0.1. PR 722.

    • Support for the new language extensions:
      • LexicalNegation, LinearTypes: disabled by default
      • QualifiedDo: enabled by default
    • Due to upstream changes in whitespace sensitity, TypeApplications is now enabled by default. Issue 452.
    • Haddocks on declarations in files without a module header are no longer deleted. Issue 480.
    • Due to a change in Haddock parsing, empty Haddock comments on function arguments now get deleted.
  • CTYPE pragmas are now preserved. Issue 689.

  • TypeApplications in data/type family instances are now supported. Issue 698.

  • Formatting infix arrow command formations now preserves the AST. Issue 718.

  • Surround code in brackets with spaces if it contains a StarIsType * to prevent unparseable output. Issue 704.

  • Formatting applied multiline constructs in do blocks now preserves the AST. Issue 707.

    This will sometimes result in odd indentations, e.g. this snippet is a fixed point:

    foo = do
      do
        (+1)
       1
    
  • GHC options passed in via the CLI can now be overridden in local files. Previously, if an extension was disabled via the CLI, it could not be re-enabled per file.

  • NegativeLiterals is no longer enabled by default. Also, spaces after negation via - are removed where possible. Issue 694.

  • Minus signs in literal patterns are now preserved in all cases. Issue 733.

  • Added support for left-to-right arrow application. Issue 737.

  • Now --mode check fails on missing trailing blank lines. Issue 743.

  • Fixed indentation of arrow forms in do blocks. Issue 739.

Ormolu 0.1.4.1

  • Added command line option --color to control how diffs are printed. Standardized the way errors are printed.

Ormolu 0.1.4.0

  • Added support for monad comprehensions. Issue 665.

  • Fixed a bug when a space was inserted in front of promoted types even when it wasn’t strictly necessary. Issue 668.

  • Now the checking mode displays diffs per file when unformatted files are found. The rendering of the diffs is also improved. Issue 656.

Ormolu 0.1.3.1

  • Fixed a problem with multiline record updates using the record dot preprocessor. Issue 658.

Ormolu 0.1.3.0

  • Ormolu no longer overwrites already formatted files. PR 649.

  • Now a space is guaranteed before ticked promoted types. Issue 631.

  • Made formatting of single-line explicitly bidirectional pattern synonyms idempotent. Issue 630.

Ormolu 0.1.2.0

  • Fixed the bug when comments in different styles got glued together after formatting. Issue 589.

  • Added -i as a shortcut for --mode inplace. Issue 467.

  • Improved grouping of top-level declarations. Issue 466.

Ormolu 0.1.1.0

  • Imports in a import lists are now normalized: duplicate imports are combined/eliminated intelligently.

  • Import declarations that can be merged are now automatically merged. Issue 414.

  • The magic comments for disabling and enabling Ormolu now can encompass any fragment of code provided that the remaining code after exclusion of the disabled part is still syntactically correct. Issue 601.

  • Improved sorting of operators in imports. Issue 602.

  • Fixed a bug related to trailing space in multiline comments in certain cases. Issue 603.

  • Added support for formatting linked lists with (:) as line terminator. Issue 478.

  • Fixed rendering of function arguments in multiline layout. Issue 609.

  • Blank lines between definitions in let and while bindings are now preserved. Issue 554.

  • Fixed the bug when type applications stuck to the $ of TH splices that followed them. Issue 613.

  • Improved region formatting so that indented fragments—such as definitions inside of where clauses—can be formatted. Issue 572.

  • Fixed the bug related to the de-association of pragma comments. Issue 619.

Ormolu 0.1.0.0

  • Fixed rendering of type signatures concerning several identifiers. Issue 566.

  • Fixed an idempotence issue with inline comments in tuples and parentheses. Issue 450.

  • Fixed an idempotence issue when certain comments were picked up as “continuation” of a series of comments Issue 449.

  • Fixed an idempotence issue related to different indentation levels in a comment series. Issue 512.

  • Fixed an idempotence issue related to comments which may happen to be separated from the elements they are attached to by the equality sign. Issue 340.

  • Fixed an idempotence issue with type synonym and data declarations where the type has a Haddock. Issue 578.

  • Fix the false positive about AST differences in presence of comments with multiple blank lines in a row. Issue 518.

  • Fixed rendering of comments around if expressions. Issue 458.

  • Unnamed fields of data constructors are now documented using the -- ^ syntax. Issue 445 and Issue 428.

  • Fixed non-idempotent transformation of partly documented data definition. Issue 590.

  • Fixed an idempotence issue related to operators. Issue 522.

  • Renamed the --check-idempotency flag to --check-idempotence. Apparently only the latter is correct.

Ormolu 0.0.5.0

  • Grouping of statements in do-blocks is now preserved. Issue 74.

  • Grouping of TH splices is now preserved. Issue 507.

  • Comments on pragmas are now preserved. Issue 216.

  • Ormolu can now be enabled and disabled via special comments. Issue 435.

  • Added experimental support for simple CPP. Issue 415.

  • Added two new options --start-line and --end-line that allow us to select a region to format. Issue 516.

  • Fixed rendering of module headers in the presence of preceding comments or Haddocks. Issue 561.

Ormolu 0.0.4.0

  • When given several files to format, Ormolu does not stop on the first failure, but tries to format all the files. Issue 502.

  • Made rendering of pattern matches involving operators consistent with other cases of rendering of operators. Issue 500.

  • More compact rendering of type family injectivity constraints. Issue 482.

  • Improved rendering of the keyword where in class, data, and type family declarations. When headers of these declarations are multi-line where is now put on its own line. Issue 509.

  • Fixed the bug pertaining to rendering of arrow notation with multiline expressions. Issue 513.

  • Made rendering of data type definitions, value-level applications, and application of types use the same style. Moreover, existential now doesn’t cause the data constructor be unconditionally rendered in multiline layout. Issue 427.

  • Records with a single data constructor are now formatted more compactly. Issue 425.

  • Switched to ghc-lib-parser-8.10.1.

  • Implemented support for the new language extensions ImportQualifiedPost and StandaloneKindSignatures.

Ormolu 0.0.3.1

  • Fixed rendering of record updates with the record dot preprocessor syntax Issue 498.

Ormolu 0.0.3.0

  • Fixed an issue related to unnecessary use of curly braces. Issue 473.

  • Fixed the issue with formatting multi-way if when it happens to be a function applied to arguments Issue 488. This changed the way multi-line if is formatted in general.

  • Added support for record dot pre-processor when used via the plugin. Issue 486.

  • Stopped hanging record constructors and improved placing potentially-hanging consturctions in the presence of comments. Issue 447.

  • Fixed indentation in presence of type applications. Issue 493.

  • Class and instance declarations now do not have a blank line after where. Grouping of methods from the original input is also preserved with some normalizations. Issue 431.

Ormolu 0.0.2.0

  • Switched to ghc-lib-parser instead of depending on the ghc package directly. This should allow us to use newest features of GHC while not necessarily depending on the newest version of the compiler. In addition to that Ormolu is now GHCJS-compatible.

  • Now unrecognized GHC options passed with --ghc-opt cause Ormolu to fail (exit code 7).

  • Fixed formatting of result type in closed type families. See issue 420.

  • Fixed a minor inconsistency between formatting of normal and foreign type signatures. See issue 408.

  • Fixed a bug when comment before module header with Haddock was moved inside the export list. See issue 430.

  • Empty foralls are now correctly preserved. See issue 429.

  • Fixed issue 446, which involved braces and operators.

  • When there are comments between preceding Haddock (pipe-style) and its corresponding declaration they are preserved like this in the output instead of being shifted. To be clear, this is not a very good idea to have comments in that position because the Haddock will end up not being associated with the declarations. Issues 440 and 448.

  • Implemented correct handling of shebangs. Issue 377.

  • Implemented correct handling of stack headers. Issue 393.

  • Sorting language pragmas cannot not change meaning of the input program anymore. Issue 404.

  • Fixed formatting of applications where function is a complex expression. Issue 444.

Ormolu 0.0.1.0

  • Initial release.