A Line is ALWAYS just one single line of text, and can always be combined horizontally with other Lines.

• Space is a single horizontal space,
• Blank is a line with no content.
• Text brings any text into the data structure. (Uses Builder for the possibility of optimal performance)
• Row joins multiple elements onto one line.

A Line containing a single space. You **must** use this to create space characters if the spaces will ever be at the start or end of a line that is joined in the context of indentation changes.

Creates a Line from the given String. You must guarantee that all characters in the String are valid 7-bit ASCII characters, and that the string does not start or end with spaces (use space instead).

Creates a Line from the given Char. You must guarantee that the given character is a valid 7-bit ASCII character, and is not a space character (use space instead).

If you know the String only contains ASCII characters, then use string7 instead for better performance.

You must guarantee that the content of the Builder does not contain newlines and does not start with whitespace.

Block contains Lines (at least one; it can't be empty).

Block either:

• can appear in the middle of a line (Stack someLine [], thus can be joined without problems), or
• has to appear on its own (Stack someLine moreLines OR MustBreak someLine).

Types of Blocks:

• SingleLine is a single line, and the indentation level for the line.
• MustBreak is a single line (and its indentation level)) that cannot have anything joined to its right side. Notably, it is used for `--` comments.
• Stack contains two or more lines, and the indentation level for each.

Sometimes (see prefix) the first line of Stack gets different treatment than the other lines.

Converts a Block into a Builder.

You can then write to a file with writeFile, or convert to Text with Data.Text.Encoding.decodeUtf8 . toLazyByteString

A blank line (taking up one vertical space), with no text content.

Promote a Line into a Block.

Promote a Line into a Block that will always have a newline at the end of it, meaning that this Line will never have another Line joined to its right side.

A vertical stack of Blocks. The left edges of all the Blocks will be aligned.

Makes a new Block with the contents of the input Block indented by one additional level.

Adds the prefix to the first line, and pads the other lines with spaces of the given length. You are responsible for making sure that the given length is the actual length of the content of the given Line.

NOTE: An exceptional case that we haven't really designed for is if the first line of the input Block is indented.

EXAMPLE:

abcde
xyz
----->
myPrefix abcde
        xyz

Adds the given suffix to then end of the last line of the Block.

This is the same as rowOrStackForce False.

If all given Blocks are single-line and the Bool is False, then makes a new single-line Block, with the Maybe Line interspersed. Otherwise, makes a vertical stack of the given Blocks.

Same as rowOrIndentForce False.

This is the same as rowOrStackForce, but all non-first lines in the resulting block are indented one additional level.

A convenience alias for `rowOrStack (Just space)`.

A convenience alias for `rowOrStackForce (Just space)`.

A convenience alias for `rowOrIndentForce (Just space)`.

A convenience alias for `rowOrIndentForce (Just space)`.

A binary version of stack.

An alternate style for stack.

a & andThen [b, c] is the same as stack [a, b, c]