Pretty-print any data type that has a Show instance.

If you've never seen MonadIO before, you can think of this function as having the following type signature:

 pPrint :: Show a => a -> IO ()

This function will only use colors if it detects it's printing to a TTY.

This function is for printing to a dark background. Use pPrintLightBg for printing to a terminal with a light background. Different colors are used.

Prints to stdout. Use pHPrint to print to a different Handle.

>>> pPrint [Just (1, "hello")]
[ Just
    ( 1
    , "hello"
    )
]

Similar to pPrint, but take a Handle to print to.

>>> pHPrint stdout [Just (1, "hello")]
[ Just
    ( 1
    , "hello"
    )
]

Similar to pPrint, but the first argument is a String representing a data type that has already been showed.

>>> pPrintString $ show [ Just (1, "hello"), Nothing ]
[ Just
    ( 1
    , "hello"
    )
, Nothing
]

Similar to pHPrintString, but take a Handle to print to.

>>> pHPrintString stdout $ show [ Just (1, "hello"), Nothing ]
[ Just
    ( 1
    , "hello"
    )
, Nothing
]

Similar to pPrint, but print in color regardless of whether the output goes to a TTY or not.

See pPrint for an example of how to use this function.

Similar to pPrintForceColor, but take a Handle to print to.

See pHPrint for an example of how to use this function.

Similar to pPrintString, but print in color regardless of whether the output goes to a TTY or not.

See pPrintString for an example of how to use this function.

Similar to pHPrintString, but print in color regardless of whether the output goes to a TTY or not.

See pHPrintString for an example of how to use this function.

Similar to pPrintForceColor, but just return the resulting pretty-printed data type as a Text instead of printing it to the screen.

This function is for printing to a dark background.

See pShowNoColor for an example of how to use this function.

Similar to pShow, but the first argument is a String representing a data type that has already been showed.

This will work on any String that is similar to a Haskell data type. The only requirement is that the strings are quoted, and braces, parentheses, and brackets are correctly used to represent indentation. For example, pString will correctly pretty-print JSON.

This function is for printing to a dark background.

See pStringNoColor for an example of how to use this function.

Alias for pPrint.

Alias for pHPrint.

Alias for pPrintString.

Alias for pHPrintString.

Alias for pPrintForceColor.

Alias for pHPrintForceColor.

Alias for pPrintStringForceColor.

Alias for pHPrintStringForceColor.

Alias for pShow.

Alias for pString.

Just like pPrintDarkBg, but for printing to a light background.

Just like pHPrintDarkBg, but for printing to a light background.

Just like pPrintStringDarkBg, but for printing to a light background.

Just like pHPrintStringDarkBg, but for printing to a light background.

Just like pPrintForceColorDarkBg, but for printing to a light background.

Just like pHPrintForceColorDarkBg, but for printing to a light background.

Just like pPrintStringForceColorDarkBg, but for printing to a light background.

Just like pHPrintStringForceColorDarkBg, but for printing to a light background.

Just like pShowDarkBg, but for printing to a light background.

Just like pStringDarkBg, but for printing to a light background.

Similar to pPrint, but doesn't print in color. However, data types will still be indented nicely.

>>> pPrintNoColor $ Just ["hello", "bye"]
Just
    [ "hello"
    , "bye"
    ]

Like pPrintNoColor, but take a Handle to determine where to print to.

>>> pHPrintNoColor stdout $ Just ["hello", "bye"]
Just
    [ "hello"
    , "bye"
    ]

Similar to pPrintString, but doesn't print in color. However, data types will still be indented nicely.

>>> pPrintStringNoColor $ show $ Just ["hello", "bye"]
Just
    [ "hello"
    , "bye"
    ]

Like pPrintStringNoColor, but take a Handle to determine where to print to.

>>> pHPrintStringNoColor stdout $ show $ Just ["hello", "bye"]
Just
    [ "hello"
    , "bye"
    ]

Like pShow, but without color.

>>> pShowNoColor [ Nothing, Just (1, "hello") ]
"[ Nothing\n, Just\n    ( 1\n    , \"hello\"\n    )\n]"

LIke pString, but without color.

>>> pStringNoColor $ show [1, 2, 3]
"[ 1\n, 2\n, 3\n]"

Similar to pPrint but takes OutputOptions to change how the pretty-printing is done.

For example, pPrintOpt can be used to make the indentation much smaller than normal.

This is what the normal indentation looks like:

>>> pPrintOpt NoCheckColorTty defaultOutputOptionsNoColor $ Just ("hello", "bye")
Just
    ( "hello"
    , "bye"
    )

This is what smaller indentation looks like:

>>> let smallIndent = defaultOutputOptionsNoColor {outputOptionsIndentAmount = 1}
>>> pPrintOpt CheckColorTty smallIndent $ Just ("hello", "bye")
Just
 ( "hello"
 , "bye"
 )

Lines in strings get indented

>>> pPrintOpt NoCheckColorTty defaultOutputOptionsNoColor (1, (2, "foo\nbar\nbaz", 3))
( 1
,
    ( 2
    , "foo
      bar
      baz"
    , 3
    )
)

Lines get indented even in custom show instances

>>> data Foo = Foo
>>> instance Show Foo where show _ = "foo\nbar\nbaz"
>>> pPrintOpt CheckColorTty defaultOutputOptionsNoColor (1, (2, Foo, 3))
( 1
,
    ( 2
    , foo
      bar
      baz
    , 3
    )
)

CheckColorTty determines whether to test stdout for whether or not it is connected to a TTY.

If set to NoCheckColorTty, then pPrintOpt won't check if stdout is a TTY. It will print in color depending on the value of outputOptionsColorOptions.

If set to CheckColorTty, then pPrintOpt will check if stdout is conneted to a TTY. If stdout is determined to be connected to a TTY, then it will print in color depending on the value of outputOptionsColorOptions. If stdout is determined to NOT be connected to a TTY, then it will NOT print in color, regardless of the value of outputOptionsColorOptions.

Similar to pPrintOpt, but take a Handle to determine where to print to.

Similar to pPrintOpt, but the last argument is a string representing a data structure that has already been showed.

>>> let foo = show (1, (2, "hello", 3))
>>> pPrintStringOpt CheckColorTty defaultOutputOptionsNoColor foo
( 1
,
    ( 2
    , "hello"
    , 3
    )
)

Similar to pPrintStringOpt, but take a Handle to determine where to print to.

>>> let foo = show (1, (2, "hello", 3))
>>> pHPrintStringOpt CheckColorTty defaultOutputOptionsNoColor stdout foo
( 1
,
    ( 2
    , "hello"
    , 3
    )
)

Like pShow but takes OutputOptions to change how the pretty-printing is done.

Like pString but takes OutputOptions to change how the pretty-printing is done.

Data-type wrapping up all the options available when rendering the list of Outputs.

Control how escaped and non-printable are output for strings.

See outputOptionsStringStyle for what the output looks like with each of these options.

Default values for OutputOptions when printing to a console with a dark background. outputOptionsIndentAmount is 4, and outputOptionsColorOptions is defaultColorOptionsDarkBg.

Default values for OutputOptions when printing to a console with a light background. outputOptionsIndentAmount is 4, and outputOptionsColorOptions is defaultColorOptionsLightBg.

Default values for OutputOptions when printing using using ANSI escape sequences for color. outputOptionsIndentAmount is 4, and outputOptionsColorOptions is Nothing.

Determines whether pretty-simple should check if the output Handle is a TTY device. Normally, users only want to print in color if the output Handle is a TTY device.

Default color options for use on a dark background.

Default color options for use on a light background.

These options are for colorizing the output of functions like pPrint.

If you don't want to use a color for one of the options, use colorNull.

Ways to style terminal output.

The 8 ANSI terminal colors.

Dull or vivid coloring, as supported by ANSI terminals.

No styling.