shoebill 0.1.1

A Wadler/Leijen style pretty-printer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

//! Tools for managing bracketing during pretty-printing based.
//! 
//! Based on an implementation I saw Gabriel Ebner use that feels complicated, 
//! but it makes sense once you get going, and there's
//! no obvious solution that's better while preserving the generality this offers.
//! The general source of the complexity is that you want both the caller and the callee
//! to have control over whether or not something gets bracketed.
//! There's a working example in the `pp` function of /examples/aexp
//! The idea is that the pretty printing implementation for some type you have is a recursive
//! (or faux-recursive) function that returns elements wrapped in this Parenable type, and have
//! an associated number which lets the functions waiting on their return know whether or not
//! they should wrap the value they get in brackets.

use crate::concat;
use crate::Doclike;
use crate::DocPtr;
use crate::StrOrDoc;
use crate::HasPrinter;
use crate::Renderable;

use BracketPrio::*;

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Brackets<'p> {
    pub doc : StrOrDoc<'p>,
    pub prio : BracketPrio,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum BracketPrio {
    Always,
    Never,
    Num(u16)
}

// The point of this is so that .bracket() doesn't require users to pass
// an allocator, and to make it more generic. We don't want to implement these methods
// in `Doclike` since we don't want users to be able to do it directly for `Doc` elements.
pub trait Bracketable<'p> : Sized {
    fn bracket(self, prio : u16) -> Brackets<'p>;
    fn bracket_never(self) -> Brackets<'p> {
        let mut b = self.bracket(0);
        b.prio = Never;
        b
    }
    fn bracket_always(self) -> Brackets<'p> {
        let mut b = self.bracket(0);
        b.prio = Always;
        b
    }
}

impl<'p, A> Bracketable<'p> for A
where StrOrDoc<'p> : From<A> {
    fn bracket(self, prio : u16) -> Brackets<'p> {
        Brackets {
            doc : self.into(),
            prio : Num(prio),
        }
    }
}

impl<'x, 'p : 'x> Brackets<'p> {

    pub fn paren_upto(self, upto : u16, pr : &mut impl HasPrinter<'p>) -> DocPtr<'p> {
        self.bracket_upto(upto, "(", ")", pr)
    }

    pub fn squre_upto(self, upto : u16, pr : &mut impl HasPrinter<'p>) -> DocPtr<'p> {
        self.bracket_upto(upto, "[", "]", pr)
    }

    pub fn wave_upto(self, upto : u16, pr : &mut impl HasPrinter<'p>) -> DocPtr<'p> {
        self.bracket_upto(upto, "{", "}", pr)
    }

    pub fn bracket_upto(
        self, 
        upto : u16, 
        open : &'p str, 
        close : &'p str, 
        pr : &mut impl HasPrinter<'p>
    ) -> DocPtr<'p> {
        match self.prio {
            Never => self.doc.alloc(pr),
            Always => concat!([open, self.doc, close], pr),
            Num(n) => {
                if n <= upto {
                    concat!([open, self.doc, close], pr)
                } else {
                    self.doc.alloc(pr)
                }
            }
        }
    }

    /// Do not add brackets to this item, disregarding its priority. We want the caller to have
    /// the last word, so this will override an inner priority of `BracketPrio::Always`.
    pub fn wo_brackets(self, pr : &mut impl HasPrinter<'p>) -> DocPtr<'p> {
        self.doc.alloc(pr)
    }

    pub fn w_parens(self, pr : &mut impl HasPrinter<'p>) -> DocPtr<'p> {
        self.w_brackets("(", ")", pr)
    }

    pub fn w_square(self, pr : &mut impl HasPrinter<'p>) -> DocPtr<'p> {
        self.w_brackets("[", "]", pr)
    }

    pub fn w_wave(self, pr : &mut impl HasPrinter<'p>) -> DocPtr<'p> {
        self.w_brackets("{", "}", pr)
    }

    /// Add brackets to this item, disregarding its assigned priority. We want the caller to have
    /// the last word, so this will override an inner priority of `BracketPrio::Never`.
    pub fn w_brackets(
        self, 
        open : &'p str,
        close : &'p str,
        pr : &mut impl HasPrinter<'p>) -> DocPtr<'p> {
        concat!([open, self.doc, close], pr)
    }

    /// A convenience function for rendering the 'last' item; this ignores/discards the given
    /// item's priority and does not add brackets, since it's more likely than not that the final
    /// expression isn't meant to be bracketed.
    pub fn render<P>(self, line_width : u16, pr : &'x mut P) -> Renderable<'x, 'p, P> 
    where P : HasPrinter<'p> {
        self.doc.alloc(pr).render(line_width, pr)
    }

}