Enum pretty::Doc

pub enum Doc<'a, T, A = ()>
where
    T: DocPtr<'a, A>,
{
    Nil,
    Append(T, T),
    Group(T),
    FlatAlt(T, T),
    Nest(isize, T),
    Hardline,
    RenderLen(usize, T),
    OwnedText(Box<str>),
    BorrowedText(&'a str),
    SmallText(SmallText),
    Annotated(A, T),
    Union(T, T),
    Column(T::ColumnFn),
    Nesting(T::ColumnFn),
    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

Append(T, T)

Group(T)

FlatAlt(T, T)

Nest(isize, T)

Hardline

RenderLen(usize, T)

OwnedText(Box<str>)

BorrowedText(&'a str)

SmallText(SmallText)

Annotated(A, T)

Union(T, T)

Column(T::ColumnFn)

Nesting(T::ColumnFn)

Fail

Implementations

impl<'a, D, A> Doc<'a, D, A>

where D: DocPtr<'a, A>,

pub fn nil() -> Self

An empty document.

pub fn hardline() -> Self

A single hardline.

pub fn space() -> Self

pub fn fail() -> Self

impl<'a, D, A> Doc<'a, D, A>

where D: StaticDoc<'a, A>,

pub fn line() -> Self

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

pub fn line_() -> Self

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

impl<'a, T, A> Doc<'a, T, A>

where T: StaticDoc<'a, A>,

pub fn as_string<U: Display>(data: U) -> Self

The text t.to_string().

The given text must not contain line breaks.

pub fn text<U: Into<Cow<'a, str>>>(data: U) -> Self

The given text, which must not contain line breaks.

impl<'a, T, A> Doc<'a, T, A>

where T: DocPtr<'a, A> + 'a,

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_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 for<'b> W: RenderAnnotated<'b, A> + ?Sized,

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

pub fn pretty<'d>(&'d self, width: usize) -> PrettyFmt<'a, 'd, T, A>

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

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

Trait Implementations

impl<'a, T, A: Clone> Clone for Doc<'a, T, A>

where T: DocPtr<'a, A> + Clone, T::ColumnFn: Clone,

fn clone(&self) -> Doc<'a, T, A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, T, A> Debug for Doc<'a, T, A>

where T: DocPtr<'a, A> + Debug, A: Debug,

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

Formats the value using the given formatter.

impl<'a, T, A> Default for Doc<'a, T, A>

where T: DocPtr<'a, A>,

fn default() -> Self

Returns the “default value” for a type.

impl<'a, A> From<Doc<'a, BoxDoc<'a, A>, A>> for BoxDoc<'a, A>

fn from(doc: Doc<'a, BoxDoc<'a, A>, A>) -> BoxDoc<'a, A>

Converts to this type from the input type.

impl<'a, A> From<Doc<'a, RcDoc<'a, A>, A>> for RcDoc<'a, A>

fn from(doc: Doc<'a, RcDoc<'a, A>, A>) -> RcDoc<'a, A>

Converts to this type from the input type.

impl<'a, T, A> From<Doc<'a, T, A>> for BuildDoc<'a, T, A>

where T: DocPtr<'a, A>,

fn from(s: Doc<'a, T, A>) -> Self

Converts to this type from the input type.

impl<'a, T, A, S> From<S> for Doc<'a, T, A>

where T: StaticDoc<'a, A>, S: Into<Cow<'a, str>>,

fn from(s: S) -> Doc<'a, T, A>

Converts to this type from the input type.

impl<'a, D, A> Pretty<'a, D, A> for Doc<'a, D::Doc, A>

where A: 'a, D: ?Sized + DocAllocator<'a, A>,

fn pretty(self, allocator: &'a D) -> DocBuilder<'a, D, A>

Converts self into a document