Enum PrettyTree 

pub enum PrettyTree<'a, T = Cow<'a, str>> {
    Nil,
    Hardline,
    Text(T),
    Annotated {
        style: Rc<AnsiStyle>,
        body: Rc<Self>,
    },
    Append {
        lhs: Rc<Self>,
        rhs: Rc<Self>,
    },
    Group {
        items: Rc<Self>,
    },
    MaybeInline {
        block: Rc<Self>,
        inline: Rc<Self>,
    },
    Nest {
        space: isize,
        doc: Rc<Self>,
    },
    RenderLength {
        length: usize,
        body: Rc<Self>,
    },
    Union {
        lhs: Rc<Self>,
        rhs: Rc<Self>,
    },
    Column {
        invoke: Rc<dyn Fn(usize) -> Self + 'a>,
    },
    Nesting {
        invoke: Rc<dyn Fn(usize) -> Self + 'a>,
    },
    Fail,
}

The concrete document type. This type is not meant to be used directly. Instead use the static functions on Doc or the methods on an DocAllocator.

The T parameter is used to abstract over pointers to Doc. See RefDoc and BoxDoc for how it is used

Variants

Nil

Nothing to show

Hardline

A hard line break

Text(T)

A dynamic text document, all newlines are hard line breaks

Annotated

A document with ansi styles

Fields

style: Rc<AnsiStyle>

The style to use for the text

body: Rc<Self>

The text to display

Append

Concatenates two documents

Fields

lhs: Rc<Self>

The first document

rhs: Rc<Self>

The second document

Group

Concatenates two documents with a space in between

Fields

items: Rc<Self>

The first document

MaybeInline

Concatenates two documents with a line in between

Fields

block: Rc<Self>

The first document

inline: Rc<Self>

The second document

Nest

Concatenates two documents with a line in between

Fields

space: isize

The first document

doc: Rc<Self>

The second document

RenderLength

Stores the length of a string document that is not just ascii

Fields

length: usize

The length of the string

body: Rc<Self>

The document

Union

Concatenates two documents with a line in between

Fields

lhs: Rc<Self>

The first document

rhs: Rc<Self>

The second document

Column

Concatenates two documents with a line in between

Fields

invoke: Rc<dyn Fn(usize) -> Self + 'a>

The first document

Nesting

Concatenates two documents with a line in between

Fields

invoke: Rc<dyn Fn(usize) -> Self + 'a>

The first document

Fail

Concatenates two documents with a line in between

Implementations

impl<'a, T> PrettyTree<'a, T>

pub fn pretty(&self, width: usize) -> PrettyFormatter<'_, 'a, T>

Returns a value which implements std::fmt::Display

use pretty::{BoxDoc, Doc};
let doc =
    BoxDoc::<()>::group(BoxDoc::text("hello").append(Doc::line()).append(Doc::text("world")));
assert_eq!(format!("{}", doc.pretty(80)), "hello world");

impl<'a, T: Text<'a>> PrettyTree<'a, T>

pub fn line_or_space() -> Self

A line acts like a \n but behaves like space if it is grouped on a single line.

pub fn line_or_comma() -> Self

A line acts like \n but behaves like nil if it is grouped on a single line.

pub fn line_or_nil() -> Self

Acts like line but behaves like nil if grouped on a single line

impl<'a, T> PrettyTree<'a, T>

pub fn text(data: impl Into<T>) -> Self

The given text, which must not contain line breaks.

impl<'a, T: Text<'a>> PrettyTree<'a, T>

pub fn render<W>(&self, width: usize, out: &mut W) -> Result<()>

where W: ?Sized + Write,

Writes a rendered document to a std::io::Write object.

pub fn render_vec( &self, width: usize, out: &mut Vec<T>, ) -> Result<(), &'static str>

Writes a rendered document to a std::io::Write object.

pub fn render_fmt<W>(&self, width: usize, out: &mut W) -> Result

where W: ?Sized + Write,

Writes a rendered document to a std::fmt::Write object.

pub fn render_raw<W>(&self, width: usize, out: &mut W) -> Result<(), W::Error>

where W: RenderAnnotated<'a, T> + ?Sized,

Writes a rendered document to a RenderAnnotated<A> object.

impl<'a, T: Text<'a>> PrettyTree<'a, T>

pub fn render_colored<W: Write>(&self, width: usize, out: W) -> Result<()>

The given text, which must not contain line breaks.

impl<'a, T: Text<'a>> PrettyTree<'a, T>

pub fn append<E>(self, follow: E) -> Self

where E: Into<PrettyTree<'a, T>>,

Append the given document after this document.

pub fn join<I, T1, T2>(terms: I, joint: T2) -> PrettyTree<'a, T>

where I: IntoIterator<Item = T1>, T1: Into<PrettyTree<'a, T>>, T2: Into<PrettyTree<'a, T>>,

Allocate a document that intersperses the given separator S between the given documents [A, B, C, ..., Z], yielding [A, S, B, S, C, S, ..., S, Z].

Compare the intersperse method from the itertools crate.

NOTE: The separator type, S may need to be cloned. Consider using cheaply cloneable ptr like RefDoc or RcDoc

pub fn concat<I>(docs: I) -> Self

where I: IntoIterator, I::Item: Into<PrettyTree<'a, T>>,

Allocate a document that intersperses the given separator S between the given documents

pub fn group(self) -> Self

Mark this document as a group.

Groups are layed out on a single line if possible. Within a group, all basic documents with several possible layouts are assigned the same layout, that is, they are all layed out horizontally and combined into a one single line, or they are each layed out on their own line.

pub fn annotate(self, style: Rc<AnsiStyle>) -> Self

Mark this document as a comment.

pub fn union<E>(self, other: E) -> Self

where E: Into<PrettyTree<'a, T>>,

Mark this document as a hard line break.

pub fn align(self) -> Self

Lays out self so with the nesting level set to the current column

NOTE: The doc pointer type, D may need to be cloned. Consider using cheaply cloneable ptr like RefDoc or RcDoc

use pretty::{docs, DocAllocator};

let arena = &pretty::Arena::<()>::new();
let doc = docs![
    arena,
    "lorem",
    " ",
    arena.intersperse(["ipsum", "dolor"].iter().cloned(), arena.line_()).align(),
    arena.hardline(),
    "next",
];
assert_eq!(doc.1.pretty(80).to_string(), "lorem ipsum\n      dolor\nnext");

pub fn hang(self, adjust: isize) -> Self

Lays out self with a nesting level set to the current level plus adjust.

NOTE: The doc pointer type, D may need to be cloned. Consider using cheaply cloneable ptr like RefDoc or RcDoc

use pretty::DocAllocator;

let arena = pretty::Arena::<()>::new();
let doc = arena
    .text("prefix")
    .append(arena.text(" "))
    .append(arena.reflow("Indenting these words with nest").hang(4));
assert_eq!(
    doc.1.pretty(24).to_string(),
    "prefix Indenting these\n           words with\n           nest",
);

pub fn width<F>(self, f: F) -> Self

where F: Fn(isize) -> Self + Clone + 'static, T: Clone,

Lays out self and provides the column width of it available to f

NOTE: The doc pointer type, D may need to be cloned. Consider using cheaply cloneable ptr like RefDoc or RcDoc

use pretty::DocAllocator;

let arena = pretty::Arena::<()>::new();
let doc = arena
    .text("prefix ")
    .append(arena.column(|l| arena.text("| <- column ").append(arena.as_string(l)).into_doc()));
assert_eq!(doc.1.pretty(80).to_string(), "prefix | <- column 7");

pub fn enclose<E, F>(self, before: E, after: F) -> Self

where E: Into<Self>, F: Into<Self>,

Puts self between before and after

pub fn single_quotes(self) -> Self

Puts self between before and after if cond is true

pub fn double_quotes(self) -> Self

Puts self between before and after if cond is true

pub fn parens(self) -> Self

Puts self between before and after if cond is true

pub fn angles(self) -> Self

Puts self between before and after if cond is true

pub fn braces(self) -> Self

Puts self between before and after if cond is true

pub fn brackets(self) -> Self

Puts self between before and after if cond is true

Trait Implementations

impl<'a, U, T: Text<'a>> Add<U> for PrettyTree<'a, T>

where U: Into<Self>,

type Output = PrettyTree<'a, T>

The resulting type after applying the + operator.

fn add(self, rhs: U) -> Self::Output

Performs the + operation.

impl<'a, U, T: Text<'a>> AddAssign<U> for PrettyTree<'a, T>

where U: Into<Self>,

fn add_assign(&mut self, rhs: U)

Performs the += operation.

impl<'a, T: Clone> Clone for PrettyTree<'a, T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, T> Debug for PrettyTree<'a, T>

where T: Text<'a> + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, T> Default for PrettyTree<'a, T>

fn default() -> PrettyTree<'a, T>

Returns the “default value” for a type.

impl<'a, T: Text<'a>> From<&'static str> for PrettyTree<'a, T>

fn from(s: &'static str) -> Self

Converts to this type from the input type.

impl<'a, T> From<()> for PrettyTree<'a, T>

fn from(_: ()) -> Self

Converts to this type from the input type.

impl<'a, U, T> From<Option<U>> for PrettyTree<'a, T>

where Self: From<U>,

fn from(x: Option<U>) -> Self

Converts to this type from the input type.

impl<'a, T: Text<'a>> From<PrettySequence<'a, T>> for PrettyTree<'a, T>

fn from(value: PrettySequence<'a, T>) -> Self

Converts to this type from the input type.

impl<'a, T: Text<'a>> From<T> for PrettyTree<'a, T>

fn from(s: T) -> Self

Converts to this type from the input type.

impl<'a, T: Text<'a>> PrettyBuilder<'a, T> for PrettyTree<'a, T>

fn flat_alt<E>(self, flat: E) -> Self

where E: Into<PrettyTree<'a, T>>,

Acts as self when laid out on multiple lines and acts as that when laid out on a single line.

use pretty::{Arena, DocAllocator};

let arena = Arena::<()>::new();
let body = arena.line().append("x");
let doc = arena
    .text("let")
    .append(arena.line())
    .append("x")
    .group()
    .append(body.clone().flat_alt(arena.line().append("in").append(body)))
    .group();

assert_eq!(doc.1.pretty(100).to_string(), "let x in x");
assert_eq!(doc.1.pretty(8).to_string(), "let x\nx");

fn indent(self, adjust: usize) -> Self

Indents self by adjust spaces from the current cursor position

NOTE: The doc pointer type, D may need to be cloned. Consider using cheaply cloneable ptr like RefDoc or RcDoc

use pretty::DocAllocator;

let arena = pretty::Arena::<()>::new();
let doc = arena
    .text("prefix")
    .append(arena.text(" "))
    .append(arena.reflow("The indent function indents these words!").indent(4));
assert_eq!(
    doc.1.pretty(24).to_string(),
    "
prefix     The indent
           function
           indents these
           words!"
        .trim_start(),
);

fn nest(self, offset: isize) -> Self

Increase the indentation level of this document.

impl<'a, T: Text<'a>> PrettyPrint<'a, T> for PrettyTree<'a, T>

fn pretty(&self, _: &PrettyProvider) -> PrettyTree<'a, T>

Build a pretty tree for this type.

fn pretty_string(&self, theme: &PrettyProvider) -> String

Get a pretty string for this type.

fn pretty_colorful(&self, theme: &PrettyProvider) -> String

Print a pretty string for this type.