Pretty print either types of kind PrettyType or any other type with a ToPretty instance.

Create a PrettyType from a type.

This is a type-level equivalent of the Show class.

Write an instance of this for converting your type (preferrable of your kind also) to a promoted PrettyType.

Render a type of kind Maybe.

Since: 0.2.1.0

A PrettyType for a string.

A PrettyType for a string with the exact given width.

A PrettyType for a string with a newline character at the end.

A PrettyType for a number.

A PrettyType for a number with a width.

Create PrettyType from a Nat formatted as hex number using lower-case letters for the hex digits.

Create PrettyType from a Nat formatted as 8 bit hex number using lower-case letters for the hex digits.

Create PrettyType from a Nat formatted as 16 bit hex number using lower-case letters for the hex digits.

Create PrettyType from a Nat formatted as 32 bit hex number using lower-case letters for the hex digits.

Create PrettyType from a Nat formatted as 64 bit hex number using lower-case letters for the hex digits.

Create PrettyType from a Nat formatted as hex number using lower-case letters for the hex digits.

Create PrettyType from a Nat formatted as 8 bit hex number using uppercase letters for the hex digits.

Create PrettyType from a Nat formatted as 16 bit hex number using uppercase letters for the hex digits.

Create PrettyType from a Nat formatted as 32 bit hex number using uppercase letters for the hex digits.

Create PrettyType from a Nat formatted as 64 bit hex number using uppercase letters for the hex digits.

Create PrettyType from a Nat formatted as bit representation,

>>> showPretty (Proxy :: Proxy (PutBits 5))
"101"

Create PrettyType from a Nat formatted as 8-bit bit representation,

>>> showPretty (Proxy :: Proxy (PutBits8 5))
"00000101"

Create PrettyType from a Nat formatted as 16-bit bit representation,

>>> showPretty (Proxy :: Proxy (PutBits16 5))
"00000000000000101"

Create PrettyType from a Nat formatted as 32-bit bit representation,

>>> showPretty (Proxy :: Proxy (PutBits32 5))
"00000000000000000000000000000000101"

Create PrettyType from a Nat formatted as 64-bit bit representation,

>>> showPretty (Proxy :: Proxy (PutBits64 5))
"00000000000000000000000000000000000000000000000000000000000000000000101"

A label followed by a colon and space : followed by another element.

>>> showPretty (Proxy :: Proxy ("foo" <:> PutStr "bar"))
@
foo: bar
@

Since: 0.2.0.0

Like <:> but begin the body on a new line.

>>> showPretty (Proxy :: Proxy (PutStr "foo" <:$$> PutStr "bar"))
@
foo:
bar
@

Since: 0.2.0.0

Like '<:$$__>' but indent the body with two spaces.

>>> showPretty (Proxy :: Proxy (PutStr "foo" <:$$--> PutStr "bar"))
@
foo:
  bar
@

Since: 0.2.0.0

Concatenate two PrettyType.

Concatenate two PrettyType using a PrettySpace.

Choose the first non-empty from two PrettyTypes.

Since: 0.2.0.0

Concatenate two PrettyType using a PrettyNewline.

Concatenate two PrettyType using a PrettyNewline and indent the second.

Since: 0.2.0.0

Surround a pretty with parens

Surround a pretty with some pretties

Combine a (type level) list of PrettyTypes next to each other using PrettySpace

Combine a (type level) list of PrettyTypes below each other using PrettyNewline

A combination of PrettySpace and PrettyMany, e.g.:

>>> showPretty (Proxy :: Proxy (PrettyManyIn (PutStr "|") '[PutStr "a", PutStr "b"]))
"|a|b|"

Combine a (type level) list of PrettyTypes seperated by a seperation element.

Repeat a PrettyType n-times and append the copies.

Combinators for type documents.

The basis for pretty printing is this eDSL. It is rendered via the PrettyTypeShow instances for its promoted constructors.

Only the promoted constructors are used, only they have instances for that class.

Padding for PrettyTypes PrettySymbol and PrettyNat.

The precision for PrettySymbol and PrettyNat.

PrettyNat formatting options.

Kind of Prettifier data types.

The type that all data types share, such that they can be passed to PrettifyWith.

Sometimes it is desirable to pass around pretty-printing functions called Prettifier in this library. A Prettifier is a parameterized pretty-printer that accepts a parameter of a specific kind.

For example:

data PutStrIsh :: Prettifies Symbol

type instance PrettifyWith PutStrIsh str = PutStr str ++ PutStr "ish"

>>> showPretty (Proxy @(PrettifyWith PutStrIsh "That's pretty okay"))
"That's pretty okayish"

Since: 0.2.3.0

An abstract declaration of a pretty-printing (type-)function that takes a specific kind of types as parameter.

Since: 0.2.3.0

Apply a Prettifier to a type in order to get a PrettyType

Since: 0.2.3.0

Write a title and print the indented, ToPretty-fied body starting on the next line.

Since: 0.2.3.0

An internal type class for rendering the types of kind PrettyType.

The monad used by ptShow to keep track of indentation.

Since: 0.2.0.0

Internal; write a possibly indented string, and update the PTRenderState accordingly.

Since: 0.2.0.0

Internal type of the indentation used by ptShow in PTM

Since: 0.2.0.0

Internal state used by ptShow in PTM

Since: 0.2.0.0

Internal printf format generation. Used internally by PrettyTypeShow instances to generate the format string piece by piece with the values for the instances of e.g. PrettyPrecise, PrettyNatFormat, or PrettyEmpty.