Skip to content

Add trailing-section-operators #444

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom
Merged
brandonchinn178 merged 11 commits into from
Dec 20, 2024
Merged

Add trailing-section-operators #444

brandonchinn178 merged 11 commits into from
Dec 20, 2024

Conversation

@pbrisbin
Copy link
Contributor

@pbrisbin pbrisbin commented Nov 14, 2024 •
edited
Loading

Fourmolu has a behavior (inherited from Ormolu) where so-called
"section" operators (those that are infixr 0, such as $) are left
trailing, with the continuation of expressions indented below, rather
than placed on the next line as most operators are.

It means code comes out like this:

    foo $
      bar $
        baz $
          bat $
            quix

Instead of this:

    foo
      $ bar
      $ baz
      $ bat
      $ quix

This behavior is not desired by some users for aesthetic reasons, and
can be even more confusing since it's unreliable: it requires fourmolu
can determine the fixity of $ correctly, which depends on dependencies
in the cabal file and imports or re-export knowledge. All of which can
make the behavior change from place to place confusing users and can
generating differences between projects for seemingly know reason.

This new option allows disabling that behavior.

Closes #405.

@github-actions
Copy link

github-actions bot commented Nov 14, 2024

👋 @pbrisbin
Thank you for raising your pull request.
Please make sure you have followed our contributing guidelines in DEVELOPER.md. We will review it as soon as possible!

Reviewer: Please verify the following things have been done, if applicable.

  • A file has been added to changelog.d/
  • Docs have been updated in web/site/pages/config/
  • Tests have been added
  • Diff files in compat-tests/ either:
    1. Have NOT been changed, or
    2. Modifies fourmolu.yaml with an appropriate option to keep the same formatting, or
    3. Modifies Haskell files with new formatting

@pbrisbin pbrisbin mentioned this pull request Nov 14, 2024
Closed
@pbrisbin

This comment was marked as resolved.

Sign in to view
@pbrisbin pbrisbin changed the title Add no-op hanging-dollar option and tests Add hanging-dollar option Nov 20, 2024
@brandonchinn178
Copy link
Collaborator

brandonchinn178 commented Nov 20, 2024

Interesting! Yes, that's almost certainly the right location. It's interesting that it's not used; the fixity logic is much newer, so it's possible that's a dead branch with the fixity logic. One thing you can do is see if there's ever a scenario where that branch fires, e.g. throw an error or trace.

You could also maybe write an issue in Ormolu to ask about this behavior. That might be worth investigating on its own.

@pbrisbin
Copy link
Contributor Author

pbrisbin commented Nov 21, 2024 •
edited
Loading

OK, so exprPlacement seems to be about some other kind of "hanging". If I make it just return Normal always (not treat $ as special), it changes outputs (for example) from:

       f = unFoo . foo bar baz 3 $ do
           act
           ret

To

       f =
           unFoo . foo bar baz 3 $ do
               act
               ret

So it seems to be about where to place the expression before the $; which I guess makes sense because the presence of x $ y changes from Normal to exprPlacement x. So I think it's fair to say that stuff is unrelated to the behavior I'm trying to change.

@brandonchinn178
Copy link
Collaborator

brandonchinn178 commented Nov 23, 2024

ahh I see. Okay so it looks like Ormolu hardcoded the fixity of $ from the very beginning, then generalized it with the fixity feature: https://github.com/tweag/ormolu/blob/807ee05aee2dff2a4222104abc75be3c776ee026/src/Ormolu/Printer/Operators.hs#L133

So the staircase behavior here is fully determined by fixity information. More specifically, it looks like all infixr 0 operators are special-cased in isHardSplitterOp to add a newline afterwards. Is your goal to remove $ from this special case, or skip the special case for all infixr 0 operators? If just the former, I'd weakly recommend just adding the fixity information in Fourmolu config, at least until we get more signal from users that this is popular enough to warrant a top-level option. If the latter, you probably want to add logic to isHardSplitterOp to always return False if the option is enabled

@pbrisbin
Copy link
Contributor Author

pbrisbin commented Nov 23, 2024

Ah nice! Yeah, I would want to disable this behavior always. I'm truly baffled that anyone finds this march to the right to be a good format in any way shape or form 🤷‍♂️. I'll explore the option and go from there.

@pbrisbin
Copy link
Contributor Author

pbrisbin commented Dec 3, 2024

OK, I've pushed a much better fix. All that's left is to rename the option, since it applies to more than just dollar.

In the code, the key behavior being switched off is "trailing". The object, the infixr-0 operators themselves, are called "hard splitter", and the intent is to respect a "separator" use-case, according to that predicate's documentation.

Absent other trade-offs, I prefer naming after intent (an old Ruby habit), and the behavior seems more important than the object, so I think I'd go with trailing-separator-ops. WDYT?

brandonchinn178
brandonchinn178 reviewed Dec 4, 2024
View reviewed changes
Copy link
Collaborator

@brandonchinn178 brandonchinn178 left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fix looks good! Shall we take the PR out of draft?

RE: naming - I sympathize with your reasoning here, but as a user, it's not immediately obvious what a "separator operator" is. In hindsight, I can reason that $ is acting as a separator that "ends" the current section and "starts" a new indented context, but I don't quite get that starting from the name. What do you think about "section operator" or "break operator"? I'd also be fine with "separator operator"

For reference: all infixr 0 operators 
(PackageName "BiGUL",ModuleName "Generics.BiGUL.Lib",==>)
(PackageName "Cabal-syntax",ModuleName "Distribution.Compat.Parsing",<?>)
(PackageName "Cabal-syntax",ModuleName "Distribution.Compat.Prelude",$)
(PackageName "Cabal-syntax",ModuleName "Distribution.Compat.Prelude",$!)
(PackageName "Cabal-syntax",ModuleName "Distribution.Compat.Prelude",deepseq)
(PackageName "Cabal-syntax",ModuleName "Distribution.Compat.Prelude",seq)
(PackageName "Earley",ModuleName "Text.Earley",<?>)
(PackageName "Earley",ModuleName "Text.Earley.Grammar",<?>)
(PackageName "FirstPrelude",ModuleName "FirstPrelude",$)
(PackageName "FirstPrelude",ModuleName "FirstPrelude",seq)
(PackageName "GPipe-Core",ModuleName "Graphics.GPipe.Linear",$*)
(PackageName "HUnit",ModuleName "Test.HUnit.Base",~:)
(PackageName "HUnit-Plus",ModuleName "Test.HUnitPlus.Base",~:)
(PackageName "LambdaHack",ModuleName "Game.LambdaHack.Core.Prelude",$)
(PackageName "LambdaHack",ModuleName "Game.LambdaHack.Core.Prelude",$!)
(PackageName "LambdaHack",ModuleName "Game.LambdaHack.Core.Prelude",seq)
(PackageName "MemoTrie",ModuleName "Data.MemoTrie",:->:)
(PackageName "NMap",ModuleName "Data.NMap",.<)
(PackageName "NMap",ModuleName "Data.NMap",.>)
(PackageName "Prelude",ModuleName "Prelude",$)
(PackageName "Prelude",ModuleName "Prelude",$!)
(PackageName "QuickCheck",ModuleName "Test.QuickCheck",==>)
(PackageName "TeX-my-math",ModuleName "Math.LaTeX.Internal.MathExpr",...)
(PackageName "TeX-my-math",ModuleName "Math.LaTeX.Internal.MathExpr",،)
(PackageName "TeX-my-math",ModuleName "Math.LaTeX.Internal.MathExpr",،..،)
(PackageName "TeX-my-math",ModuleName "Math.LaTeX.Internal.MathExpr",⍪)
(PackageName "TeX-my-math",ModuleName "Math.LaTeX.Internal.MathExpr",⍪..⍪)
(PackageName "TeX-my-math",ModuleName "Math.LaTeX.Internal.MathExpr",␣)
(PackageName "TeX-my-math",ModuleName "Math.LaTeX.Prelude",...)
(PackageName "TeX-my-math",ModuleName "Math.LaTeX.Prelude",،)
(PackageName "TeX-my-math",ModuleName "Math.LaTeX.Prelude",،..،)
(PackageName "TeX-my-math",ModuleName "Math.LaTeX.Prelude",⍪)
(PackageName "TeX-my-math",ModuleName "Math.LaTeX.Prelude",⍪..⍪)
(PackageName "TeX-my-math",ModuleName "Math.LaTeX.Prelude",␣)
(PackageName "TypeCompose",ModuleName "Control.Compose",:$)
(PackageName "Yampa",ModuleName "FRP.Yampa",-->)
(PackageName "Yampa",ModuleName "FRP.Yampa",-:>)
(PackageName "Yampa",ModuleName "FRP.Yampa",-=>)
(PackageName "Yampa",ModuleName "FRP.Yampa",>--)
(PackageName "Yampa",ModuleName "FRP.Yampa",>=-)
(PackageName "Yampa",ModuleName "FRP.Yampa.Basic",-->)
(PackageName "Yampa",ModuleName "FRP.Yampa.Basic",-:>)
(PackageName "Yampa",ModuleName "FRP.Yampa.Basic",-=>)
(PackageName "Yampa",ModuleName "FRP.Yampa.Basic",>--)
(PackageName "Yampa",ModuleName "FRP.Yampa.Basic",>=-)
(PackageName "Yampa",ModuleName "FRP.Yampa.Delays",fby)
(PackageName "Z-Data",ModuleName "Z.Data.Parser",<?>)
(PackageName "Z-Data",ModuleName "Z.Data.Parser.Base",<?>)
(PackageName "accelerate",ModuleName "Data.Array.Accelerate",$)
(PackageName "algebra",ModuleName "Numeric.Map",$@)
(PackageName "amazonka-core",ModuleName "Amazonka.Prelude",$)
(PackageName "amazonka-core",ModuleName "Amazonka.Prelude",$!)
(PackageName "amazonka-core",ModuleName "Amazonka.Prelude",seq)
(PackageName "arduino-copilot",ModuleName "Copilot.Arduino",$)
(PackageName "arduino-copilot",ModuleName "Copilot.Arduino",$!)
(PackageName "arduino-copilot",ModuleName "Copilot.Arduino",seq)
(PackageName "asana",ModuleName "Asana.Api.Prelude",$)
(PackageName "asana",ModuleName "Asana.Api.Prelude",$!)
(PackageName "asana",ModuleName "Asana.Api.Prelude",seq)
(PackageName "axiom",ModuleName "GHCJS.HPlay.Cell",.=)
(PackageName "base",ModuleName "Data.Function",$)
(PackageName "base",ModuleName "GHC.Base",$)
(PackageName "base",ModuleName "GHC.Base",$!)
(PackageName "base",ModuleName "GHC.Base",seq)
(PackageName "base",ModuleName "GHC.Conc",par)
(PackageName "base",ModuleName "GHC.Conc",pseq)
(PackageName "base",ModuleName "GHC.Conc.Sync",par)
(PackageName "base",ModuleName "GHC.Conc.Sync",pseq)
(PackageName "base",ModuleName "GHC.Exts",seq)
(PackageName "base",ModuleName "Prelude",$)
(PackageName "base",ModuleName "Prelude",$!)
(PackageName "base",ModuleName "Prelude",seq)
(PackageName "base-compat",ModuleName "Prelude.Compat",$)
(PackageName "base-compat",ModuleName "Prelude.Compat",$!)
(PackageName "base-compat",ModuleName "Prelude.Compat",seq)
(PackageName "base-prelude",ModuleName "BasePrelude",$)
(PackageName "base-prelude",ModuleName "BasePrelude",$!)
(PackageName "base-prelude",ModuleName "BasePrelude",par)
(PackageName "base-prelude",ModuleName "BasePrelude",pseq)
(PackageName "base-prelude",ModuleName "BasePrelude",seq)
(PackageName "base-prelude",ModuleName "BasePrelude.Operators",$)
(PackageName "base-prelude",ModuleName "BasePrelude.Operators",$!)
(PackageName "basement",ModuleName "Basement.Compat.Base",$)
(PackageName "basement",ModuleName "Basement.Compat.Base",$!)
(PackageName "basement",ModuleName "Basement.Compat.Base",seq)
(PackageName "basement",ModuleName "Basement.Imports",$)
(PackageName "basement",ModuleName "Basement.Imports",$!)
(PackageName "basement",ModuleName "Basement.Imports",seq)
(PackageName "basement-cd",ModuleName "Basement.Compat.Base",$)
(PackageName "basement-cd",ModuleName "Basement.Compat.Base",$!)
(PackageName "basement-cd",ModuleName "Basement.Compat.Base",seq)
(PackageName "basement-cd",ModuleName "Basement.Imports",$)
(PackageName "basement-cd",ModuleName "Basement.Imports",$!)
(PackageName "basement-cd",ModuleName "Basement.Imports",seq)
(PackageName "basic-prelude",ModuleName "CorePrelude",$)
(PackageName "basic-prelude",ModuleName "CorePrelude",$!)
(PackageName "bearriver",ModuleName "FRP.BearRiver.Basic",-->)
(PackageName "bearriver",ModuleName "FRP.BearRiver.Basic",-:>)
(PackageName "bearriver",ModuleName "FRP.BearRiver.Basic",-=>)
(PackageName "bearriver",ModuleName "FRP.BearRiver.Basic",>--)
(PackageName "bearriver",ModuleName "FRP.BearRiver.Basic",>=-)
(PackageName "bearriver",ModuleName "FRP.BearRiver.Delays",fby)
(PackageName "bearriver",ModuleName "FRP.Yampa",-->)
(PackageName "bearriver",ModuleName "FRP.Yampa",-:>)
(PackageName "bearriver",ModuleName "FRP.Yampa",-=>)
(PackageName "bearriver",ModuleName "FRP.Yampa",>--)
(PackageName "bearriver",ModuleName "FRP.Yampa",>=-)
(PackageName "bearriver",ModuleName "FRP.Yampa",fby)
(PackageName "bifunctors",ModuleName "Data.Bifunctor.Functor",:->)
(PackageName "biohazard",ModuleName "Bio.Prelude",$)
(PackageName "biohazard",ModuleName "Bio.Prelude",$!)
(PackageName "biohazard",ModuleName "Bio.Prelude",par)
(PackageName "biohazard",ModuleName "Bio.Prelude",pseq)
(PackageName "biohazard",ModuleName "Bio.Prelude",seq)
(PackageName "bizzlelude",ModuleName "Prelude",$)
(PackageName "bizzlelude",ModuleName "Prelude",$!)
(PackageName "blank-canvas",ModuleName "Graphics.Blank",#)
(PackageName "box",ModuleName "Box.Codensity",<$|>)
(PackageName "breakpoint",ModuleName "Debug.Breakpoint.GhcFacade",SynFun)
(PackageName "brittany",ModuleName "Language.Haskell.Brittany.Internal.Prelude",$)
(PackageName "brittany",ModuleName "Language.Haskell.Brittany.Internal.Prelude",$!)
(PackageName "brittany",ModuleName "Language.Haskell.Brittany.Internal.Prelude",seq)
(PackageName "btc-lsp",ModuleName "BtcLsp.Import",$!)
(PackageName "btc-lsp",ModuleName "BtcLsp.Import",$!!)
(PackageName "btc-lsp",ModuleName "BtcLsp.Import",?:)
(PackageName "btc-lsp",ModuleName "BtcLsp.Import",seq)
(PackageName "btc-lsp",ModuleName "BtcLsp.Import.External",$!)
(PackageName "btc-lsp",ModuleName "BtcLsp.Import.External",$!!)
(PackageName "btc-lsp",ModuleName "BtcLsp.Import.External",?:)
(PackageName "btc-lsp",ModuleName "BtcLsp.Import.External",seq)
(PackageName "btc-lsp",ModuleName "BtcLsp.Yesod.Import.NoFoundation",$)
(PackageName "btc-lsp",ModuleName "BtcLsp.Yesod.Import.NoFoundation",$!)
(PackageName "btc-lsp",ModuleName "BtcLsp.Yesod.Import.NoFoundation",$!!)
(PackageName "btc-lsp",ModuleName "BtcLsp.Yesod.Import.NoFoundation",$$)
(PackageName "btc-lsp",ModuleName "BtcLsp.Yesod.Import.NoFoundation",$$+)
(PackageName "btc-lsp",ModuleName "BtcLsp.Yesod.Import.NoFoundation",$$++)
(PackageName "btc-lsp",ModuleName "BtcLsp.Yesod.Import.NoFoundation",$$+-)
(PackageName "btc-lsp",ModuleName "BtcLsp.Yesod.Import.NoFoundation",=$$+)
(PackageName "btc-lsp",ModuleName "BtcLsp.Yesod.Import.NoFoundation",=$$++)
(PackageName "btc-lsp",ModuleName "BtcLsp.Yesod.Import.NoFoundation",=$$+-)
(PackageName "btc-lsp",ModuleName "BtcLsp.Yesod.Import.NoFoundation",seq)
(PackageName "buchhaltung",ModuleName "Buchhaltung.Utils",<&>)
(PackageName "cabal-install-solver",ModuleName "Distribution.Solver.Compat.Prelude",$)
(PackageName "cabal-install-solver",ModuleName "Distribution.Solver.Compat.Prelude",$!)
(PackageName "cabal-install-solver",ModuleName "Distribution.Solver.Compat.Prelude",deepseq)
(PackageName "cabal-install-solver",ModuleName "Distribution.Solver.Compat.Prelude",seq)
(PackageName "caster",ModuleName "System.Log.Caster",$:)
(PackageName "caster",ModuleName "System.Log.Caster.Core",$:)
(PackageName "caster",ModuleName "System.Log.Caster.Monad",$:)
(PackageName "cfn-flip",ModuleName "CfnFlip.Prelude",$)
(PackageName "cfn-flip",ModuleName "CfnFlip.Prelude",$!)
(PackageName "cfn-flip",ModuleName "CfnFlip.Prelude",seq)
(PackageName "chassis",ModuleName "Chassis",$)
(PackageName "clash-prelude",ModuleName "Clash.Explicit.Prelude",seqV)
(PackageName "clash-prelude",ModuleName "Clash.Explicit.Prelude",seqVX)
(PackageName "clash-prelude",ModuleName "Clash.Explicit.Prelude.Safe",seqV)
(PackageName "clash-prelude",ModuleName "Clash.Explicit.Prelude.Safe",seqVX)
(PackageName "clash-prelude",ModuleName "Clash.HaskellPrelude",$)
(PackageName "clash-prelude",ModuleName "Clash.HaskellPrelude",$!)
(PackageName "clash-prelude",ModuleName "Clash.HaskellPrelude",seq)
(PackageName "clash-prelude",ModuleName "Clash.Prelude",seqV)
(PackageName "clash-prelude",ModuleName "Clash.Prelude",seqVX)
(PackageName "clash-prelude",ModuleName "Clash.Prelude.Safe",seqV)
(PackageName "clash-prelude",ModuleName "Clash.Prelude.Safe",seqVX)
(PackageName "clash-prelude",ModuleName "Clash.Sized.Vector",seqV)
(PackageName "clash-prelude",ModuleName "Clash.Sized.Vector",seqVX)
(PackageName "clash-prelude",ModuleName "Clash.Verification.DSL",~>)
(PackageName "clash-prelude",ModuleName "Clash.XException",deepseqX)
(PackageName "clash-prelude",ModuleName "Clash.XException",defaultSeqX)
(PackageName "clash-prelude",ModuleName "Clash.XException",hwSeqX)
(PackageName "clash-prelude",ModuleName "Clash.XException",seqErrorX)
(PackageName "clash-prelude",ModuleName "Clash.XException",seqX)
(PackageName "classy-prelude",ModuleName "ClassyPrelude",$)
(PackageName "classy-prelude",ModuleName "ClassyPrelude",$!)
(PackageName "classy-prelude",ModuleName "ClassyPrelude",$!!)
(PackageName "classy-prelude",ModuleName "ClassyPrelude",seq)
(PackageName "classy-prelude-conduit",ModuleName "ClassyPrelude.Conduit",$$)
(PackageName "classy-prelude-conduit",ModuleName "ClassyPrelude.Conduit",$$+)
(PackageName "classy-prelude-conduit",ModuleName "ClassyPrelude.Conduit",$$++)
(PackageName "classy-prelude-conduit",ModuleName "ClassyPrelude.Conduit",$$+-)
(PackageName "classy-prelude-conduit",ModuleName "ClassyPrelude.Conduit",=$$+)
(PackageName "classy-prelude-conduit",ModuleName "ClassyPrelude.Conduit",=$$++)
(PackageName "classy-prelude-conduit",ModuleName "ClassyPrelude.Conduit",=$$+-)
(PackageName "clerk",ModuleName "Clerk",|$|)
(PackageName "cleveland",ModuleName "Test.Cleveland",?-)
(PackageName "cleveland",ModuleName "Test.Cleveland.Util",?-)
(PackageName "code-conjure",ModuleName "Conjure.Engine",-==>-)
(PackageName "code-conjure",ModuleName "Conjure.Expr",-==>-)
(PackageName "codeworld-api",ModuleName "CodeWorld",&)
(PackageName "codeworld-api",ModuleName "CodeWorld.Reflex",&)
(PackageName "compdata",ModuleName "Data.Comp.Mapping",&)
(PackageName "compdata",ModuleName "Data.Comp.Multi.HFunctor",:->)
(PackageName "compdata",ModuleName "Data.Comp.Multi.HFunctor",:=>)
(PackageName "compdata",ModuleName "Data.Comp.Multi.Mapping",&)
(PackageName "compdata",ModuleName "Data.Comp.Multi.Variables",&)
(PackageName "compdata",ModuleName "Data.Comp.Variables",&)
(PackageName "compdata-automata",ModuleName "Data.Comp.Automata",&)
(PackageName "cond",ModuleName "Control.Conditional",<<|)
(PackageName "cond",ModuleName "Control.Conditional",<|)
(PackageName "cond",ModuleName "Control.Conditional",?)
(PackageName "cond",ModuleName "Control.Conditional",|>)
(PackageName "cond",ModuleName "Control.Conditional",|>>)
(PackageName "cond",ModuleName "Control.Conditional",⊲)
(PackageName "cond",ModuleName "Control.Conditional",⊳)
(PackageName "conduit",ModuleName "Data.Conduit",$$)
(PackageName "conduit",ModuleName "Data.Conduit",$$+)
(PackageName "conduit",ModuleName "Data.Conduit",$$++)
(PackageName "conduit",ModuleName "Data.Conduit",$$+-)
(PackageName "conduit",ModuleName "Data.Conduit",=$$+)
(PackageName "conduit",ModuleName "Data.Conduit",=$$++)
(PackageName "conduit",ModuleName "Data.Conduit",=$$+-)
(PackageName "conduit",ModuleName "Data.Conduit.Internal",$$)
(PackageName "conduit",ModuleName "Data.Conduit.Internal",$$+)
(PackageName "conduit",ModuleName "Data.Conduit.Internal",$$++)
(PackageName "conduit",ModuleName "Data.Conduit.Internal",$$+-)
(PackageName "conduit",ModuleName "Data.Conduit.Internal",=$$+)
(PackageName "conduit",ModuleName "Data.Conduit.Internal",=$$++)
(PackageName "conduit",ModuleName "Data.Conduit.Internal",=$$+-)
(PackageName "config-ini",ModuleName "Data.Ini.Config.Bidir",.=)
(PackageName "config-ini",ModuleName "Data.Ini.Config.Bidir",.=?)
(PackageName "constrained-categories",ModuleName "Control.Arrow.Constrained",$)
(PackageName "constrained-categories",ModuleName "Control.Category.Constrained",$~)
(PackageName "constrained-categories",ModuleName "Control.Category.Constrained.Prelude",$)
(PackageName "constrained-categories",ModuleName "Control.Category.Constrained.Prelude",$!)
(PackageName "constrained-categories",ModuleName "Control.Category.Constrained.Prelude",$~)
(PackageName "constrained-categories",ModuleName "Control.Category.Constrained.Prelude",seq)
(PackageName "constrained-categories",ModuleName "Control.Category.Hask",$)
(PackageName "constrained-categories",ModuleName "Control.Category.Hask",$!)
(PackageName "constrained-categories",ModuleName "Control.Category.Hask",seq)
(PackageName "construct",ModuleName "Construct",<?>)
(PackageName "control-invariants",ModuleName "Control.Invariant",##)
(PackageName "copilot-language",ModuleName "Copilot.Language.Prelude",$)
(PackageName "copilot-language",ModuleName "Copilot.Language.Prelude",$!)
(PackageName "copilot-language",ModuleName "Copilot.Language.Prelude",seq)
(PackageName "cornea",ModuleName "Cornea.Prelude",$)
(PackageName "cornea",ModuleName "Cornea.Prelude",$!)
(PackageName "cornea",ModuleName "Cornea.Prelude",$!!)
(PackageName "cornea",ModuleName "Cornea.Prelude",?:)
(PackageName "cornea",ModuleName "Cornea.Prelude",seq)
(PackageName "darcs",ModuleName "Darcs.Prelude",$)
(PackageName "darcs",ModuleName "Darcs.Prelude",$!)
(PackageName "darcs",ModuleName "Darcs.Prelude",seq)
(PackageName "data-lens",ModuleName "Data.Lens.Common",^$)
(PackageName "data-lens",ModuleName "Data.Lens.Common",^$!)
(PackageName "data-lens",ModuleName "Data.Lens.Partial.Common",^$)
(PackageName "deep-transformations",ModuleName "Transformation",$)
(PackageName "deepseq",ModuleName "Control.DeepSeq",$!!)
(PackageName "deepseq",ModuleName "Control.DeepSeq",deepseq)
(PackageName "defun-core",ModuleName "DeFun.Core",:~>)
(PackageName "defun-core",ModuleName "DeFun.Core",~>)
(PackageName "dimensional",ModuleName "Numeric.Units.Dimensional.Prelude",$)
(PackageName "dimensional",ModuleName "Numeric.Units.Dimensional.Prelude",$!)
(PackageName "dimensional",ModuleName "Numeric.Units.Dimensional.Prelude",seq)
(PackageName "dino",ModuleName "Dino.Prelude",$)
(PackageName "dino",ModuleName "Dino.Prelude",$!)
(PackageName "dino",ModuleName "Dino.Prelude",seq)
(PackageName "distributed-closure",ModuleName "Control.Distributed.Closure",/->)
(PackageName "distribution-opensuse",ModuleName "OpenSuse.Prelude",$)
(PackageName "distribution-opensuse",ModuleName "OpenSuse.Prelude",$!)
(PackageName "distribution-opensuse",ModuleName "OpenSuse.Prelude",seq)
(PackageName "ditto",ModuleName "Ditto.Core",@$)
(PackageName "dmcc",ModuleName "DMCC.Prelude",$)
(PackageName "dmcc",ModuleName "DMCC.Prelude",$!)
(PackageName "dmcc",ModuleName "DMCC.Prelude",$!!)
(PackageName "dovetail",ModuleName "Dovetail.FFI.Builder",~>)
(PackageName "electrs-client",ModuleName "ElectrsClient.Import.External",$!)
(PackageName "electrs-client",ModuleName "ElectrsClient.Import.External",$!!)
(PackageName "electrs-client",ModuleName "ElectrsClient.Import.External",?:)
(PackageName "electrs-client",ModuleName "ElectrsClient.Import.External",seq)
(PackageName "entwine",ModuleName "Entwine.P",$)
(PackageName "entwine",ModuleName "Entwine.P",$!)
(PackageName "errors",ModuleName "Control.Error.Util",?:)
(PackageName "ersatz",ModuleName "Ersatz.Bit",==>)
(PackageName "espial",ModuleName "Import.NoFoundation",$)
(PackageName "espial",ModuleName "Import.NoFoundation",$!)
(PackageName "espial",ModuleName "Import.NoFoundation",$!!)
(PackageName "espial",ModuleName "Import.NoFoundation",$$)
(PackageName "espial",ModuleName "Import.NoFoundation",$$+)
(PackageName "espial",ModuleName "Import.NoFoundation",$$++)
(PackageName "espial",ModuleName "Import.NoFoundation",$$+-)
(PackageName "espial",ModuleName "Import.NoFoundation",=$$+)
(PackageName "espial",ModuleName "Import.NoFoundation",=$$++)
(PackageName "espial",ModuleName "Import.NoFoundation",=$$+-)
(PackageName "espial",ModuleName "Import.NoFoundation",deepseq)
(PackageName "espial",ModuleName "Import.NoFoundation",seq)
(PackageName "express",ModuleName "Data.Express.Fixtures",-==>-)
(PackageName "extensible",ModuleName "Data.Extensible.Product",<!)
(PackageName "extensible",ModuleName "Data.Extensible.Product",<:)
(PackageName "extensible",ModuleName "Data.Extensible.Product",=<:)
(PackageName "extrapolate",ModuleName "Test.Extrapolate",==>)
(PackageName "extrapolate",ModuleName "Test.Extrapolate.Core",==>)
(PackageName "faktory",ModuleName "Faktory.Prelude",$)
(PackageName "faktory",ModuleName "Faktory.Prelude",$!)
(PackageName "faktory",ModuleName "Faktory.Prelude",seq)
(PackageName "fay",ModuleName "Fay.Compiler.Prelude",$)
(PackageName "fay",ModuleName "Fay.Compiler.Prelude",$!)
(PackageName "fay",ModuleName "Fay.Compiler.Prelude",seq)
(PackageName "fay-base",ModuleName "Prelude",$)
(PackageName "fay-base",ModuleName "Prelude",$!)
(PackageName "fay-base",ModuleName "Prelude",seq)
(PackageName "first-class-families",ModuleName "Fcf",$)
(PackageName "first-class-families",ModuleName "Fcf.Combinators",$)
(PackageName "first-class-instances",ModuleName "FCI",==>)
(PackageName "first-class-instances",ModuleName "FCI.Internal.Definitions",==>)
(PackageName "flow",ModuleName "Flow",<!)
(PackageName "flow",ModuleName "Flow",<|)
(PackageName "flow-er",ModuleName "Control.Flower.Apply.Lazy",<|)
(PackageName "flow-er",ModuleName "Control.Flower.Apply.Lazy",>|)
(PackageName "flow-er",ModuleName "Control.Flower.Apply.Strict",<!)
(PackageName "foundation",ModuleName "Foundation",$)
(PackageName "foundation",ModuleName "Foundation",$!)
(PackageName "foundation",ModuleName "Foundation",seq)
(PackageName "freckle-app",ModuleName "Freckle.App.Prelude",$)
(PackageName "freckle-app",ModuleName "Freckle.App.Prelude",$!)
(PackageName "freckle-app",ModuleName "Freckle.App.Prelude",seq)
(PackageName "freckle-app",ModuleName "Freckle.App.Test",$)
(PackageName "freckle-app",ModuleName "Freckle.App.Test",$!)
(PackageName "freckle-app",ModuleName "Freckle.App.Test",seq)
(PackageName "freelude",ModuleName "Freelude.Impl.ExoFunctor",$)
(PackageName "freelude",ModuleName "Freelude.Impl.ExoFunctor",$!)
(PackageName "freer-simple",ModuleName "Control.Monad.Freer",~>)
(PackageName "frp-arduino",ModuleName "Arduino.DSL",=:)
(PackageName "funcmp",ModuleName "FMP.Types",<*)
(PackageName "funcmp",ModuleName "FMP.Types",<+)
(PackageName "functor-combinators",ModuleName "Control.Natural.IsoF",<~>)
(PackageName "functor-combinators",ModuleName "Control.Natural.IsoF",~>)
(PackageName "functor-combinators",ModuleName "Data.Functor.Combinator",<~>)
(PackageName "functor-combinators",ModuleName "Data.Functor.Combinator",~>)
(PackageName "g4ip-prover",ModuleName "G4ipProver.Proposition",<=>)
(PackageName "ghc",ModuleName "GHC.Tc.Gen.Expr",SynFun)
(PackageName "ghc",ModuleName "GHC.Tc.Utils.TcType",SynFun)
(PackageName "ghc-internal",ModuleName "GHC.Internal.Base",$)
(PackageName "ghc-internal",ModuleName "GHC.Internal.Base",$!)
(PackageName "ghc-internal",ModuleName "GHC.Internal.Base",seq)
(PackageName "ghc-internal",ModuleName "GHC.Internal.Conc.Sync",par)
(PackageName "ghc-internal",ModuleName "GHC.Internal.Conc.Sync",pseq)
(PackageName "ghc-internal",ModuleName "GHC.Internal.Data.Function",$)
(PackageName "ghc-internal",ModuleName "GHC.Internal.Exts",seq)
(PackageName "ghc-lib",ModuleName "GHC.Tc.Gen.Expr",SynFun)
(PackageName "ghc-lib-parser",ModuleName "GHC.Prelude.Basic",$)
(PackageName "ghc-lib-parser",ModuleName "GHC.Prelude.Basic",$!)
(PackageName "ghc-lib-parser",ModuleName "GHC.Prelude.Basic",seq)
(PackageName "ghc-lib-parser",ModuleName "GHC.Tc.Utils.TcType",SynFun)
(PackageName "ghc-mod",ModuleName "GhcMod.Error",modifyError')
(PackageName "ghc-prim",ModuleName "GHC.Prim",seq)
(PackageName "ghc-source-gen",ModuleName "GHC.SourceGen.Type",-->)
(PackageName "ghc-source-gen",ModuleName "GHC.SourceGen.Type",==>)
(PackageName "ghcjs-hplay",ModuleName "GHCJS.HPlay.Cell",.=)
(PackageName "github",ModuleName "GitHub.Internal.Prelude",$)
(PackageName "github",ModuleName "GitHub.Internal.Prelude",$!)
(PackageName "github",ModuleName "GitHub.Internal.Prelude",seq)
(PackageName "glib",ModuleName "System.Glib.Attributes",::=)
(PackageName "glib",ModuleName "System.Glib.Attributes",::~)
(PackageName "glib",ModuleName "System.Glib.Attributes",:=)
(PackageName "glib",ModuleName "System.Glib.Attributes",:=>)
(PackageName "glib",ModuleName "System.Glib.Attributes",:~)
(PackageName "glib",ModuleName "System.Glib.Attributes",:~>)
(PackageName "goal-core",ModuleName "Goal.Core",$)
(PackageName "goal-core",ModuleName "Goal.Core",$!!)
(PackageName "gogol-core",ModuleName "Network.Google.Prelude",$)
(PackageName "gogol-core",ModuleName "Network.Google.Prelude",$!)
(PackageName "grammatical-parsers",ModuleName "Text.Grampa",<?>)
(PackageName "grapefruit-records",ModuleName "Data.Record.Context",app)
(PackageName "greskell",ModuleName "Data.Greskell",$.)
(PackageName "greskell",ModuleName "Data.Greskell",<$.>)
(PackageName "greskell",ModuleName "Data.Greskell",<*.>)
(PackageName "greskell",ModuleName "Data.Greskell.GTraversal",$.)
(PackageName "greskell",ModuleName "Data.Greskell.GTraversal",<$.>)
(PackageName "greskell",ModuleName "Data.Greskell.GTraversal",<*.>)
(PackageName "greskell",ModuleName "Data.Greskell.GTraversal.Gen",$.)
(PackageName "greskell",ModuleName "Data.Greskell.GTraversal.Gen",<$.>)
(PackageName "greskell",ModuleName "Data.Greskell.GTraversal.Gen",<*.>)
(PackageName "grisette",ModuleName "Grisette.Internal.SymPrim.GeneralFun",-->)
(PackageName "grisette",ModuleName "Grisette.Internal.SymPrim.SymGeneralFun",-->)
(PackageName "grisette",ModuleName "Grisette.Internal.SymPrim.SymGeneralFun",-~>)
(PackageName "grisette",ModuleName "Grisette.Internal.SymPrim.SymTabularFun",=~>)
(PackageName "grisette",ModuleName "Grisette.Internal.SymPrim.TabularFun",=->)
(PackageName "grisette",ModuleName "Grisette.SymPrim",-->)
(PackageName "grisette",ModuleName "Grisette.SymPrim",-~>)
(PackageName "grisette",ModuleName "Grisette.SymPrim",=->)
(PackageName "grisette",ModuleName "Grisette.SymPrim",=~>)
(PackageName "group-theory",ModuleName "Data.Group.Permutation",$-)
(PackageName "group-theory",ModuleName "Data.Group.Permutation",-$)
(PackageName "hakaru",ModuleName "Language.Hakaru.Types.DataKind",:->)
(PackageName "hakaru",ModuleName "Language.Hakaru.Types.Sing",SFun)
(PackageName "haskell-ci",ModuleName "HaskellCI.Prelude",$)
(PackageName "haskell-ci",ModuleName "HaskellCI.Prelude",$!)
(PackageName "haskell-ci",ModuleName "HaskellCI.Prelude",seq)
(PackageName "haskell-gi-base",ModuleName "Data.GI.Base",:=)
(PackageName "haskell-gi-base",ModuleName "Data.GI.Base",:=>)
(PackageName "haskell-gi-base",ModuleName "Data.GI.Base",:~)
(PackageName "haskell-gi-base",ModuleName "Data.GI.Base",:~>)
(PackageName "haskell-gi-base",ModuleName "Data.GI.Base.Attributes",:=)
(PackageName "haskell-gi-base",ModuleName "Data.GI.Base.Attributes",:=>)
(PackageName "haskell-gi-base",ModuleName "Data.GI.Base.Attributes",:~)
(PackageName "haskell-gi-base",ModuleName "Data.GI.Base.Attributes",:~>)
(PackageName "haskell-gi-base",ModuleName "Data.GI.Base.ShortPrelude",$)
(PackageName "haskell-gi-base",ModuleName "Data.GI.Base.ShortPrelude",:=)
(PackageName "haskell-gi-base",ModuleName "Data.GI.Base.ShortPrelude",:=>)
(PackageName "haskell-gi-base",ModuleName "Data.GI.Base.ShortPrelude",:~)
(PackageName "haskell-gi-base",ModuleName "Data.GI.Base.ShortPrelude",:~>)
(PackageName "haskell-src-meta",ModuleName "Language.Haskell.Meta.Utils",|$|)
(PackageName "haskell2020",ModuleName "Prelude",$)
(PackageName "haskell2020",ModuleName "Prelude",$!)
(PackageName "hasklepias",ModuleName "Hasklepias.Reexports",$)
(PackageName "hasklepias",ModuleName "Hasklepias.Reexports",<!)
(PackageName "hasklepias",ModuleName "Hasklepias.Reexports",<|)
(PackageName "hasktorch-codegen",ModuleName "CodeGen.Prelude",$)
(PackageName "hasktorch-codegen",ModuleName "CodeGen.Prelude",$!)
(PackageName "haskus-utils",ModuleName "Haskus.Utils.Flow",<|)
(PackageName "haskus-utils",ModuleName "Haskus.Utils.Flow",<||)
(PackageName "haskus-utils",ModuleName "Haskus.Utils.Flow",<|||)
(PackageName "haxl",ModuleName "Haxl.Prelude",$)
(PackageName "haxl",ModuleName "Haxl.Prelude",$!)
(PackageName "haxl",ModuleName "Haxl.Prelude",seq)
(PackageName "heart-core",ModuleName "Heart.Core.Prelude",$)
(PackageName "heart-core",ModuleName "Heart.Core.Prelude",$!)
(PackageName "hedgehog",ModuleName "Hedgehog.Internal.Prelude",$)
(PackageName "hedgehog",ModuleName "Hedgehog.Internal.Prelude",$!)
(PackageName "hedgehog",ModuleName "Hedgehog.Internal.Prelude",seq)
(PackageName "hgrep",ModuleName "Language.Haskell.HGrep.Prelude",$)
(PackageName "hgrep",ModuleName "Language.Haskell.HGrep.Prelude",$!)
(PackageName "hlatex",ModuleName "Language.LaTeX",!$)
(PackageName "hlatex",ModuleName "Language.LaTeX",!$?)
(PackageName "hlatex",ModuleName "Language.LaTeX",$?)
(PackageName "hlatex",ModuleName "Language.LaTeX.Builder",!$)
(PackageName "hlatex",ModuleName "Language.LaTeX.Builder",!$?)
(PackageName "hlatex",ModuleName "Language.LaTeX.Builder",$?)
(PackageName "hlatex",ModuleName "Language.LaTeX.Slicer",^$)
(PackageName "hledger-web",ModuleName "Hledger.Web.Import",$)
(PackageName "hledger-web",ModuleName "Hledger.Web.Import",$!)
(PackageName "hledger-web",ModuleName "Hledger.Web.Import",seq)
(PackageName "hnix",ModuleName "Nix.Prelude",$)
(PackageName "hnix",ModuleName "Nix.Prelude",$!)
(PackageName "hnix",ModuleName "Nix.Prelude",$!!)
(PackageName "hnix",ModuleName "Nix.Prelude",?:)
(PackageName "hnix",ModuleName "Nix.Prelude",seq)
(PackageName "hoodle-core",ModuleName "Hoodle.Util",#)
(PackageName "hoppy-generator",ModuleName "Foreign.Hoppy.Generator.Spec",~:)
(PackageName "hspec-multicheck",ModuleName "Test.Hspec.Multicheck",==>)
(PackageName "hspec-wai",ModuleName "Test.Hspec.Wai.QuickCheck",==>)
(PackageName "http-pony",ModuleName "Network.HTTP.Pony.Helper",-)
(PackageName "http-pony-serve-wai",ModuleName "Network.HTTP.Pony.Serve.Wai.Helper",-)
(PackageName "humble-prelude",ModuleName "HumblePrelude",$)
(PackageName "humble-prelude",ModuleName "HumblePrelude",$!)
(PackageName "hxt",ModuleName "Control.FlatSeq",$!!)
(PackageName "hxt",ModuleName "Text.XML.HXT.DTDValidation.TypeDefs",$$)
(PackageName "hydra",ModuleName "Hydra.Impl.Haskell.Dsl.Base",-->)
(PackageName "hydra",ModuleName "Hydra.Impl.Haskell.Dsl.Base",>:)
(PackageName "hydra",ModuleName "Hydra.Impl.Haskell.Dsl.Base",@->)
(PackageName "hydra",ModuleName "Hydra.Impl.Haskell.Dsl.Grammars",>:)
(PackageName "hydra",ModuleName "Hydra.Impl.Haskell.Dsl.Types",-->)
(PackageName "hydra",ModuleName "Hydra.Impl.Haskell.Dsl.Types",>:)
(PackageName "hypertypes",ModuleName "Hyper",#*#)
(PackageName "hypertypes",ModuleName "Hyper",#>)
(PackageName "hypertypes",ModuleName "Hyper.Class.Nodes",#*#)
(PackageName "hypertypes",ModuleName "Hyper.Class.Nodes",#>)
(PackageName "hypertypes",ModuleName "Hyper.Recurse",##>>)
(PackageName "hypertypes",ModuleName "Hyper.Recurse",#**#)
(PackageName "hypertypes",ModuleName "Hyper.Recurse",#>>)
(PackageName "ideas",ModuleName "Ideas.Common.Traversal.Utils",>|<)
(PackageName "ihaskell",ModuleName "IHaskellPrelude",$)
(PackageName "ihaskell",ModuleName "IHaskellPrelude",$!)
(PackageName "ihaskell",ModuleName "IHaskellPrelude",seq)
(PackageName "impl",ModuleName "Impl",:->)
(PackageName "incipit-base",ModuleName "Incipit.Base",$)
(PackageName "incipit-base",ModuleName "Incipit.Base",$!)
(PackageName "incipit-base",ModuleName "Incipit.Base",seq)
(PackageName "indigo",ModuleName "Indigo",#=)
(PackageName "indigo",ModuleName "Indigo",$!)
(PackageName "indigo",ModuleName "Indigo",$!!)
(PackageName "indigo",ModuleName "Indigo",/->)
(PackageName "indigo",ModuleName "Indigo",//->)
(PackageName "indigo",ModuleName "Indigo",:=)
(PackageName "indigo",ModuleName "Indigo",:>)
(PackageName "indigo",ModuleName "Indigo",=:)
(PackageName "indigo",ModuleName "Indigo",seq)
(PackageName "indigo",ModuleName "Indigo.Backend.Prelude",$!)
(PackageName "indigo",ModuleName "Indigo.Backend.Prelude",$!!)
(PackageName "indigo",ModuleName "Indigo.Backend.Prelude",?:)
(PackageName "indigo",ModuleName "Indigo.Backend.Prelude",seq)
(PackageName "indigo",ModuleName "Indigo.Frontend.Language",#=)
(PackageName "indigo",ModuleName "Indigo.Frontend.Language",//->)
(PackageName "indigo",ModuleName "Indigo.Frontend.Language",=:)
(PackageName "indigo",ModuleName "Indigo.Lorentz",/->)
(PackageName "indigo",ModuleName "Indigo.Lorentz",:=)
(PackageName "indigo",ModuleName "Indigo.Lorentz",:>)
(PackageName "indigo",ModuleName "Indigo.Prelude",$!)
(PackageName "indigo",ModuleName "Indigo.Prelude",$!!)
(PackageName "indigo",ModuleName "Indigo.Prelude",seq)
(PackageName "interlude-l",ModuleName "Interlude",$)
(PackageName "interlude-l",ModuleName "Interlude",$!)
(PackageName "interlude-l",ModuleName "Interlude",$!!)
(PackageName "intro",ModuleName "Intro",$)
(PackageName "intro",ModuleName "Intro",$!)
(PackageName "ipfs",ModuleName "Network.IPFS.Prelude",$)
(PackageName "ipfs",ModuleName "Network.IPFS.Prelude",$!)
(PackageName "ipfs",ModuleName "Network.IPFS.Prelude",$!!)
(PackageName "ipfs",ModuleName "Network.IPFS.Prelude",seq)
(PackageName "isobmff",ModuleName "Data.ByteString.IsoBaseFileFormat.ReExports",?::)
(PackageName "isobmff",ModuleName "Data.Type.BitRecords.Assert",?::)
(PackageName "joint",ModuleName "Control.Joint.Core",:=)
(PackageName "joint",ModuleName "Control.Joint.Core",~>)
(PackageName "kerry",ModuleName "Kerry.Internal.Prelude",$)
(PackageName "kerry",ModuleName "Kerry.Internal.Prelude",$!)
(PackageName "kindly-functors",ModuleName "Kindly.Class",~>)
(PackageName "kmonad",ModuleName "KMonad.Prelude.Imports",$)
(PackageName "kmonad",ModuleName "KMonad.Prelude.Imports",$!)
(PackageName "kmonad",ModuleName "KMonad.Prelude.Imports",$!!)
(PackageName "kmonad",ModuleName "KMonad.Prelude.Imports",deepseq)
(PackageName "kmonad",ModuleName "KMonad.Prelude.Imports",seq)
(PackageName "language-css",ModuleName "Language.Css.Build",<:>)
(PackageName "lawz",ModuleName "Test.Logic",==>)
(PackageName "lazy-search",ModuleName "Control.Search",==>)
(PackageName "lazy-search",ModuleName "Data.Coolean",==>)
(PackageName "leancheck",ModuleName "Test.LeanCheck",==>)
(PackageName "leancheck",ModuleName "Test.LeanCheck.Core",==>)
(PackageName "leancheck",ModuleName "Test.LeanCheck.Error",==>)
(PackageName "leancheck",ModuleName "Test.LeanCheck.Utils.Operators",==>)
(PackageName "lifted-protolude",ModuleName "Protolude.Lifted",$!)
(PackageName "linear",ModuleName "Linear.Covector",$*)
(PackageName "linear-accelerate",ModuleName "Data.Array.Accelerate.Linear.Projection",$$$$$$)
(PackageName "linear-base",ModuleName "Data.Array.Mutable.Unlifted.Linear",lseq)
(PackageName "linear-base",ModuleName "Data.Unrestricted.Linear",lseq)
(PackageName "linear-base",ModuleName "Prelude.Linear",$)
(PackageName "linear-base",ModuleName "Prelude.Linear",$!)
(PackageName "linear-base",ModuleName "Prelude.Linear",lseq)
(PackageName "linear-base",ModuleName "Prelude.Linear",seq)
(PackageName "linear-smc",ModuleName "Control.Category.Constrained",//)
(PackageName "linearmap-category",ModuleName "Math.LinearMap.Category",-+$>)
(PackageName "linearmap-category",ModuleName "Math.LinearMap.Category",<$|)
(PackageName "linearmap-category",ModuleName "Math.LinearMap.Category",\$)
(PackageName "linearmap-category",ModuleName "Math.LinearMap.Category",|$|)
(PackageName "linearmap-category",ModuleName "Math.LinearMap.Coercion",-+$=>)
(PackageName "list-extras",ModuleName "Prelude.Listless",$)
(PackageName "list-extras",ModuleName "Prelude.Listless",$!)
(PackageName "list-extras",ModuleName "Prelude.Listless",seq)
(PackageName "live-sequencer",ModuleName "Function",$)
(PackageName "llvm-hs-pure",ModuleName "LLVM.Prelude",$)
(PackageName "llvm-hs-pure",ModuleName "LLVM.Prelude",$!)
(PackageName "llvm-hs-pure",ModuleName "LLVM.Prelude",seq)
(PackageName "llvm-party",ModuleName "LLVM.Prelude",$)
(PackageName "llvm-party",ModuleName "LLVM.Prelude",$!)
(PackageName "llvm-party",ModuleName "LLVM.Prelude",seq)
(PackageName "llvm-pretty",ModuleName "Text.LLVM",:>)
(PackageName "loc",ModuleName "Data.Loc.Internal.Prelude",$)
(PackageName "lol",ModuleName "Crypto.Lol.Prelude",$)
(PackageName "lol",ModuleName "Crypto.Lol.Prelude",$!)
(PackageName "lorentz",ModuleName "Lorentz",$)
(PackageName "lorentz",ModuleName "Lorentz",/->)
(PackageName "lorentz",ModuleName "Lorentz",:=)
(PackageName "lorentz",ModuleName "Lorentz",:>)
(PackageName "lorentz",ModuleName "Lorentz",|@|)
(PackageName "lorentz",ModuleName "Lorentz.ADT",/->)
(PackageName "lorentz",ModuleName "Lorentz.ADT",:=)
(PackageName "lorentz",ModuleName "Lorentz.Entrypoints",:>)
(PackageName "lorentz",ModuleName "Lorentz.Entrypoints.Core",:>)
(PackageName "lorentz",ModuleName "Lorentz.Expr",|@|)
(PackageName "lorentz",ModuleName "Lorentz.ReferencedByName",:=)
(PackageName "lucid-extras",ModuleName "Lucid.Bootstrap3",$:)
(PackageName "lumberjack",ModuleName "Lumberjack",|#)
(PackageName "magicbane",ModuleName "Magicbane",?:)
(PackageName "map-syntax",ModuleName "Data.Map.Syntax",#!)
(PackageName "map-syntax",ModuleName "Data.Map.Syntax",##)
(PackageName "map-syntax",ModuleName "Data.Map.Syntax",#?)
(PackageName "massiv-test",ModuleName "Test.Massiv.Utils",==>)
(PackageName "mezzo",ModuleName "Mezzo",$)
(PackageName "mismi-p",ModuleName "P",$)
(PackageName "mismi-p",ModuleName "P",$!)
(PackageName "mit-3qvpPyAi6mH",ModuleName "Mit.Prelude",$)
(PackageName "mit-3qvpPyAi6mH",ModuleName "Mit.Prelude",$!)
(PackageName "mit-3qvpPyAi6mH",ModuleName "Mit.Prelude",seq)
(PackageName "mixed-types-num",ModuleName "Numeric.MixedTypes.PreludeHiding",$)
(PackageName "mixed-types-num",ModuleName "Numeric.MixedTypes.PreludeHiding",$!)
(PackageName "mixed-types-num",ModuleName "Numeric.MixedTypes.PreludeHiding",seq)
(PackageName "morley",ModuleName "Morley.Util.Binary",##:)
(PackageName "morley",ModuleName "Morley.Util.Binary",#:)
(PackageName "morley-prelude",ModuleName "Prelude",$)
(PackageName "morley-prelude",ModuleName "Prelude",$!)
(PackageName "morley-prelude",ModuleName "Prelude",$!!)
(PackageName "morley-prelude",ModuleName "Prelude",?:)
(PackageName "morley-prelude",ModuleName "Prelude",deepseq)
(PackageName "morley-prelude",ModuleName "Prelude",seq)
(PackageName "morley-upgradeable",ModuleName "Lorentz.Contracts.Upgradeable.EntrypointWise",/==>)
(PackageName "morphisms",ModuleName "Control.Morphism",$)
(PackageName "mprelude",ModuleName "MPrelude",$)
(PackageName "nemesis",ModuleName "System.Nemesis.Utils",-)
(PackageName "noether",ModuleName "Lemmata.Base",$!)
(PackageName "nom",ModuleName "Language.Nominal.Abs",:@>)
(PackageName "nom",ModuleName "Language.Nominal.Binder",:@@!)
(PackageName "nom",ModuleName "Language.Nominal.Equivar",$$)
(PackageName "nri-prelude",ModuleName "Basics",<|)
(PackageName "numeric-prelude",ModuleName "NumericPrelude",$)
(PackageName "numeric-prelude",ModuleName "NumericPrelude",$!)
(PackageName "numeric-prelude",ModuleName "NumericPrelude",seq)
(PackageName "numeric-prelude",ModuleName "NumericPrelude.Base",$)
(PackageName "numeric-prelude",ModuleName "NumericPrelude.Base",$!)
(PackageName "numeric-prelude",ModuleName "NumericPrelude.Base",seq)
(PackageName "numhask",ModuleName "NumHask.Prelude",$)
(PackageName "numhask",ModuleName "NumHask.Prelude",$!)
(PackageName "numhask",ModuleName "NumHask.Prelude",seq)
(PackageName "numhask-prelude",ModuleName "NumHask.Prelude",$)
(PackageName "numhask-prelude",ModuleName "NumHask.Prelude",$!!)
(PackageName "oalg-base",ModuleName "OAlg.Category.Applicative",$)
(PackageName "oalg-base",ModuleName "OAlg.Category.Definition",$)
(PackageName "oalg-base",ModuleName "OAlg.Data.Statement.Definition",:<=>:)
(PackageName "oalg-base",ModuleName "OAlg.Prelude",seq)
(PackageName "obdd",ModuleName "OBDD.Operation",==>)
(PackageName "optparse-generic",ModuleName "Options.Generic",:::)
(PackageName "pandora",ModuleName "Pandora.Core.Functor",:=:=>)
(PackageName "pandora",ModuleName "Pandora.Core.Functor",:=>)
(PackageName "pandora",ModuleName "Pandora.Core.Functor",<:=)
(PackageName "pandora",ModuleName "Pandora.Core.Functor",~>)
(PackageName "pandora",ModuleName "Pandora.Paradigm.Primary.Functor.Tagged",:#)
(PackageName "papa-base-export",ModuleName "Papa.Base.Export.Data.Function",$)
(PackageName "papa-base-export",ModuleName "Papa.Base.Export.Prelude",$)
(PackageName "parallel",ModuleName "Control.Parallel",par)
(PackageName "parallel",ModuleName "Control.Parallel",pseq)
(PackageName "parsers",ModuleName "Text.Parser.Combinators",<?>)
(PackageName "pasta",ModuleName "Pasta",.!)
(PackageName "pinchot",ModuleName "Pinchot",<?>)
(PackageName "pinchot",ModuleName "Pinchot.Rules",<?>)
(PackageName "planet-mitchell",ModuleName "Eval",$!)
(PackageName "planet-mitchell",ModuleName "Eval",$!!)
(PackageName "planet-mitchell",ModuleName "Function",$)
(PackageName "planet-mitchell",ModuleName "Function",$!)
(PackageName "planet-mitchell",ModuleName "Mitchell.Prelude",$)
(PackageName "planet-mitchell",ModuleName "Mitchell.Prelude",$!)
(PackageName "planet-mitchell",ModuleName "Parallelism",par)
(PackageName "planet-mitchell",ModuleName "Parallelism",pseq)
(PackageName "praglude",ModuleName "Praglude",$)
(PackageName "preamble",ModuleName "Preamble",$)
(PackageName "preamble",ModuleName "Preamble",$!)
(PackageName "precursor",ModuleName "Precursor.Function",$)
(PackageName "predicate-typed",ModuleName "Predicate.Core",$)
(PackageName "pregame",ModuleName "Pregame.Base",$!)
(PackageName "prelude-compat",ModuleName "Prelude2010",$)
(PackageName "prelude-compat",ModuleName "Prelude2010",$!)
(PackageName "preludeplus",ModuleName "PreludePlus",$)
(PackageName "preludeplus",ModuleName "PreludePlus",$!)
(PackageName "prettyprinter-combinators",ModuleName "Prettyprinter.Combinators",-->)
(PackageName "prettyprinter-combinators",ModuleName "Prettyprinter.Combinators",:->)
(PackageName "primal",ModuleName "Control.Prim.Eval",seq)
(PackageName "primal",ModuleName "Foreign.Prim",seq)
(PackageName "profunctor-arrows",ModuleName "Data.Profunctor.Arrow",$$$)
(PackageName "profunctor-misc",ModuleName "Data.Profunctor.Arrow",$$$)
(PackageName "profunctors",ModuleName "Data.Profunctor",:->)
(PackageName "profunctors",ModuleName "Data.Profunctor.Types",:->)
(PackageName "prologue",ModuleName "Prologue",$)
(PackageName "prologue",ModuleName "Prologue",$!)
(PackageName "prologue",ModuleName "Prologue",>>$)
(PackageName "prologue",ModuleName "Prologue.Control.Monad",>>$)
(PackageName "prolude",ModuleName "Prolude.Core",$)
(PackageName "prolude",ModuleName "Prolude.Core",seq)
(PackageName "property",ModuleName "Test.Property.Util",==>)
(PackageName "protolude",ModuleName "Protolude",$)
(PackageName "protolude",ModuleName "Protolude",$!)
(PackageName "protolude",ModuleName "Protolude",$!!)
(PackageName "protolude",ModuleName "Protolude",deepseq)
(PackageName "protolude",ModuleName "Protolude",seq)
(PackageName "protolude",ModuleName "Protolude.Base",$!)
(PackageName "protolude",ModuleName "Protolude.Base",seq)
(PackageName "ptera-core",ModuleName "Language.Parser.Ptera.Prelude",$!)
(PackageName "ptera-core",ModuleName "Language.Parser.Ptera.Prelude",seq)
(PackageName "purenix",ModuleName "PureNix.Prelude",$)
(PackageName "purenix",ModuleName "PureNix.Prelude",$!)
(PackageName "purenix",ModuleName "PureNix.Prelude",seq)
(PackageName "quaalude",ModuleName "Essentials",$)
(PackageName "quickcheck-with-counterexamples",ModuleName "Test.QuickCheck.Counterexamples",==>)
(PackageName "rank2classes",ModuleName "Rank2",$)
(PackageName "rank2classes",ModuleName "Rank2",~>)
(PackageName "rebase",ModuleName "Rebase.Prelude",$)
(PackageName "rebase",ModuleName "Rebase.Prelude",$!)
(PackageName "rebase",ModuleName "Rebase.Prelude",$!!)
(PackageName "rebase",ModuleName "Rebase.Prelude",:->)
(PackageName "rebase",ModuleName "Rebase.Prelude",par)
(PackageName "rebase",ModuleName "Rebase.Prelude",pseq)
(PackageName "rebase",ModuleName "Rebase.Prelude",seq)
(PackageName "rec-smallarray",ModuleName "Data.Rec.SmallArray",~>)
(PackageName "reflex-gi-gtk",ModuleName "Reflex.GI.Gtk",:==)
(PackageName "reflex-gi-gtk",ModuleName "Reflex.GI.Gtk",:==>)
(PackageName "reflex-gi-gtk",ModuleName "Reflex.GI.Gtk",:~~)
(PackageName "reflex-gi-gtk",ModuleName "Reflex.GI.Gtk",:~~>)
(PackageName "reflex-gi-gtk",ModuleName "Reflex.GI.Gtk.Output",:==)
(PackageName "reflex-gi-gtk",ModuleName "Reflex.GI.Gtk.Output",:==>)
(PackageName "reflex-gi-gtk",ModuleName "Reflex.GI.Gtk.Output",:~~)
(PackageName "reflex-gi-gtk",ModuleName "Reflex.GI.Gtk.Output",:~~>)
(PackageName "relude",ModuleName "Relude.Base",$!)
(PackageName "relude",ModuleName "Relude.Base",seq)
(PackageName "relude",ModuleName "Relude.DeepSeq",$!!)
(PackageName "relude",ModuleName "Relude.DeepSeq",deepseq)
(PackageName "relude",ModuleName "Relude.Function",$)
(PackageName "relude",ModuleName "Relude.Monad.Maybe",?:)
(PackageName "repa",ModuleName "Data.Array.Repa.Shape",deepSeq)
(PackageName "rio",ModuleName "RIO.Prelude",$)
(PackageName "rio",ModuleName "RIO.Prelude",$!)
(PackageName "rio",ModuleName "RIO.Prelude",$!!)
(PackageName "rio",ModuleName "RIO.Prelude",seq)
(PackageName "ron",ModuleName "RON.Prelude",$)
(PackageName "ron",ModuleName "RON.Prelude",?:)
(PackageName "sdp",ModuleName "SDP.SafePrelude",...)
(PackageName "servant-util",ModuleName "Servant.Util.Combinators.Filtering.Construction",?/)
(PackageName "servant-util",ModuleName "Servant.Util.Combinators.Filtering.Construction",?/<)
(PackageName "servant-util",ModuleName "Servant.Util.Combinators.Filtering.Construction",?/<=)
(PackageName "servant-util",ModuleName "Servant.Util.Combinators.Filtering.Construction",?/=)
(PackageName "servant-util",ModuleName "Servant.Util.Combinators.Filtering.Construction",?/>)
(PackageName "servant-util",ModuleName "Servant.Util.Combinators.Filtering.Construction",?/>=)
(PackageName "servant-util",ModuleName "Servant.Util.Combinators.Filtering.Construction",textContains)
(PackageName "servant-util",ModuleName "Servant.Util.Combinators.Filtering.Construction",textIContains)
(PackageName "servant-util",ModuleName "Servant.Util.Combinators.Filtering.Construction",textILike)
(PackageName "servant-util",ModuleName "Servant.Util.Combinators.Filtering.Construction",textLike)
(PackageName "shakers",ModuleName "Development.Shakers",$)
(PackageName "shakers",ModuleName "Development.Shakers",$!)
(PackageName "signable",ModuleName "Data.Signable.Import",$)
(PackageName "signable",ModuleName "Data.Signable.Import",$!!)
(PackageName "simple-conduit",ModuleName "Conduit.Simple",$$)
(PackageName "simple-conduit",ModuleName "Conduit.Simple.Compat",$$)
(PackageName "singletons",ModuleName "Data.Singletons",~>)
(PackageName "singletons",ModuleName "Data.Singletons",~>@#@$)
(PackageName "singletons",ModuleName "Data.Singletons",~>@#@$$)
(PackageName "singletons",ModuleName "Data.Singletons",~>@#@$$$)
(PackageName "singletons-base",ModuleName "Data.Function.Singletons",$)
(PackageName "singletons-base",ModuleName "Data.Function.Singletons",$@#@$)
(PackageName "singletons-base",ModuleName "Data.Function.Singletons",$@#@$$)
(PackageName "singletons-base",ModuleName "Data.Function.Singletons",$@#@$$$)
(PackageName "singletons-base",ModuleName "Data.Function.Singletons",%$)
(PackageName "singletons-base",ModuleName "Prelude.Singletons",$)
(PackageName "singletons-base",ModuleName "Prelude.Singletons",$!)
(PackageName "singletons-base",ModuleName "Prelude.Singletons",$!@#@$)
(PackageName "singletons-base",ModuleName "Prelude.Singletons",$!@#@$$)
(PackageName "singletons-base",ModuleName "Prelude.Singletons",$!@#@$$$)
(PackageName "singletons-base",ModuleName "Prelude.Singletons",$@#@$)
(PackageName "singletons-base",ModuleName "Prelude.Singletons",$@#@$$)
(PackageName "singletons-base",ModuleName "Prelude.Singletons",$@#@$$$)
(PackageName "singletons-base",ModuleName "Prelude.Singletons",%$)
(PackageName "singletons-base",ModuleName "Prelude.Singletons",%$!)
(PackageName "singletons-base",ModuleName "Prelude.Singletons",Seq)
(PackageName "singletons-base",ModuleName "Prelude.Singletons",SeqSym0)
(PackageName "singletons-base",ModuleName "Prelude.Singletons",SeqSym1)
(PackageName "singletons-base",ModuleName "Prelude.Singletons",SeqSym2)
(PackageName "singletons-base",ModuleName "Prelude.Singletons",sSeq)
(PackageName "smallcheck",ModuleName "Test.SmallCheck",==>)
(PackageName "spiros",ModuleName "Prelude.Spiros.Reexports",$)
(PackageName "spiros",ModuleName "Prelude.Spiros.Reexports",$!)
(PackageName "sprinkles",ModuleName "Web.Sprinkles.Prelude",$)
(PackageName "sprinkles",ModuleName "Web.Sprinkles.Prelude",$!)
(PackageName "stack",ModuleName "Stack.Prelude",$)
(PackageName "stack",ModuleName "Stack.Prelude",$!)
(PackageName "stack",ModuleName "Stack.Prelude",$!!)
(PackageName "stack",ModuleName "Stack.Prelude",deepseq)
(PackageName "stack",ModuleName "Stack.Prelude",seq)
(PackageName "stackctl",ModuleName "Stackctl.Prelude",$)
(PackageName "stackctl",ModuleName "Stackctl.Prelude",$!)
(PackageName "stackctl",ModuleName "Stackctl.Prelude",$!!)
(PackageName "stackctl",ModuleName "Stackctl.Prelude",seq)
(PackageName "stdio",ModuleName "Std.Data.Parser",<?>)
(PackageName "stdio",ModuleName "Std.Data.Parser.Base",<?>)
(PackageName "stm-conduit",ModuleName "Data.Conduit.Async",$$&)
(PackageName "streamly",ModuleName "Streamly.Internal.Data.Stream.IsStream",|$)
(PackageName "streamly",ModuleName "Streamly.Internal.Data.Stream.IsStream",|$.)
(PackageName "streamly",ModuleName "Streamly.Prelude",|$)
(PackageName "streamly",ModuleName "Streamly.Prelude",|$.)
(PackageName "streams",ModuleName "Data.Stream.Infinite.Functional.Zipper",:~)
(PackageName "stripe-tests",ModuleName "Web.Stripe.Test.Prelude",$)
(PackageName "supermonad",ModuleName "Control.Super.Monad.PreludeWithoutMonad",$)
(PackageName "supermonad",ModuleName "Control.Super.Monad.PreludeWithoutMonad",$!)
(PackageName "swarm",ModuleName "Swarm.Game.World.Typecheck",:->:)
(PackageName "symantic",ModuleName "Language.Symantic.Compiling.Term",app)
(PackageName "symantic",ModuleName "Language.Symantic.Typing.Type",#>)
(PackageName "symantic",ModuleName "Language.Symantic.Typing.Type",:$)
(PackageName "symantic",ModuleName "Language.Symantic.Typing.Type",~>)
(PackageName "symantic-base",ModuleName "Symantic.Syntaxes.Classes",$)
(PackageName "symantic-cli",ModuleName "Symantic.CLI.API",help)
(PackageName "synthesizer-llvm",ModuleName "Synthesizer.LLVM.Causal.Functional",$&)
(PackageName "synthesizer-llvm",ModuleName "Synthesizer.LLVM.Causal.FunctionalPlug",$&)
(PackageName "synthesizer-llvm",ModuleName "Synthesizer.LLVM.Server.Common",$+)
(PackageName "synthesizer-llvm",ModuleName "Synthesizer.LLVM.Server.Common",$++)
(PackageName "tasty-quickcheck",ModuleName "Test.Tasty.QuickCheck",==>)
(PackageName "tasty-smallcheck",ModuleName "Test.Tasty.SmallCheck",==>)
(PackageName "termonad",ModuleName "Termonad.Prelude",$)
(PackageName "termonad",ModuleName "Termonad.Prelude",$!)
(PackageName "termonad",ModuleName "Termonad.Prelude",seq)
(PackageName "tlex-core",ModuleName "Language.Lexer.Tlex.Prelude",$!)
(PackageName "tlex-core",ModuleName "Language.Lexer.Tlex.Prelude",seq)
(PackageName "tonalude",ModuleName "Tonalude",$)
(PackageName "tonalude",ModuleName "Tonalude",$!)
(PackageName "tonalude",ModuleName "Tonalude",$!!)
(PackageName "tonalude",ModuleName "Tonalude",seq)
(PackageName "traction",ModuleName "Traction.Prelude",$)
(PackageName "type-combinators",ModuleName "Type.Class.Witness",//)
(PackageName "type-combinators",ModuleName "Type.Class.Witness",//?)
(PackageName "type-combinators",ModuleName "Type.Class.Witness",//?+)
(PackageName "type-spec",ModuleName "Test.TypeSpec.Internal.Apply",~>)
(PackageName "typelevel",ModuleName "Type.Operators",$$)
(PackageName "uhc-util",ModuleName "UHC.Util.Utils",$?)
(PackageName "uni-graphs",ModuleName "Graphs.GraphConfigure",$$)
(PackageName "uni-graphs",ModuleName "Graphs.GraphConfigure",$$$)
(PackageName "uni-graphs",ModuleName "Graphs.GraphConfigure",$$$?)
(PackageName "uni-util",ModuleName "Util.Computation",$$)
(PackageName "uni-util",ModuleName "Util.DeepSeq",$!!)
(PackageName "uni-util",ModuleName "Util.DeepSeq",deepSeq)
(PackageName "universum",ModuleName "Universum.Base",$!)
(PackageName "universum",ModuleName "Universum.Base",seq)
(PackageName "universum",ModuleName "Universum.DeepSeq",$!!)
(PackageName "universum",ModuleName "Universum.DeepSeq",deepseq)
(PackageName "universum",ModuleName "Universum.Function",$)
(PackageName "universum",ModuleName "Universum.Monad.Maybe",?:)
(PackageName "util",ModuleName "Util",₪)
(PackageName "uulib",ModuleName "UU.Pretty.Basic",>>$<)
(PackageName "uulib",ModuleName "UU.Pretty.Basic",>>$<<)
(PackageName "uusi",ModuleName "Distribution.Uusi.Utils",<|)
(PackageName "verifiable-expressions",ModuleName "Language.While.Syntax.Sugar",\\)
(PackageName "verset",ModuleName "Verset",$)
(PackageName "verset",ModuleName "Verset",$!)
(PackageName "verset",ModuleName "Verset",seq)
(PackageName "vt-utils",ModuleName "VtUtils.Prelude",$)
(PackageName "vt-utils",ModuleName "VtUtils.Prelude",$!)
(PackageName "web3-solidity",ModuleName "Data.Solidity.Event.Internal",:<)
(PackageName "what4",ModuleName "Test.Verification",==>)
(PackageName "xmonad-contrib",ModuleName "XMonad.Config.Prime",$)
(PackageName "xmonad-contrib",ModuleName "XMonad.Config.Prime",$!)
(PackageName "xmonad-contrib",ModuleName "XMonad.Config.Prime",seq)
(PackageName "xmonad-contrib",ModuleName "XMonad.Hooks.ManageHelpers",-->>)
(PackageName "xmonad-contrib",ModuleName "XMonad.Hooks.ManageHelpers",-?>)
(PackageName "xmonad-contrib",ModuleName "XMonad.Hooks.ManageHelpers",-?>>)
(PackageName "xmonad-contrib",ModuleName "XMonad.Layout.MultiToggle",??)
(PackageName "yesod-paginator",ModuleName "Yesod.Paginator.Prelude",$)
(PackageName "yesod-paginator",ModuleName "Yesod.Paginator.Prelude",$!)
(PackageName "yesod-paginator",ModuleName "Yesod.Paginator.Prelude",seq)
(PackageName "yi",ModuleName "Yi.Keymap.Keys",?*>>)
(PackageName "yi",ModuleName "Yi.Keymap.Keys",?*>>!)
(PackageName "yi",ModuleName "Yi.Keymap.Keys",?>>)
(PackageName "yi",ModuleName "Yi.Keymap.Keys",?>>!)
(PackageName "yi-core",ModuleName "Yi.Keymap.Keys",?*>>)
(PackageName "yi-core",ModuleName "Yi.Keymap.Keys",?*>>!)
(PackageName "yi-core",ModuleName "Yi.Keymap.Keys",?>>)
(PackageName "yi-core",ModuleName "Yi.Keymap.Keys",?>>!)
(PackageName "zephyr-copilot",ModuleName "Copilot.Zephyr",$)
(PackageName "zephyr-copilot",ModuleName "Copilot.Zephyr",$!)
(PackageName "zephyr-copilot",ModuleName "Copilot.Zephyr",seq)

@pbrisbin

This comment was marked as resolved.

Sign in to view
@pbrisbin
Add trailing-section-operators
1c08b97 
Fourmolu has a behavior (inherited from Ormolu) where so-called
"section" operators (those that are `infixr 0`, such as `$`) are left
trailing, with the continuation of expressions indented below, rather
than placed on the next line as most operators are.

It means code comes out like this:

    foo $
      bar $
        baz $
          bat $
            quix

Instead of this:

    foo
      $ bar
      $ baz
      $ bat
      $ quix

This behavior is not desired by some users for aesthetic reasons, and
can be even more confusing since it's unreliable: it requires fourmolu
can determine the fixity of `$` correctly, which depends on dependencies
in the cabal file and imports or re-export knowledge. All of which can
make the behavior change from place to place confusing users and can
generating differences between projects for seemingly know reason.

This new option allows disabling that behavior.

Closes fourmolu#405.
@pbrisbin
Add changelog section for trailing-section-operators
30d3c8c
@pbrisbin
Add config section for trailing operators
f54d8b5
@pbrisbin pbrisbin changed the title Add hanging-dollar option Add trailing-section-operators Dec 6, 2024
@pbrisbin pbrisbin marked this pull request as ready for review December 6, 2024 14:08
@pbrisbin
Copy link
Contributor Author

pbrisbin commented Dec 6, 2024

@brandonchinn178 ready for review!

@pbrisbin
Copy link
Contributor Author

pbrisbin commented Dec 6, 2024

OK, you're going to have to tell me how one escapes a $ in the website content.

@brandonchinn178
Copy link
Collaborator

brandonchinn178 commented Dec 6, 2024

I believe it's $$ - https://jaspervdj.be/hakyll/tutorials/04-compilers.html#templates

@pbrisbin
Copy link
Contributor Author

pbrisbin commented Dec 6, 2024

OK, I give up. I'm going to need some help on the website template.

@brandonchinn178
Copy link
Collaborator

brandonchinn178 commented Dec 7, 2024 

foo :: IO ()
foo =
  $ bar
  $ baz
  $ bat
  $ quiz x

The first dollar is invalid haskell :)

So you should keep what you have, with all dollars replaced with $$, but you need to fix your example. You can run (cd web/site && cabal run -- fourmolu-web build) locally to test it

@pbrisbin
Copy link
Contributor Author

pbrisbin commented Dec 13, 2024 •
edited
Loading

In case you missed it, this is ready for review now. Thanks!

@brandonchinn178 brandonchinn178 self-requested a review December 13, 2024 19:46
brandonchinn178
brandonchinn178 approved these changes Dec 14, 2024
View reviewed changes
Copy link
Collaborator

@brandonchinn178 brandonchinn178 left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Looks great! One small test change, then good to merge!

@brandonchinn178 brandonchinn178 added this to the Fourmolu 0.17.0.0 milestone Dec 14, 2024
@pbrisbin
Add long-line example to trailing-section-operator tests
b14f4c5 
These don't actually get reformatted at all, since there's no
column-limit configuration active in the test.
@brandonchinn178 brandonchinn178 merged commit c9949b1 into fourmolu:main Dec 20, 2024
18 of 19 checks passed
@brandonchinn178
Copy link
Collaborator

brandonchinn178 commented Dec 20, 2024

Thank you!

@BrewTestBot BrewTestBot mentioned this pull request Jan 15, 2025
Merged
netbsd-srcmastr pushed a commit to NetBSD/pkgsrc that referenced this pull request Jan 31, 2025
@depressed-pho
devel/fourmolu: update to fourmolu-0.17.0.0
642ab56 
## Fourmolu 0.17.0.0

* Add new `import-grouping` option to group imports with grouping rules specified in configuration ([#403](fourmolu/fourmolu#403))

* Add new `sort-constraints` option to sort constraints alphabetically ([#433](fourmolu/fourmolu#433))

* Add new `sort-derived-classes` option to sort classes in deriving clauses ([#434](fourmolu/fourmolu#434))

* Add new `sort-derived-clauses` option to sort classes deriving clauses ([#434](fourmolu/fourmolu#434))

* Add new `trailing-section-operators` option to disable trailing "section" operators (those that are `infixr 0`, such as `$`) ([#444](fourmolu/fourmolu#444))

* Fix issue where `single-constraint-parens: never` would drop parentheses around implicit parameters ([#446](fourmolu/fourmolu#446))

* Fix indentation for parenthesized expressions that start off the indentation column ([#428](fourmolu/fourmolu#428))

* Allow multiline comments in indented contexts ([#65](fourmolu/fourmolu#65))


## Fourmolu 0.16.2.0

### Upstream changes:

#### Ormolu 0.7.7.0

* Use single-line layout for parens around single-line content. [Issue
  1120](tweag/ormolu#1120).

* Allow function arguments to be on the same line even if the full type
  (with constraints and foralls) are on multiple lines. [PR
  1125](tweag/ormolu#1125).

## Fourmolu 0.16.1.0

### Upstream changes:

#### Ormolu 0.7.6.0

* Fix Haddock comments on infix constructors
  [Issue 758](tweag/ormolu#758).

* Don't require a trailing newline in `.ormolu` files. [Issue
  1122](tweag/ormolu#1122).

* Remove unnecessary indentation from list comprehensions. [Issue
  966](tweag/ormolu#966).

## Fourmolu 0.16.0.0

* Allow specifying path to configuration file with `--config` ([#396](fourmolu/fourmolu#396))

### Upstream changes:

#### Ormolu 0.7.5.0

* Switched to `ghc-lib-parser-9.10`, with the following new syntactic features/behaviors:
  * GHC proposal [#575](https://github.com/ghc-proposals/ghc-proposals/blob/10290a668608d608c3f6c6010be265cf7a02e1fc/proposals/0575-deprecated-instances.rst): deprecated instances.
  * GHC proposal [#281](https://github.com/ghc-proposals/ghc-proposals/blob/10290a668608d608c3f6c6010be265cf7a02e1fc/proposals/0281-visible-forall.rst): visible forall in types of terms.
    Enabled by `RequiredTypeArguments` (enabled by default).
  * `LinearTypes`: `let` and `where` bindings can now be linear, in particular have multiplicity annotations.
  * Using `forall` as an identifier is now a parse error.
  * GHC proposal [#65](https://github.com/ghc-proposals/ghc-proposals/blob/10290a668608d608c3f6c6010be265cf7a02e1fc/proposals/0065-type-infix.rst): namespacing fixity declarations for type names and WARNING/DEPRECATED pragmas.
  * `TypeAbstractions` now supports `@`-binders in lambdas and function equations.
  * Support for the `GHC2024` language.

* Updated to `Cabal-syntax-3.12`.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

@brandonchinn178 brandonchinn178 brandonchinn178 approved these changes

Assignees

No one assigned

Labels

None yet

Projects

None yet

Milestone

Fourmolu 0.17.0.0

Development

Successfully merging this pull request may close these issues.

Trailing $ vs leading operators seems inconsistent

2 participants

@pbrisbin @brandonchinn178