Provided by: erlang-manpages_20.2.2+dfsg-1ubuntu2_all bug


       prettypr - A generic pretty printer library.


       A  generic  pretty  printer  library.  This  module  uses  a  strict-style context passing
       implementation of John Hughes algorithm, described in "The  design  of  a  Pretty-printing
       Library".  The  paragraph-style  formatting, empty documents, floating documents, and null
       strings are my own additions to the algorithm.

       To get started, you should read about the  document()  data  type;  the  main  constructor
       functions:  text/1,  above/2,  beside/2,  nest/2,  sep/1,  and  par/2; and the main layout
       function format/3.

       If you simply want to format a paragraph of plain text,  you  probably  want  to  use  the
       text_par/2 function, as in the following example:

         prettypr:format(prettypr:text_par("Lorem ipsum dolor sit amet"), 20)



           An  abstract  character-based  "document"  representing  a number of possible layouts,
           which can be processed to produce a single concrete layout. A concrete layout can then
           be  rendered as a sequence of characters containing linebreaks, which can be passed to
           a printer or terminal that uses a fixed-width font.

           For example, a document sep([text("foo"), text("bar")]) represents the two layouts

              foo bar



           Which layout is chosen depends on the available horizontal space.  When  processing  a
           document,  the  main  parameters are the paper width and the line width (also known as
           the "ribbon width"). In the resulting layout, no text should  be  printed  beyond  the
           paper width (which by default is 80 characters) as long as it can be avoided, and each
           single line of text (its indentation not counted, hence "ribbon") should preferably be
           no wider than the specified line width (which by default is 65).

           Documents  can be joined into a single new document using the constructor functions of
           this module. Note that the new document often represents a larger number  of  possible
           layouts than just the sum of the components.


       above(D1::document(), D2::document()) -> document()

              Concatenates   documents   vertically.   Returns   a   document   representing  the
              concatenation of the documents D1 and D2 such that the first  line  of  D2  follows
              directly  below  the  last line of D1, and the first character of D2 is in the same
              horizontal column as the first character of D1, in all possible layouts.


                   ab  cd  =>  ab

                   abc   fgh  =>   de
                    de    ij      fgh

       beside(D1::document(), D2::document()) -> document()

              Concatenates  documents  horizontally.  Returns   a   document   representing   the
              concatenation  of  the  documents  D1  and D2 such that the last character of D1 is
              horizontally adjacent to the first character of D2, in all possible layouts. (Note:
              any indentation of D2 is lost.)


                   ab  cd  =>  abcd

                   ab  ef      ab
                   cd  gh  =>  cdef

       best(D::document(), PaperWidth::integer(), LineWidth::integer()) -> empty | document()

              Selects  a  "best"  layout  for  a  document, creating a corresponding fixed-layout
              document. If no layout could be produced, the atom empty is returned  instead.  For
              details about PaperWidth and LineWidth, see format/3. The function is idempotent.

              One  possible  use  of  this  function is to compute a fixed layout for a document,
              which can then be included as part of a larger document. For example:

                   above(text("Example:"), nest(8, best(D, W - 12, L - 6)))

              will format D as a displayed-text example indented by  8,  whose  right  margin  is
              indented  by 4 relative to the paper width W of the surrounding document, and whose
              maximum individual line length is shorter by 6  than  the  line  length  L  of  the
              surrounding document.

              This  function  is used by the format/3 function to prepare a document before being
              laid out as text.

       break(D::document()) -> document()

              Forces a line break at the end of the given document. This is a  utility  function;
              see empty/0 for details.

       empty() -> document()

              Yields  the  empty  document,  which  has  neither height nor width. (empty is thus
              different from an empty text string, which has zero width but height 1.)

              Empty documents are occasionally useful; in particular, they have the property that
              above(X, empty()) will force a new line after X without leaving an empty line below
              it; since this is a common idiom, the utility function break/1 will place  a  given
              document in such a context.

              See also: text/1.

       floating(D::document()) -> document()

              Equivalent to floating(D, 0, 0).

       floating(D::document(), Hp::integer(), Vp::integer()) -> document()

              Creates  a "floating" document. The result represents the same set of layouts as D;
              however, a floating document may be moved  relative  to  other  floating  documents
              immediately beside or above it, according to their relative horizontal and vertical
              priorities. These priorities are set with the Hp and  Vp  parameters;  if  omitted,
              both default to zero.

              Notes:  Floating documents appear to work well, but are currently less general than
              you might wish, losing effect when embedded in certain contexts. It is possible  to
              nest  floating-operators  (even  with different priorities), but the effects may be
              difficult to predict. In any  case,  note  that  the  way  the  algorithm  reorders
              floating documents amounts to a "bubblesort", so don't expect it to be able to sort
              large sequences of floating documents quickly.

       follow(D1::document(), D2::document()) -> document()

              Equivalent to follow(D1, D2, 0).

       follow(D1::document(), D2::document(), Offset::integer()) -> document()

              Separates two documents by either a single space, or a line break and  intentation.
              In other words, one of the layouts

                   abc def



              will  be  generated,  using  the  optional offset in the latter case. This is often
              useful for typesetting programming language constructs.

              This is a utility function; see par/2 for further details.

              See also: follow/2.

       format(D::document()) -> string()

              Equivalent to format(D, 80).

       format(D::document(), PaperWidth::integer()) -> string()

              Equivalent to format(D, PaperWidth, 65).

       format(D::document(), PaperWidth::integer(), LineWidth::integer()) -> string()

              Computes a layout for a document and returns the corresponding text. See document()
              for further information. Throws no_layout if no layout could be selected.

              PaperWidth  specifies  the  total  width  (in character positions) of the field for
              which the text is to be laid out. LineWidth specifies the desired maximum width (in
              number  of characters) of the text printed on any single line, disregarding leading
              and trailing white space. These parameters need to be properly balanced in order to
              produce good layouts. By default, PaperWidth is 80 and LineWidth is 65.

              See also: best/3.

       nest(N::integer(), D::document()) -> document()

              Indents a document a number of character positions to the right. Note that N may be
              negative, shifting the text to the left, or zero,  in  which  case  D  is  returned

       null_text(Characters::string()) -> document()

              Similar  to  text/1,  but  the  result  is  treated  as  having zero width. This is
              regardless of the actual length of the string. Null  text  is  typically  used  for
              markup, which is supposed to have no effect on the actual layout.

              The  standard  example  is  when formatting source code as HTML to be placed within
              <pre>...</pre> markup, and using e.g. <i> and <b> to make parts of the source  code
              stand  out.  In  this  case,  the markup does not add to the width of the text when
              viewed in an HTML browser, so the layout engine  should  simply  pretend  that  the
              markup has zero width.

              See also: empty/0, text/1.

       par(Docs::[document()]) -> document()

              Equivalent to par(Ds, 0).

       par(Docs::[document()], Offset::integer()) -> document()

              Arranges  documents in a paragraph-like layout. Returns a document representing all
              possible left-aligned paragraph-like layouts of the  (nonempty)  sequence  Docs  of
              documents.  Elements in Docs are separated horizontally by a single space character
              and vertically with a single line break. All lines following the first (if any) are
              indented  to  the  same left column, whose indentation is specified by the optional
              Offset parameter relative to the  position  of  the  first  element  in  Docs.  For
              example,  with an offset of -4, the following layout can be produced, for a list of
              documents representing the numbers 0 to 15:

                       0 1 2 3
                   4 5 6 7 8 9
                   10 11 12 13
                   14 15

              or with an offset of +2:

                   0 1 2 3 4 5 6
                     7 8 9 10 11
                     12 13 14 15

              The utility function text_par/2 can be used to easily transform a  string  of  text
              into a par representation by splitting it into words.

              Note that whenever a document in Docs contains a line break, it will be placed on a
              separate line. Thus, neither a layout such as

                   ab cd


                   cd ef

              will be generated. However, a useful idiom for making the former  variant  possible
              (when  wanted)  is  beside(par([D1, text("")], N), D2) for two documents D1 and D2.
              This will break the line between D1 and D2 if D1  contains  a  line  break  (or  if
              otherwise  necessary),  and  optionally further indent D2 by N character positions.
              The utility function follow/3 creates this context for two documents D1 and D2, and
              an optional integer N.

              See also: par/1, text_par/2.

       sep(Docs::[document()]) -> document()

              Arranges  documents  horizontally or vertically, separated by whitespace. Returns a
              document representing two alternative layouts of the (nonempty)  sequence  Docs  of
              documents, such that either all elements in Docs are concatenated horizontally, and
              separated by a  space  character,  or  all  elements  are  concatenated  vertically
              (without extra separation).

              Note:  If  some  document  in  Docs contains a line break, the vertical layout will
              always be selected.


                   ab  cd  ef  =>  ab cd ef  |  cd

                   ab           ab
                   cd  ef  =>   cd

              See also: par/2.

       text(Characters::string()) -> document()

              Yields a document representing a fixed, unbreakable  sequence  of  characters.  The
              string should contain only printable characters (tabs allowed but not recommended),
              and not newline, line feed, vertical tab, etc. A tab character (\t) is  interpreted
              as  padding  of  1-8 space characters to the next column of 8 characters within the

              See also: empty/0, null_text/1, text_par/2.

       text_par(Text::string()) -> document()

              Equivalent to text_par(Text, 0).

       text_par(Text::string(), Indentation::integer()) -> document()

              Yields  a  document  representing  paragraph-formatted  plain  text.  The  optional
              Indentation  parameter  specifies  the  extra  indentation of the first line of the
              paragraph. For example, text_par("Lorem ipsum dolor sit amet", N) could represent

                   Lorem ipsum dolor
                   sit amet

              if N = 0, or

                     Lorem ipsum
                   dolor sit amet

              if N = 2, or

                   Lorem ipsum dolor
                     sit amet

              if N = -2.

              (The sign of the indentation is thus reversed compared to the par/2  function,  and
              the  behaviour varies slightly depending on the sign in order to match the expected
              layout of a paragraph of text.)

              Note that this is just a utility function, which does all the work of splitting the
              given  string  into  words  separated  by  whitespace and setting up a par with the
              proper indentation, containing a list of text elements.

              See also: par/2, text/1, text_par/1.


       Richard Carlsson <>

                                        syntax_tools 2.1.4                         prettypr(3erl)