Struct pomelo_fmt::printer::Printer

pub struct Printer {
    margin: isize,
    space: isize,
    left_total: isize,
    right_total: isize,
    buffer: Buffer<BufElt>,
    scan_stack: VecDeque<usize>,
    print_stack: Vec<PrintStackEntry>,
    output: String,
}

Fields

margin: isize

space: isize

left_total: isize

right_total: isize

buffer: Buffer<BufElt>

scan_stack: VecDeque<usize>

Stack of pointers to the start of the current group in the buffer

print_stack: Vec<PrintStackEntry>

output: String

Implementations

impl Printer

pub fn new(line_width: usize) -> Self

pub fn output(self) -> String

pub fn text(&mut self, s: impl Into<Cow<'static, str>>)

pub fn cgroup(&mut self, indent: isize)

pub fn igroup(&mut self, indent: isize)

pub fn endgroup(&mut self)

pub fn linebreak(&mut self)

pub fn zerobreak(&mut self)

pub fn space(&mut self)

pub fn space_indent(&mut self)

impl Printer

fn scan(&mut self, t: Token)

fn print(&mut self, token: Token, size: isize)

fn advance_left(&mut self)

fn check_stack(&mut self, k: isize)

fn check_stream(&mut self)

fn add_space_break(&mut self, blank_spaces: usize)

fn add_line_break(&mut self, print_stack_offset: isize, overflow_indent: usize)

fn insert_indent(&mut self, n: usize)

fn insert_newline(&mut self)

impl Printer

pub fn dec(&mut self, dec: &Dec) -> Option<()>

fn seq_dec(&mut self, d: &SeqDec) -> Option<()>

fn val(&mut self, d: &ValDec) -> Option<()>

fn fun(&mut self, _d: &FunDec) -> Option<()>

fn tydec(&mut self, _d: &TypeDec) -> Option<()>

fn datatype(&mut self, _d: &DatatypeDec) -> Option<()>

fn datarep(&mut self, _d: &DatatypeRepDec) -> Option<()>

fn abstype(&mut self, _d: &AbstypeDec) -> Option<()>

fn exception(&mut self, _d: &ExceptionDec) -> Option<()>

fn local(&mut self, _d: &LocalDec) -> Option<()>

fn open(&mut self, _d: &OpenDec) -> Option<()>

fn infix(&mut self, _d: &InfixDec) -> Option<()>

fn infixr(&mut self, _d: &InfixrDec) -> Option<()>

fn nonfix(&mut self, _d: &NonfixDec) -> Option<()>

impl Printer

pub fn expr(&mut self, expr: &Expr) -> Option<()>

fn atomic_expr(&mut self, e: &AtomicExpr) -> Option<()>

fn vid_expr(&mut self, e: &VIdExpr) -> Option<()>

fn scon_expr(&mut self, e: &SConExpr) -> Option<()>

fn let_expr(&mut self, e: &LetExpr) -> Option<()>

fn unit_expr(&mut self, _e: &UnitExpr) -> Option<()>

fn paren_expr(&mut self, e: &ParenExpr) -> Option<()>

fn recsel_expr(&mut self, e: &RecSelExpr) -> Option<()>

fn typed_expr(&mut self, _e: &TypedExpr) -> Option<()>

fn infix_or_app_expr(&mut self, e: &InfixOrAppExpr) -> Option<()>

fn fn_expr(&mut self, e: &FnExpr) -> Option<()>

fn case_expr(&mut self, e: &CaseExpr) -> Option<()>

fn if_expr(&mut self, e: &IfExpr) -> Option<()>

fn or_else_expr(&mut self, e: &OrElseExpr) -> Option<()>

fn and_also_expr(&mut self, e: &AndAlsoExpr) -> Option<()>

fn while_expr(&mut self, e: &WhileExpr) -> Option<()>

fn raise_expr(&mut self, _e: &RaiseExpr) -> Option<()>

fn handle_expr(&mut self, _e: &HandleExpr) -> Option<()>

impl Printer

fn expr_row(&mut self, e: &ExprRow) -> Option<()>

impl Printer

pub fn pat(&mut self, pat: &Pat) -> Option<()>

fn atomic_pat(&mut self, p: &AtomicPat) -> Option<()>

fn vid_pat(&mut self, p: &VIdPat) -> Option<()>

fn scon_pat(&mut self, p: &SConPat) -> Option<()>

fn wildcard_pat(&mut self, _p: &WildcardPat) -> Option<()>

fn typed_pat(&mut self, _p: &TypedPat) -> Option<()>

fn layered_pat(&mut self, _p: &LayeredPat) -> Option<()>

fn cons_or_infix_pat(&mut self, _p: &ConsOrInfixPat) -> Option<()>

impl Printer

pub fn ty(&mut self, ty: &Ty) -> Option<()>

fn fun_ty(&mut self, _t: &FunTy) -> Option<()>

fn tuple_ty(&mut self, _t: &TupleTy) -> Option<()>

fn cons_ty(&mut self, _t: &ConsTy) -> Option<()>

fn record_ty(&mut self, _t: &RecordTy) -> Option<()>

fn tyvar_ty(&mut self, _t: &TyVarTy) -> Option<()>

impl Printer

pub fn match_rules(&mut self, match_: &Match, is_fn: bool) -> Option<()>

pub(crate) fn list_like<T: Printable>(
    &mut self,
    open_bracket: &'static str,
    close_bracket: &'static str,
    delimiter: &'static str,
    ends_spaced: bool,
    items: impl Iterator<Item = T>,
    item_count: usize
) -> Option<()>

Trait Implementations

impl Clone for Printer

fn clone(&self) -> Printer

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Printer

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

Formats the value using the given formatter.