optparse-applicative-0.18.1.0: Utilities and combinators for parsing command line options

Safe Haskell | Safe-Inferred
Language | Haskell98

Options.Applicative.Help.Pretty

Synopsis

- class Pretty a where
  - pretty :: a -> Doc ann
  - prettyList :: [a] -> Doc ann
- (<>) :: Semigroup a => a -> a -> a
- fill :: Int -> Doc ann -> Doc ann
- parens :: Doc ann -> Doc ann
- list :: [Doc ann] -> Doc ann
- data SimpleDocStream ann
  - = SFail
  - | SEmpty
  - | SChar !Char (SimpleDocStream ann)
  - | SText !Int !Text (SimpleDocStream ann)
  - | SLine !Int (SimpleDocStream ann)
  - | SAnnPush ann (SimpleDocStream ann)
  - | SAnnPop (SimpleDocStream ann)
- group :: Doc ann -> Doc ann
- (<+>) :: Doc ann -> Doc ann -> Doc ann
- data FusionDepth
  - = Shallow
  - | Deep
- annotate :: ann -> Doc ann -> Doc ann
- semi :: Doc ann
- comma :: Doc ann
- colon :: Doc ann
- space :: Doc ann
- equals :: Doc ann
- lparen :: Doc ann
- rparen :: Doc ann
- lbrace :: Doc ann
- rbrace :: Doc ann
- brackets :: Doc ann -> Doc ann
- braces :: Doc ann -> Doc ann
- hcat :: [Doc ann] -> Doc ann
- hsep :: [Doc ann] -> Doc ann
- vcat :: [Doc ann] -> Doc ann
- nest :: Int -> Doc ann -> Doc ann
- hang :: Int -> Doc ann -> Doc ann
- punctuate :: Doc ann -> [Doc ann] -> [Doc ann]
- sep :: [Doc ann] -> Doc ann
- cat :: [Doc ann] -> Doc ann
- indent :: Int -> Doc ann -> Doc ann
- newtype LayoutOptions = LayoutOptions {
  - layoutPageWidth :: PageWidth
  }
- data PageWidth
  - = AvailablePerLine !Int !Double
  - | Unbounded
- viaShow :: Show a => a -> Doc ann
- unsafeViaShow :: Show a => a -> Doc ann
- emptyDoc :: Doc ann
- line :: Doc ann
- line' :: Doc ann
- softline :: Doc ann
- softline' :: Doc ann
- hardline :: Doc ann
- flatAlt :: Doc ann -> Doc ann -> Doc ann
- align :: Doc ann -> Doc ann
- encloseSep :: Doc ann -> Doc ann -> Doc ann -> [Doc ann] -> Doc ann
- tupled :: [Doc ann] -> Doc ann
- concatWith :: Foldable t => (Doc ann -> Doc ann -> Doc ann) -> t (Doc ann) -> Doc ann
- vsep :: [Doc ann] -> Doc ann
- fillSep :: [Doc ann] -> Doc ann
- fillCat :: [Doc ann] -> Doc ann
- column :: (Int -> Doc ann) -> Doc ann
- nesting :: (Int -> Doc ann) -> Doc ann
- width :: Doc ann -> (Int -> Doc ann) -> Doc ann
- pageWidth :: (PageWidth -> Doc ann) -> Doc ann
- fillBreak :: Int -> Doc ann -> Doc ann
- plural :: (Num amount, Eq amount) => doc -> doc -> amount -> doc
- enclose :: Doc ann -> Doc ann -> Doc ann -> Doc ann
- surround :: Doc ann -> Doc ann -> Doc ann -> Doc ann
- unAnnotate :: Doc ann -> Doc xxx
- reAnnotate :: (ann -> ann') -> Doc ann -> Doc ann'
- alterAnnotations :: (ann -> [ann']) -> Doc ann -> Doc ann'
- unAnnotateS :: SimpleDocStream ann -> SimpleDocStream xxx
- reAnnotateS :: (ann -> ann') -> SimpleDocStream ann -> SimpleDocStream ann'
- alterAnnotationsS :: (ann -> Maybe ann') -> SimpleDocStream ann -> SimpleDocStream ann'
- fuse :: FusionDepth -> Doc ann -> Doc ann
- removeTrailingWhitespace :: SimpleDocStream ann -> SimpleDocStream ann
- defaultLayoutOptions :: LayoutOptions
- layoutPretty :: LayoutOptions -> Doc ann -> SimpleDocStream ann
- layoutSmart :: LayoutOptions -> Doc ann -> SimpleDocStream ann
- layoutCompact :: Doc ann1 -> SimpleDocStream ann2
- squotes :: Doc ann -> Doc ann
- dquotes :: Doc ann -> Doc ann
- angles :: Doc ann -> Doc ann
- squote :: Doc ann
- dquote :: Doc ann
- langle :: Doc ann
- rangle :: Doc ann
- lbracket :: Doc ann
- rbracket :: Doc ann
- dot :: Doc ann
- slash :: Doc ann
- backslash :: Doc ann
- pipe :: Doc ann
- module Prettyprinter.Render.Terminal
- type Doc = Doc AnsiStyle
- type SimpleDoc = SimpleDocStream AnsiStyle
- (.$.) :: Doc -> Doc -> Doc
- (</>) :: Doc -> Doc -> Doc
- groupOrNestLine :: Doc -> Doc
- altSep :: Doc -> Doc -> Doc
- hangAtIfOver :: Int -> Int -> Doc -> Doc
- prettyString :: Double -> Int -> Doc -> String

# Documentation

class Pretty a where Source #

Overloaded conversion to `Doc`.

Laws:

1. output should be pretty. :-)

Minimal complete definition

pretty

Methods

pretty :: a -> Doc ann Source #

    >>> pretty 1 <+> pretty "hello" <+> pretty 1.234
    1 hello 1.234

default pretty :: Show a => a -> Doc ann Source #

prettyList :: [a] -> Doc ann Source #

``prettyList`` is only used to define the `instance `Pretty` a => `Pretty` [a]`. In normal circumstances only the ``pretty`` function is used.

    >>> prettyList [1, 23, 456]
    [1, 23, 456]

#### Instances

Instances details

Pretty Void

Finding a good example for printing something that does not exist is hard, so here is an example of printing a list full of nothing.

    >>> pretty ([] :: [Void])
    []

Instance details Defined in Prettyprinter.Internal Methods pretty :: Void -> Doc ann Source # prettyList :: [Void] -> Doc ann Source #
Pretty Int16 |
Instance details Defined in Prettyprinter.Internal Methods pretty :: Int16 -> Doc ann Source # prettyList :: [Int16] -> Doc ann Source #
Pretty Int32 |
Instance details Defined in Prettyprinter.Internal Methods pretty :: Int32 -> Doc ann Source # prettyList :: [Int32] -> Doc ann Source #
Pretty Int64 |
Instance details Defined in Prettyprinter.Internal Methods pretty :: Int64 -> Doc ann Source # prettyList :: [Int64] -> Doc ann Source #
Pretty Int8 |
Instance details Defined in Prettyprinter.Internal Methods pretty :: Int8 -> Doc ann Source # prettyList :: [Int8] -> Doc ann Source #
Pretty Word16 |
Instance details Defined in Prettyprinter.Internal Methods pretty :: Word16 -> Doc ann Source # prettyList :: [Word16] -> Doc ann Source #
Pretty Word32 |
Instance details Defined in Prettyprinter.Internal Methods pretty :: Word32 -> Doc ann Source # prettyList :: [Word32] -> Doc ann Source #
Pretty Word64 |
Instance details Defined in Prettyprinter.Internal Methods pretty :: Word64 -> Doc ann Source # prettyList :: [Word64] -> Doc ann Source #
Pretty Word8 |
Instance details Defined in Prettyprinter.Internal Methods pretty :: Word8 -> Doc ann Source # prettyList :: [Word8] -> Doc ann Source #

Pretty Text

Automatically converts all newlines to ``line``.

    >>> pretty ("hello\nworld" :: Text)
    hello
    world

Note that ``line`` can be undone by ``group``:

    >>> group (pretty ("hello\nworld" :: Text))
    hello world

Manually use ``hardline`` if you definitely want newlines.

Instance details Defined in Prettyprinter.Internal Methods pretty :: Text -> Doc ann Source # prettyList :: [Text] -> Doc ann Source #
Pretty Text | (lazy `Text` instance, identical to the strict version)
Instance details Defined in Prettyprinter.Internal Methods pretty :: Text -> Doc ann Source # prettyList :: [Text] -> Doc ann Source #

Pretty Integer

    >>> pretty (2^123 :: Integer)
    10633823966279326983230456482242756608

Instance details Defined in Prettyprinter.Internal Methods pretty :: Integer -> Doc ann Source # prettyList :: [Integer] -> Doc ann Source #
Pretty Natural |
Instance details Defined in Prettyprinter.Internal Methods pretty :: Natural -> Doc ann Source # prettyList :: [Natural] -> Doc ann Source #

Pretty ()

    >>> pretty ()
    ()

The argument is not used:

    >>> pretty (error "Strict?" :: ())
    ()

Instance details Defined in Prettyprinter.Internal Methods pretty :: () -> Doc ann Source # prettyList :: [()] -> Doc ann Source #

Pretty Bool

    >>> pretty True
    True

Instance details Defined in Prettyprinter.Internal Methods pretty :: Bool -> Doc ann Source # prettyList :: [Bool] -> Doc ann Source #

Pretty Char

Instead of `(`pretty` 'n')`, consider using ``line`` as a more readable alternative.

    >>> pretty 'f' <> pretty 'o' <> pretty 'o'
    foo
    >>> pretty ("string" :: String)
    string

Instance details Defined in Prettyprinter.Internal Methods pretty :: Char -> Doc ann Source # prettyList :: [Char] -> Doc ann Source #

Pretty Double

    >>> pretty (exp 1 :: Double)
    2.71828182845904...

Instance details Defined in Prettyprinter.Internal Methods pretty :: Double -> Doc ann Source # prettyList :: [Double] -> Doc ann Source #

Pretty Float

    >>> pretty (pi :: Float)
    3.1415927

Instance details Defined in Prettyprinter.Internal Methods pretty :: Float -> Doc ann Source # prettyList :: [Float] -> Doc ann Source #

Pretty Int

    >>> pretty (123 :: Int)
    123

Instance details Defined in Prettyprinter.Internal Methods pretty :: Int -> Doc ann Source # prettyList :: [Int] -> Doc ann Source #
Pretty Word |
Instance details Defined in Prettyprinter.Internal Methods pretty :: Word -> Doc ann Source # prettyList :: [Word] -> Doc ann Source #
Pretty a => Pretty (NonEmpty a) |
Instance details Defined in Prettyprinter.Internal Methods pretty :: NonEmpty a -> Doc ann Source # prettyList :: [NonEmpty a] -> Doc ann Source #

Pretty a => Pretty (Identity a)

    >>> pretty (Identity 1)
    1

Instance details Defined in Prettyprinter.Internal Methods pretty :: Identity a -> Doc ann Source # prettyList :: [Identity a] -> Doc ann Source #

Pretty a => Pretty (Maybe a)

Ignore `Nothing`s, print `Just` contents.

    >>> pretty (Just True)
    True
    >>> braces (pretty (Nothing :: Maybe Bool))
    {}

    >>> pretty [Just 1, Nothing, Just 3, Nothing]
    [1, 3]

Instance details Defined in Prettyprinter.Internal Methods pretty :: Maybe a -> Doc ann Source # prettyList :: [Maybe a] -> Doc ann Source #

Pretty a => Pretty [a]

    >>> pretty [1,2,3]
    [1, 2, 3]

Instance details Defined in Prettyprinter.Internal Methods pretty :: [a] -> Doc ann Source # prettyList :: [[a]] -> Doc ann Source #

(Pretty a1, Pretty a2) => Pretty (a1, a2)

    >>> pretty (123, "hello")
    (123, hello)

Instance details Defined in Prettyprinter.Internal Methods pretty :: (a1, a2) -> Doc ann Source # prettyList :: [(a1, a2)] -> Doc ann Source #
Pretty a => Pretty (Const a b) |
Instance details Defined in Prettyprinter.Internal Methods pretty :: Const a b -> Doc ann Source # prettyList :: [Const a b] -> Doc ann Source #

(Pretty a1, Pretty a2, Pretty a3) => Pretty (a1, a2, a3)

    >>> pretty (123, "hello", False)
    (123, hello, False)

Instance details Defined in Prettyprinter.Internal Methods pretty :: (a1, a2, a3) -> Doc ann Source # prettyList :: [(a1, a2, a3)] -> Doc ann Source #

(<>) :: Semigroup a => a -> a -> a infixr 6 Source #

An associative operation.

#### Examples

Expand

    >>> [1,2,3] <> [4,5,6]
    [1,2,3,4,5,6]

    >>> Just [1, 2, 3] <> Just [4, 5, 6]
    Just [1,2,3,4,5,6]

    >>> putStr "Hello, " <> putStrLn "World!"
    Hello, World!

fill Source #

Arguments

:: Int | Append spaces until the document is at least this wide
-> Doc ann |
-> Doc ann |

`(`fill` i x)` lays out the document `x`. It then appends `space`s until the width is equal to `i`. If the width of `x` is already larger, nothing is appended.

This function is quite useful in practice to output a list of bindings:

    >>> let types = [("empty","Doc"), ("nest","Int -> Doc -> Doc"), ("fillSep","[Doc] -> Doc")]
    >>> let ptype (name, tp) = fill 5 (pretty name) <+> "::" <+> pretty tp
    >>> "let" <+> align (vcat (map ptype types))
    let empty :: Doc
        nest  :: Int -> Doc -> Doc
        fillSep :: [Doc] -> Doc

parens :: Doc ann -> Doc ann Source #

    >>> parens "·"
    (·)

list :: [Doc ann] -> Doc ann Source #

Haskell-inspired variant of `encloseSep` with braces and comma as separator.

    >>> let doc = list (map pretty [1,20,300,4000])

    >>> putDocW 80 doc
    [1, 20, 300, 4000]

    >>> putDocW 10 doc
    [ 1
    , 20
    , 300
    , 4000 ]

data SimpleDocStream ann Source #

The data type `SimpleDocStream` represents laid out documents and is used by the display functions.

A simplified view is that ``Doc` = [`SimpleDocStream`]`, and the layout functions pick one of the `SimpleDocStream`s based on which one fits the layout constraints best. This means that `SimpleDocStream` has all complexity contained in `Doc` resolved, making it very easy to convert it to other formats, such as plain text or terminal output.

To write your own ``Doc`` to X converter, it is therefore sufficient to convert from ``SimpleDocStream``. The »Render« submodules provide some built-in converters to do so, and helpers to create own ones.

Constructors

SFail |
SEmpty |
SChar !Char (SimpleDocStream ann) |
SText !Int !Text (SimpleDocStream ann) | `length` is O(n), so we cache it in the `Int` field.
SLine !Int (SimpleDocStream ann) | `Int` = indentation level for the (next) line
SAnnPush ann (SimpleDocStream ann) | Add an annotation to the remaining document.
SAnnPop (SimpleDocStream ann) | Remove a previously pushed annotation.

#### Instances

Instances details

Functor SimpleDocStream | Alter the document’s annotations. This instance makes `SimpleDocStream` more flexible (because it can be used in `Functor`-polymorphic values), but ``fmap`` is much less readable compared to using ``reAnnotateST`` in code that only works for ``SimpleDocStream`` anyway. Consider using the latter when the type does not matter.
Instance details Defined in Prettyprinter.Internal Methods fmap :: (a -> b) -> SimpleDocStream a -> SimpleDocStream b Source # (<$) :: a -> SimpleDocStream b -> SimpleDocStream a Source #
Foldable SimpleDocStream | Collect all annotations from a document.

Instance details

Defined in Prettyprinter.Internal

Methods

fold :: Monoid m => SimpleDocStream m -> m Source #

foldMap :: Monoid m => (a -> m) -> SimpleDocStream a -> m Source #

foldMap' :: Monoid m => (a -> m) -> SimpleDocStream a -> m Source #

foldr :: (a -> b -> b) -> b -> SimpleDocStream a -> b Source #

foldr' :: (a -> b -> b) -> b -> SimpleDocStream a -> b Source #

foldl :: (b -> a -> b) -> b -> SimpleDocStream a -> b Source #

foldl' :: (b -> a -> b) -> b -> SimpleDocStream a -> b Source #

foldr1 :: (a -> a -> a) -> SimpleDocStream a -> a Source #

foldl1 :: (a -> a -> a) -> SimpleDocStream a -> a Source #

toList :: SimpleDocStream a -> [a] Source #

null :: SimpleDocStream a -> Bool Source #

length :: SimpleDocStream a -> Int Source #

elem :: Eq a => a -> SimpleDocStream a -> Bool Source #

maximum :: Ord a => SimpleDocStream a -> a Source #

minimum :: Ord a => SimpleDocStream a -> a Source #

sum :: Num a => SimpleDocStream a -> a Source #

product :: Num a => SimpleDocStream a -> a Source #

Traversable SimpleDocStream | Transform a document based on its annotations, possibly leveraging `Applicative` effects.

Instance details

Defined in Prettyprinter.Internal

Methods

traverse :: Applicative f => (a -> f b) -> SimpleDocStream a -> f (SimpleDocStream b) Source #

sequenceA :: Applicative f => SimpleDocStream (f a) -> f (SimpleDocStream a) Source #

mapM :: Monad m => (a -> m b) -> SimpleDocStream a -> m (SimpleDocStream b) Source #

sequence :: Monad m => SimpleDocStream (m a) -> m (SimpleDocStream a) Source #

Generic (SimpleDocStream ann) |

Instance details

Defined in Prettyprinter.Internal

Associated Types

type Rep (SimpleDocStream ann) |

Instance details

Defined in Prettyprinter.Internal

type Rep (SimpleDocStream ann) = D1 ('MetaData "SimpleDocStream" "Prettyprinter.Internal" "prettyprinter-1.7.1-K35zp2YrYoHG4xnuHsN7jV" 'False) ((C1 ('MetaCons "SFail" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "SEmpty" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SChar" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedUnpack) (Rec0 Char) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (SimpleDocStream ann))))) :+: ((C1 ('MetaCons "SText" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedUnpack) (Rec0 Int) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Text) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (SimpleDocStream ann)))) :+: C1 ('MetaCons "SLine" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedUnpack) (Rec0 Int) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (SimpleDocStream ann)))) :+: (C1 ('MetaCons "SAnnPush" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ann) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (SimpleDocStream ann))) :+: C1 ('MetaCons "SAnnPop" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (SimpleDocStream ann))))))

Methods

from :: SimpleDocStream ann -> Rep (SimpleDocStream ann) x Source #

to :: Rep (SimpleDocStream ann) x -> SimpleDocStream ann Source #

Show ann => Show (SimpleDocStream ann) |
Instance details Defined in Prettyprinter.Internal Methods showsPrec :: Int -> SimpleDocStream ann -> ShowS Source # show :: SimpleDocStream ann -> String Source # showList :: [SimpleDocStream ann] -> ShowS Source #
Eq ann => Eq (SimpleDocStream ann) |
Instance details Defined in Prettyprinter.Internal Methods (==) :: SimpleDocStream ann -> SimpleDocStream ann -> Bool Source # (/=) :: SimpleDocStream ann -> SimpleDocStream ann -> Bool Source #
Ord ann => Ord (SimpleDocStream ann) |

Instance details

Defined in Prettyprinter.Internal

Methods

compare :: SimpleDocStream ann -> SimpleDocStream ann -> Ordering Source #

(<) :: SimpleDocStream ann -> SimpleDocStream ann -> Bool Source #

(<=) :: SimpleDocStream ann -> SimpleDocStream ann -> Bool Source #

(>) :: SimpleDocStream ann -> SimpleDocStream ann -> Bool Source #

(>=) :: SimpleDocStream ann -> SimpleDocStream ann -> Bool Source #

max :: SimpleDocStream ann -> SimpleDocStream ann -> SimpleDocStream ann Source #

min :: SimpleDocStream ann -> SimpleDocStream ann -> SimpleDocStream ann Source #

type Rep (SimpleDocStream ann) |

Instance details

Defined in Prettyprinter.Internal

type Rep (SimpleDocStream ann) = D1 ('MetaData "SimpleDocStream" "Prettyprinter.Internal" "prettyprinter-1.7.1-K35zp2YrYoHG4xnuHsN7jV" 'False) ((C1 ('MetaCons "SFail" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "SEmpty" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SChar" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedUnpack) (Rec0 Char) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (SimpleDocStream ann))))) :+: ((C1 ('MetaCons "SText" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedUnpack) (Rec0 Int) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Text) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (SimpleDocStream ann)))) :+: C1 ('MetaCons "SLine" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedUnpack) (Rec0 Int) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (SimpleDocStream ann)))) :+: (C1 ('MetaCons "SAnnPush" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ann) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (SimpleDocStream ann))) :+: C1 ('MetaCons "SAnnPop" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (SimpleDocStream ann))))))

group :: Doc ann -> Doc ann Source #

`(`group` x)` tries laying out `x` into a single line by removing the contained line breaks; if this does not fit the page, or when a `hardline` within `x` prevents it from being flattened, `x` is laid out without any changes.

The `group` function is key to layouts that adapt to available space nicely.

See `vcat`, `line`, or `flatAlt` for examples that are related, or make good use of it.

(<+>) :: Doc ann -> Doc ann -> Doc ann infixr 6 Source #

`(x `<+>` y)` concatenates document `x` and `y` with a ``space`` in between.

    >>> "hello" <+> "world"
    hello world

    x <+> y = x <> space <> y

data FusionDepth Source #

Fusion depth parameter, used by `fuse`.

Constructors

Shallow | Do not dive deep into nested documents, fusing mostly concatenations of text nodes together.

Deep

Recurse into all parts of the `Doc`, including different layout alternatives, and location-sensitive values such as created by `nesting` which cannot be fused before, but only during, the layout process. As a result, the performance cost of using deep fusion is often hard to predict, and depends on the interplay between page layout and document to prettyprint.

This value should only be used if profiling shows it is significantly faster than using `Shallow`.

#### Instances

Instances details

Show FusionDepth |
Instance details Defined in Prettyprinter.Internal Methods showsPrec :: Int -> FusionDepth -> ShowS Source # show :: FusionDepth -> String Source # showList :: [FusionDepth] -> ShowS Source #
Eq FusionDepth |
Instance details Defined in Prettyprinter.Internal Methods (==) :: FusionDepth -> FusionDepth -> Bool Source # (/=) :: FusionDepth -> FusionDepth -> Bool Source #
Ord FusionDepth |

Instance details

Defined in Prettyprinter.Internal

Methods

compare :: FusionDepth -> FusionDepth -> Ordering Source #

(<) :: FusionDepth -> FusionDepth -> Bool Source #

(<=) :: FusionDepth -> FusionDepth -> Bool Source #

(>) :: FusionDepth -> FusionDepth -> Bool Source #

(>=) :: FusionDepth -> FusionDepth -> Bool Source #

max :: FusionDepth -> FusionDepth -> FusionDepth Source #

min :: FusionDepth -> FusionDepth -> FusionDepth Source #

annotate :: ann -> Doc ann -> Doc ann Source #

Add an annotation to a ``Doc``. This annotation can then be used by the renderer to e.g. add color to certain parts of the output. For a full tutorial example on how to use it, see the Prettyprinter.Render.Tutorials.StackMachineTutorial or Prettyprinter.Render.Tutorials.TreeRenderingTutorial modules.

This function is only relevant for custom formats with their own annotations, and not relevant for basic prettyprinting. The predefined renderers, e.g. Prettyprinter.Render.Text, should be enough for the most common needs.

semi :: Doc ann Source #

    >>> semi
    ;

comma :: Doc ann Source #

    >>> comma
    ,

colon :: Doc ann Source #

    >>> colon
    :

space :: Doc ann Source #

    >>> "a" <> space <> "b"
    a b

This is mostly used via ``<+>``,

    >>> "a" <+> "b"
    a b

equals :: Doc ann Source #

    >>> equals
    =

lparen :: Doc ann Source #

    >>> lparen
    (

rparen :: Doc ann Source #

    >>> rparen
    )

lbrace :: Doc ann Source #

    >>> lbrace
    {

rbrace :: Doc ann Source #

    >>> rbrace
    }

brackets :: Doc ann -> Doc ann Source #

    >>> brackets "·"
    [·]

braces :: Doc ann -> Doc ann Source #

    >>> braces "·"
    {·}

hcat :: [Doc ann] -> Doc ann Source #

`(`hcat` xs)` concatenates all documents `xs` horizontally with ``<>`` (i.e. without any spacing).

It is provided only for consistency, since it is identical to `mconcat`.

    >>> let docs = Util.words "lorem ipsum dolor"
    >>> hcat docs
    loremipsumdolor

hsep :: [Doc ann] -> Doc ann Source #

`(`hsep` xs)` concatenates all documents `xs` horizontally with ``<+>``, i.e. it puts a space between all entries.

    >>> let docs = Util.words "lorem ipsum dolor sit amet"

    >>> hsep docs
    lorem ipsum dolor sit amet

``hsep`` does not introduce line breaks on its own, even when the page is too narrow:

    >>> putDocW 5 (hsep docs)
    lorem ipsum dolor sit amet

For automatic line breaks, consider using `fillSep` instead.

vcat :: [Doc ann] -> Doc ann Source #

`(`vcat` xs)` vertically concatenates the documents `xs`. If it is `group`ed, the line breaks are removed.

In other words ``vcat`` is like ``vsep``, with newlines removed instead of replaced by `space`s.

    >>> let docs = Util.words "lorem ipsum dolor"
    >>> vcat docs
    lorem
    ipsum
    dolor
    >>> group (vcat docs)
    loremipsumdolor

Since `group`ing a `vcat` is rather common, `cat` is a built-in shortcut for it.

nest Source #

Arguments

:: Int | Change of nesting level
-> Doc ann |
-> Doc ann |

`(`nest` i x)` lays out the document `x` with the current nesting level (indentation of the following lines) increased by `i`. Negative values are allowed, and decrease the nesting level accordingly.

    >>> vsep [nest 4 (vsep ["lorem", "ipsum", "dolor"]), "sit", "amet"]
    lorem
        ipsum
        dolor
    sit
    amet

See also

- `hang` (`nest` relative to current cursor position instead of current nesting level)
- `align` (set nesting level to current cursor position)
- `indent` (increase indentation on the spot, padding with spaces).

hang Source #

Arguments

:: Int | Change of nesting level, relative to the start of the first line
-> Doc ann |
-> Doc ann |

`(`hang` i x)` lays out the document `x` with a nesting level set to the current column plus `i`. Negative values are allowed, and decrease the nesting level accordingly.

    >>> let doc = reflow "Indenting these words with hang"
    >>> putDocW 24 ("prefix" <+> hang 4 doc)
    prefix Indenting these
               words with
               hang

This differs from `nest`, which is based on the current nesting level plus `i`. When you're not sure, try the more efficient `nest` first. In our example, this would yield

    >>> let doc = reflow "Indenting these words with nest"
    >>> putDocW 24 ("prefix" <+> nest 4 doc)
    prefix Indenting these
        words with nest

    hang i doc = align (nest i doc)

punctuate Source #

Arguments

:: Doc ann | Punctuation, e.g. `comma`
-> [Doc ann] |
-> [Doc ann] |

`(`punctuate` p xs)` appends `p` to all but the last document in `xs`.

    >>> let docs = punctuate comma (Util.words "lorem ipsum dolor sit amet")
    >>> putDocW 80 (hsep docs)
    lorem, ipsum, dolor, sit, amet

The separators are put at the end of the entries, which we can see if we position the result vertically:

    >>> putDocW 20 (vsep docs)
    lorem,
    ipsum,
    dolor,
    sit,
    amet

If you want put the commas in front of their elements instead of at the end, you should use `tupled` or, in general, `encloseSep`.

sep :: [Doc ann] -> Doc ann Source #

`(`sep` xs)` tries laying out the documents `xs` separated with `space`s, and if this does not fit the page, separates them with newlines. This is what differentiates it from `vsep`, which always lays out its contents beneath each other.

    >>> let doc = "prefix" <+> sep ["text", "to", "lay", "out"]
    >>> putDocW 80 doc
    prefix text to lay out

With a narrower layout, the entries are separated by newlines:

    >>> putDocW 20 doc
    prefix text
    to
    lay
    out

    sep = group . vsep

cat :: [Doc ann] -> Doc ann Source #

`(`cat` xs)` tries laying out the documents `xs` separated with nothing, and if this does not fit the page, separates them with newlines. This is what differentiates it from `vcat`, which always lays out its contents beneath each other.

    >>> let docs = Util.words "lorem ipsum dolor"
    >>> putDocW 80 ("Docs:" <+> cat docs)
    Docs: loremipsumdolor

When there is enough space, the documents are put above one another:

    >>> putDocW 10 ("Docs:" <+> cat docs)
    Docs: lorem
    ipsum
    dolor

    cat = group . vcat

indent Source #

Arguments

:: Int | Number of spaces to increase indentation by
-> Doc ann |
-> Doc ann |

`(`indent` i x)` indents document `x` by `i` columns, starting from the current cursor position.

    >>> let doc = reflow "The indent function indents these words!"
    >>> putDocW 24 ("prefix" <> indent 4 doc)
    prefix    The indent
              function
              indents these
              words!

    indent i d = hang i ({i spaces} <> d)

newtype LayoutOptions Source #

Options to influence the layout algorithms.

Constructors

LayoutOptions |

Fields

- layoutPageWidth :: PageWidth

#### Instances

Instances details

Show LayoutOptions |
Instance details Defined in Prettyprinter.Internal Methods showsPrec :: Int -> LayoutOptions -> ShowS Source # show :: LayoutOptions -> String Source # showList :: [LayoutOptions] -> ShowS Source #
Eq LayoutOptions |
Instance details Defined in Prettyprinter.Internal Methods (==) :: LayoutOptions -> LayoutOptions -> Bool Source # (/=) :: LayoutOptions -> LayoutOptions -> Bool Source #
Ord LayoutOptions |

Instance details

Defined in Prettyprinter.Internal

Methods

compare :: LayoutOptions -> LayoutOptions -> Ordering Source #

(<) :: LayoutOptions -> LayoutOptions -> Bool Source #

(<=) :: LayoutOptions -> LayoutOptions -> Bool Source #

(>) :: LayoutOptions -> LayoutOptions -> Bool Source #

(>=) :: LayoutOptions -> LayoutOptions -> Bool Source #

max :: LayoutOptions -> LayoutOptions -> LayoutOptions Source #

min :: LayoutOptions -> LayoutOptions -> LayoutOptions Source #

data PageWidth Source #

Maximum number of characters that fit in one line. The layout algorithms will try not to exceed the set limit by inserting line breaks when applicable (e.g. via `softline'`).

Constructors

AvailablePerLine !Int !Double

Layouters should not exceed the specified space per line.

- The `Int` is the number of characters, including whitespace, that fit in a line. A typical value is 80.
- The `Double` is the ribbon with, i.e. the fraction of the total page width that can be printed on. This allows limiting the length of printable text per line. Values must be between 0 and 1, and 0.4 to 1 is typical.

Unbounded | Layouters should not introduce line breaks on their own.

#### Instances

Instances details

Show PageWidth |
Instance details Defined in Prettyprinter.Internal Methods showsPrec :: Int -> PageWidth -> ShowS Source # show :: PageWidth -> String Source # showList :: [PageWidth] -> ShowS Source #
Eq PageWidth |
Instance details Defined in Prettyprinter.Internal Methods (==) :: PageWidth -> PageWidth -> Bool Source # (/=) :: PageWidth -> PageWidth -> Bool Source #
Ord PageWidth |

Instance details

Defined in Prettyprinter.Internal

Methods

compare :: PageWidth -> PageWidth -> Ordering Source #

(<) :: PageWidth -> PageWidth -> Bool Source #

(<=) :: PageWidth -> PageWidth -> Bool Source #

(>) :: PageWidth -> PageWidth -> Bool Source #

(>=) :: PageWidth -> PageWidth -> Bool Source #

max :: PageWidth -> PageWidth -> PageWidth Source #

min :: PageWidth -> PageWidth -> PageWidth Source #

viaShow :: Show a => a -> Doc ann Source #

Convenience function to convert a `Show`able value to a `Doc`. If the `String` does not contain newlines, consider using the more performant `unsafeViaShow`.

unsafeViaShow :: Show a => a -> Doc ann Source #

Convenience function to convert a `Show`able value /that must not contain newlines/ to a `Doc`. If there may be newlines, use `viaShow` instead.

emptyDoc :: Doc ann Source #

The empty document behaves like `(`pretty` "")`, so it has a height of 1. This may lead to surprising behaviour if we expect it to bear no weight inside e.g. `vcat`, where we get an empty line of output from it (`parens` for visibility only):

    >>> vsep ["hello", parens emptyDoc, "world"]
    hello
    ()
    world

Together with `<>`, `emptyDoc` forms the `Monoid` `Doc`.

line :: Doc ann Source #

The ``line`` document advances to the next line and indents to the current nesting level.

    >>> let doc = "lorem ipsum" <> line <> "dolor sit amet"
    >>> doc
    lorem ipsum
    dolor sit amet

``line`` behaves like ``space`` if the line break is undone by `group`:

    >>> group doc
    lorem ipsum dolor sit amet

line' :: Doc ann Source #

``line'`` is like ``line``, but behaves like ``mempty`` if the line break is undone by `group` (instead of ``space``).

    >>> let doc = "lorem ipsum" <> line' <> "dolor sit amet"
    >>> doc
    lorem ipsum
    dolor sit amet
    >>> group doc
    lorem ipsumdolor sit amet

softline :: Doc ann Source #

`softline` behaves like ``space`` if the resulting output fits the page, otherwise like ``line``.

Here, we have enough space to put everything in one line:

    >>> let doc = "lorem ipsum" <> softline <> "dolor sit amet"
    >>> putDocW 80 doc
    lorem ipsum dolor sit amet

If we narrow the page to width 10, the layouter produces a line break:

    >>> putDocW 10 doc
    lorem ipsum
    dolor sit amet

    softline = group line

softline' :: Doc ann Source #

``softline'`` is like ``softline``, but behaves like ``mempty`` if the resulting output does not fit on the page (instead of ``space``). In other words, ``line`` is to ``line'`` how ``softline`` is to ``softline'``.

With enough space, we get direct concatenation:

    >>> let doc = "ThisWord" <> softline' <> "IsWayTooLong"
    >>> putDocW 80 doc
    ThisWordIsWayTooLong

If we narrow the page to width 10, the layouter produces a line break:

    >>> putDocW 10 doc
    ThisWord
    IsWayTooLong

    softline' = group line'

hardline :: Doc ann Source #

A ``hardline`` is always laid out as a line break, even when `group`ed or when there is plenty of space. Note that it might still be simply discarded if it is part of a `flatAlt` inside a `group`.

    >>> let doc = "lorem ipsum" <> hardline <> "dolor sit amet"
    >>> putDocW 1000 doc
    lorem ipsum
    dolor sit amet

    >>> group doc
    lorem ipsum
    dolor sit amet

flatAlt Source #

Arguments

:: Doc ann | Default
-> Doc ann | Preferred when `group`ed
-> Doc ann |

By default, `(`flatAlt` x y)` renders as `x`. However when `group`ed, `y` will be preferred, with `x` as the fallback for the case when `y` doesn't fit.

    >>> let doc = flatAlt "a" "b"
    >>> putDoc doc
    a
    >>> putDoc (group doc)
    b
    >>> putDocW 0 (group doc)
    a

`flatAlt` is particularly useful for defining conditional separators such as

    softline = group (flatAlt hardline " ")

    >>> let hello = "Hello" <> softline <> "world!"
    >>> putDocW 12 hello
    Hello world!
    >>> putDocW 11 hello
    Hello
    world!

### Example: Haskell's do-notation

Expand

We can use this to render Haskell's do-notation nicely:

    >>> let open        = flatAlt "" "{ "
    >>> let close       = flatAlt "" " }"
    >>> let separator   = flatAlt "" "; "
    >>> let prettyDo xs = group ("do" <+> align (encloseSep open close separator xs))
    >>> let statements  = ["name:_ <- getArgs", "let greet = \"Hello, \" <> name", "putStrLn greet"]

This is put into a single line with `{;}` style if it fits:

    >>> putDocW 80 (prettyDo statements)
    do { name:_ <- getArgs; let greet = "Hello, " <> name; putStrLn greet }

When there is not enough space the statements are broken up into lines nicely:

    >>> putDocW 10 (prettyDo statements)
    do name:_ <- getArgs
       let greet = "Hello, " <> name
       putStrLn greet

### Notes

Users should be careful to choose `x` to be less wide than `y`. Otherwise, if `y` turns out not to fit the page, we fall back on an even wider layout:

    >>> let ugly = group (flatAlt "even wider" "too wide")
    >>> putDocW 7 ugly
    even wider

Also note that `group` will flatten `y`:

    >>> putDoc (group (flatAlt "x" ("y" <> line <> "y")))
    y y

This also means that an "unflattenable" `y` which contains a hard linebreak will never be rendered:

    >>> putDoc (group (flatAlt "x" ("y" <> hardline <> "y")))
    x

align :: Doc ann -> Doc ann Source #

`(`align` x)` lays out the document `x` with the nesting level set to the current column. It is used for example to implement `hang`.

As an example, we will put a document right above another one, regardless of the current nesting level. Without `align`ment, the second line is put simply below everything we've had so far:

    >>> "lorem" <+> vsep ["ipsum", "dolor"]
    lorem ipsum
    dolor

If we add an `align` to the mix, the ``vsep``'s contents all start in the same column:

    >>> "lorem" <+> align (vsep ["ipsum", "dolor"])
    lorem ipsum
          dolor

encloseSep Source #

Arguments

:: Doc ann | left delimiter
-> Doc ann | right delimiter
-> Doc ann | separator
-> [Doc ann] | input documents
-> Doc ann |

`(`encloseSep` l r sep xs)` concatenates the documents `xs` separated by `sep`, and encloses the resulting document by `l` and `r`.

The documents are laid out horizontally if that fits the page:

    >>> let doc = "list" <+> align (encloseSep lbracket rbracket comma (map pretty [1,20,300,4000]))
    >>> putDocW 80 doc
    list [1,20,300,4000]

If there is not enough space, then the input is split into lines entry-wise therwise they are laid out vertically, with separators put in the front:

    >>> putDocW 10 doc
    list [1
         ,20
         ,300
         ,4000]

Note that `doc` contains an explicit call to `align` so that the list items are aligned vertically.

For putting separators at the end of entries instead, have a look at `punctuate`.

tupled :: [Doc ann] -> Doc ann Source #

Haskell-inspired variant of `encloseSep` with parentheses and comma as separator.

    >>> let doc = tupled (map pretty [1,20,300,4000])

    >>> putDocW 80 doc
    (1, 20, 300, 4000)

    >>> putDocW 10 doc
    ( 1
    , 20
    , 300
    , 4000 )

concatWith :: Foldable t => (Doc ann -> Doc ann -> Doc ann) -> t (Doc ann) -> Doc ann Source #

Concatenate all documents element-wise with a binary function.

    concatWith _ [] = mempty
    concatWith (**) [x,y,z] = x ** y ** z

Multiple convenience definitions based on `concatWith` are already predefined, for example:

    hsep    = concatWith (<+>)
    fillSep = concatWith (\x y -> x <> softline <> y)

This is also useful to define customized joiners:

    >>> concatWith (surround dot) ["Prettyprinter", "Render", "Text"]
    Prettyprinter.Render.Text

vsep :: [Doc ann] -> Doc ann Source #

`(`vsep` xs)` concatenates all documents `xs` above each other. If a `group` undoes the line breaks inserted by `vsep`, the documents are separated with a `space` instead.

Using `vsep` alone yields

    >>> "prefix" <+> vsep ["text", "to", "lay", "out"]
    prefix text
    to
    lay
    out

`group`ing a `vsep` separates the documents with a `space` if it fits the page (and does nothing otherwise). See the ``sep`` convenience function for this use case.

The `align` function can be used to align the documents under their first element:

    >>> "prefix" <+> align (vsep ["text", "to", "lay", "out"])
    prefix text
           to
           lay
           out

Since `group`ing a `vsep` is rather common, `sep` is a built-in for doing that.

fillSep :: [Doc ann] -> Doc ann Source #

`(`fillSep` xs)` concatenates the documents `xs` horizontally with ``<+>`` as long as it fits the page, then inserts a ``line`` and continues doing that for all documents in `xs`. (``line`` means that if `group`ed, the documents are separated with a `space` instead of newlines. Use `fillCat` if you do not want a `space`.)

Let's print some words to fill the line:

    >>> let docs = take 20 (cycle ["lorem", "ipsum", "dolor", "sit", "amet"])
    >>> putDocW 80 ("Docs:" <+> fillSep docs)
    Docs: lorem ipsum dolor sit amet lorem ipsum dolor sit amet lorem ipsum dolor
    sit amet lorem ipsum dolor sit amet

The same document, printed at a width of only 40, yields

    >>> putDocW 40 ("Docs:" <+> fillSep docs)
    Docs: lorem ipsum dolor sit amet lorem
    ipsum dolor sit amet lorem ipsum dolor
    sit amet lorem ipsum dolor sit amet

fillCat :: [Doc ann] -> Doc ann Source #

`(`fillCat` xs)` concatenates documents `xs` horizontally with ``<>`` as long as it fits the page, then inserts a ``line'`` and continues doing that for all documents in `xs`. This is similar to how an ordinary word processor lays out the text if you just keep typing after you hit the maximum line length.

(``line'`` means that if `group`ed, the documents are separated with nothing instead of newlines. See `fillSep` if you want a `space` instead.)

Observe the difference between `fillSep` and `fillCat`. `fillSep` concatenates the entries `space`d when `group`ed:

    >>> let docs = take 20 (cycle (["lorem", "ipsum", "dolor", "sit", "amet"]))
    >>> putDocW 40 ("Grouped:" <+> group (fillSep docs))
    Grouped: lorem ipsum dolor sit amet
    lorem ipsum dolor sit amet lorem ipsum
    dolor sit amet lorem ipsum dolor sit
    amet

On the other hand, `fillCat` concatenates the entries directly when `group`ed:

    >>> putDocW 40 ("Grouped:" <+> group (fillCat docs))
    Grouped: loremipsumdolorsitametlorem
    ipsumdolorsitametloremipsumdolorsitamet
    loremipsumdolorsitamet

column :: (Int -> Doc ann) -> Doc ann Source #

Layout a document depending on which column it starts at. `align` is implemented in terms of `column`.

    >>> column (\l -> "Columns are" <+> pretty l <> "-based.")
    Columns are 0-based.

    >>> let doc = "prefix" <+> column (\l -> "| <- column" <+> pretty l)
    >>> vsep [indent n doc | n <- [0,4,8]]
    prefix | <- column 7
        prefix | <- column 11
            prefix | <- column 15

nesting :: (Int -> Doc ann) -> Doc ann Source #

Layout a document depending on the current `nest`ing level. `align` is implemented in terms of `nesting`.

    >>> let doc = "prefix" <+> nesting (\l -> brackets ("Nested:" <+> pretty l))
    >>> vsep [indent n doc | n <- [0,4,8]]
    prefix [Nested: 0]
        prefix [Nested: 4]
            prefix [Nested: 8]

width :: Doc ann -> (Int -> Doc ann) -> Doc ann Source #

`(`width` doc f)` lays out the document `doc`, and makes the column width of it available to a function.

    >>> let annotate doc = width (brackets doc) (\w -> " <- width:" <+> pretty w)
    >>> align (vsep (map annotate ["---", "------", indent 3 "---", vsep ["---", indent 4 "---"]]))
    [---] <- width: 5
    [------] <- width: 8
    [   ---] <- width: 8
    [---
        ---] <- width: 8

pageWidth :: (PageWidth -> Doc ann) -> Doc ann Source #

Layout a document depending on the page width, if one has been specified.

    >>> let prettyPageWidth (AvailablePerLine l r) = "Width:" <+> pretty l <> ", ribbon fraction:" <+> pretty r
    >>> let doc = "prefix" <+> pageWidth (brackets . prettyPageWidth)
    >>> putDocW 32 (vsep [indent n doc | n <- [0,4,8]])
    prefix [Width: 32, ribbon fraction: 1.0]
        prefix [Width: 32, ribbon fraction: 1.0]
            prefix [Width: 32, ribbon fraction: 1.0]

fillBreak Source #

Arguments

:: Int | Append spaces until the document is at least this wide
-> Doc ann |
-> Doc ann |

`(`fillBreak` i x)` first lays out the document `x`. It then appends `space`s until the width is equal to `i`. If the width of `x` is already larger than `i`, the nesting level is increased by `i` and a `line` is appended. When we redefine `ptype` in the example given in `fill` to use ``fillBreak``, we get a useful variation of the output:

    >>> let types = [("empty","Doc"), ("nest","Int -> Doc -> Doc"), ("fillSep","[Doc] -> Doc")]
    >>> let ptype (name, tp) = fillBreak 5 (pretty name) <+> "::" <+> pretty tp
    >>> "let" <+> align (vcat (map ptype types))
    let empty :: Doc
        nest  :: Int -> Doc -> Doc
        fillSep
              :: [Doc] -> Doc

plural Source #

Arguments

:: (Num amount, Eq amount) |
=> doc | `1` case
-> doc | other cases
-> amount |
-> doc |

`(`plural` n one many)` is `one` if `n` is `1`, and `many` otherwise. A typical use case is adding a plural "s".

    >>> let things = [True]
    >>> let amount = length things
    >>> pretty things <+> "has" <+> pretty amount <+> plural "entry" "entries" amount
    [True] has 1 entry

enclose Source #

Arguments

:: Doc ann | L
-> Doc ann | R
-> Doc ann | x
-> Doc ann | LxR

`(`enclose` l r x)` encloses document `x` between documents `l` and `r` using ``<>``.

    >>> enclose "A" "Z" "·"
    A·Z

    enclose l r x = l <> x <> r

surround :: Doc ann -> Doc ann -> Doc ann -> Doc ann Source #

`(`surround` x l r)` surrounds document `x` with `l` and `r`.

    >>> surround "·" "A" "Z"
    A·Z

This is merely an argument reordering of ``enclose``, but allows for definitions like

    >>> concatWith (surround dot) ["Prettyprinter", "Render", "Text"]
    Prettyprinter.Render.Text

unAnnotate :: Doc ann -> Doc xxx Source #

Remove all annotations.

Although `unAnnotate` is idempotent with respect to rendering,

    unAnnotate . unAnnotate = unAnnotate

it should not be used without caution, for each invocation traverses the entire contained document. If possible, it is preferrable to unannotate after producing the layout by using `unAnnotateS`.

reAnnotate :: (ann -> ann') -> Doc ann -> Doc ann' Source #

Change the annotation of a `Doc`ument.

Useful in particular to embed documents with one form of annotation in a more generally annotated document.

Since this traverses the entire ``Doc`` tree, including parts that are not rendered due to other layouts fitting better, it is preferrable to reannotate after producing the layout by using ``reAnnotateS``.

Since ``reAnnotate`` has the right type and satisfies `'reAnnotate id = id'`, it is used to define the ``Functor`` instance of ``Doc``.

alterAnnotations :: (ann -> [ann']) -> Doc ann -> Doc ann' Source #

Change the annotations of a `Doc`ument. Individual annotations can be removed, changed, or replaced by multiple ones.

This is a general function that combines `unAnnotate` and `reAnnotate`, and it is useful for mapping semantic annotations (such as »this is a keyword«) to display annotations (such as »this is red and underlined«), because some backends may not care about certain annotations, while others may.

Annotations earlier in the new list will be applied earlier, i.e. returning `[Bold, Green]` will result in a bold document that contains green text, and not vice-versa.

Since this traverses the entire ``Doc`` tree, including parts that are not rendered due to other layouts fitting better, it is preferrable to reannotate after producing the layout by using ``alterAnnotationsS``.

unAnnotateS :: SimpleDocStream ann -> SimpleDocStream xxx Source #

Remove all annotations. `unAnnotate` for `SimpleDocStream`.

reAnnotateS :: (ann -> ann') -> SimpleDocStream ann -> SimpleDocStream ann' Source #

Change the annotation of a document. `reAnnotate` for `SimpleDocStream`.

alterAnnotationsS :: (ann -> Maybe ann') -> SimpleDocStream ann -> SimpleDocStream ann' Source #

Change the annotation of a document to a different annotation, or none at all. `alterAnnotations` for `SimpleDocStream`.

Note that the `Doc` version is more flexible, since it allows changing a single annotation to multiple ones. (`SimpleDocTree` restores this flexibility again.)

fuse :: FusionDepth -> Doc ann -> Doc ann Source #

`(`fuse` depth doc)` combines text nodes so they can be rendered more efficiently. A fused document is always laid out identical to its unfused version.

When laying a `Doc`ument out to a `SimpleDocStream`, every component of the input is translated directly to the simpler output format. This sometimes yields undesirable chunking when many pieces have been concatenated together.

For example

    >>> "a" <> "b" <> pretty 'c' <> "d"
    abcd

results in a chain of four entries in a `SimpleDocStream`, although this is fully equivalent to the tightly packed

    >>> "abcd" :: Doc ann
    abcd

which is only a single `SimpleDocStream` entry, and can be processed faster.

It is therefore a good idea to run `fuse` on concatenations of lots of small strings that are used many times:

    >>> let oftenUsed = fuse Shallow ("a" <> "b" <> pretty 'c' <> "d")
    >>> hsep (replicate 5 oftenUsed)
    abcd abcd abcd abcd abcd

removeTrailingWhitespace :: SimpleDocStream ann -> SimpleDocStream ann Source #

Remove all trailing space characters.

This has some performance impact, because it does an entire additional pass over the `SimpleDocStream`.

No trimming will be done inside annotations, which are considered to contain no (trimmable) whitespace, since the annotation might actually be about the whitespace, for example a renderer that colors the background of trailing whitespace, as e.g. `git diff` can be configured to do.

Historical note: Since v1.7.0, `layoutPretty` and `layoutSmart` avoid producing the trailing whitespace that was the original motivation for creating `removeTrailingWhitespace`. See https://github.com/quchen/prettyprinter/pull/139 for some background info.

defaultLayoutOptions :: LayoutOptions Source #

The default layout options, suitable when you just want some output, and don’t particularly care about the details. Used by the `Show` instance, for example.

    >>> defaultLayoutOptions
    LayoutOptions {layoutPageWidth = AvailablePerLine 80 1.0}

layoutPretty :: LayoutOptions -> Doc ann -> SimpleDocStream ann Source #

This is the default layout algorithm, and it is used by `show`, `putDoc` and `hPutDoc`.

``layoutPretty`` commits to rendering something in a certain way if the next element fits the layout constraints; in other words, it has one `SimpleDocStream` element lookahead when rendering. Consider using the smarter, but a bit less performant, ``layoutSmart`` algorithm if the results seem to run off to the right before having lots of line breaks.

layoutSmart :: LayoutOptions -> Doc ann -> SimpleDocStream ann Source #

A layout algorithm with more lookahead than `layoutPretty`, that introduces line breaks earlier if the content does not (or will not, rather) fit into one line.

Consider the following python-ish document,

    >>> let fun x = hang 2 ("fun(" <> softline' <> x) <> ")"
    >>> let doc = (fun . fun . fun . fun . fun) (align (list ["abcdef", "ghijklm"]))

which we’ll be rendering using the following pipeline (where the layout algorithm has been left open):

    >>> import Data.Text.IO as T
    >>> import Prettyprinter.Render.Text
    >>> let hr = pipe <> pretty (replicate (26-2) '-') <> pipe
    >>> let go layouter x = (T.putStrLn . renderStrict . layouter (LayoutOptions (AvailablePerLine 26 1))) (vsep [hr, x, hr])

If we render this using `layoutPretty` with a page width of 26 characters per line, all the `fun` calls fit into the first line so they will be put there:

    >>> go layoutPretty doc
    |------------------------|
    fun(fun(fun(fun(fun(
                      [ abcdef
                      , ghijklm ])))))
    |------------------------|

Note that this exceeds the desired 26 character page width. The same document, rendered with ``layoutSmart``, fits the layout contstraints:

    >>> go layoutSmart doc
    |------------------------|
    fun(
      fun(
        fun(
          fun(
            fun(
              [ abcdef
              , ghijklm ])))))
    |------------------------|

The key difference between `layoutPretty` and `layoutSmart` is that the latter will check the potential document until it encounters a line with the same indentation or less than the start of the document. Any line encountered earlier is assumed to belong to the same syntactic structure. `layoutPretty` checks only the first line.

Consider for example the question of whether the `A`s fit into the document below:

    1 A
    2   A
    3  A
    4 B
    5   B

`layoutPretty` will check only line 1, ignoring whether e.g. line 2 might already be too wide. By contrast, `layoutSmart` stops only once it reaches line 4, where the `B` has the same indentation as the first `A`.

layoutCompact :: Doc ann1 -> SimpleDocStream ann2 Source #

`(layoutCompact x)` lays out the document `x` without adding any indentation and without preserving annotations. Since no 'pretty' printing is involved, this layouter is very fast. The resulting output contains fewer characters than a prettyprinted version and can be used for output that is read by other programs.

    >>> let doc = hang 4 (vsep ["lorem", "ipsum", hang 4 (vsep ["dolor", "sit"])])
    >>> doc
    lorem
        ipsum
        dolor
            sit

    >>> let putDocCompact = renderIO System.IO.stdout . layoutCompact
    >>> putDocCompact doc
    lorem
    ipsum
    dolor
    sit

squotes :: Doc ann -> Doc ann Source #

    >>> squotes "·"
    '·'

dquotes :: Doc ann -> Doc ann Source #

    >>> dquotes "·"
    "·"

angles :: Doc ann -> Doc ann Source #

    >>> angles "·"
    <·>

squote :: Doc ann Source #

    >>> squote
    '

dquote :: Doc ann Source #

    >>> dquote
    "

langle :: Doc ann Source #

    >>> langle
    <

rangle :: Doc ann Source #

    >>> rangle
    >

lbracket :: Doc ann Source #

    >>> lbracket
    [

rbracket :: Doc ann Source #

    >>> rbracket
    ]

dot :: Doc ann Source #

    >>> dot
    .

slash :: Doc ann Source #

    >>> slash
    /

backslash :: Doc ann Source #

    >>> backslash
    \

pipe :: Doc ann Source #

    >>> pipe
    |

module Prettyprinter.Render.Terminal

type Doc = Doc AnsiStyle Source #

type SimpleDoc = SimpleDocStream AnsiStyle Source #

(.$.) :: Doc -> Doc -> Doc Source #

(</>) :: Doc -> Doc -> Doc Source #

groupOrNestLine :: Doc -> Doc Source #

Render flattened text on this line, or start a new line before rendering any text.

This will also nest subsequent lines in the group.

altSep :: Doc -> Doc -> Doc Source #

Separate items in an alternative with a pipe.

If the first document and the pipe don't fit on the line, then mandatorily flow the next entry onto the following line.

The (//) softbreak ensures that if the document does fit on the line, there is at least a space, but it's possible for y to still appear on the next line.

hangAtIfOver :: Int -> Int -> Doc -> Doc Source #

Printer hacks to get nice indentation for long commands and subcommands.

If we're starting this section over the desired width (usually 1/3 of the ribbon), then we will make a line break, indent all of the usage, and go.

The ifAtRoot is an interesting clause. If this whole operation is put under a `group` then the linebreak will disappear; then item d will therefore not be at the starting column, and it won't be indented more.

prettyString :: Double -> Int -> Doc -> String Source #