typeset 3.1.2

A DSL for defining source code pretty printers
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

use typeset::*;

/// Basic pretty printing example showing fundamental layout combinators
fn main() {
    println!("=== Basic Layout Combinators ===\n");

    // Basic text layouts
    let hello = text("Hello".to_string());
    let world = text("World".to_string());

    // Unpadded composition (no spaces)
    let hello_world_unpadded = comp(hello.clone(), world.clone(), false, false);
    println!(
        "Unpadded: \"{}\"",
        render(compile(hello_world_unpadded), 2, 80)
    );

    // Padded composition (with spaces)
    let hello_world_padded = comp(hello.clone(), world.clone(), true, false);
    println!("Padded: \"{}\"", render(compile(hello_world_padded), 2, 80));

    // Line breaks
    let hello_newline_world = line(hello.clone(), world.clone());
    println!(
        "Line break:\n\"{}\"",
        render(compile(hello_newline_world), 2, 80)
    );

    // Nested layouts
    let nested = nest(comp(
        text("Indented".to_string()),
        text("text".to_string()),
        true,
        false,
    ));
    let with_prefix = comp(text("Prefix:".to_string()), nested, false, false);
    println!(
        "Nested (broken):\n\"{}\"",
        render(compile(with_prefix), 2, 10)
    ); // Force break with small width

    // Fixed layouts (won't break)
    let fixed_comp = fix(comp(
        text("Fixed".to_string()),
        text("together".to_string()),
        false,
        false,
    ));
    println!("Fixed: \"{}\"", render(compile(fixed_comp), 2, 5)); // Will overflow

    // Groups (break as unit)
    let group_inner = comp(
        text("grouped".to_string()),
        text("content".to_string()),
        true,
        false,
    );
    let grouped = grp(group_inner);
    let with_group = comp(text("Before".to_string()), grouped, true, false);
    println!(
        "Grouped (fits): \"{}\"",
        render(compile(with_group.clone()), 2, 80)
    );
    println!(
        "Grouped (breaks): \"{}\"",
        render(compile(with_group), 2, 10)
    );

    // Sequence (all break if one breaks)
    let seq_inner = comp(
        text("item1".to_string()),
        comp(
            text("item2".to_string()),
            text("item3".to_string()),
            true,
            false,
        ),
        true,
        false,
    );
    let sequenced = seq(seq_inner);
    println!(
        "Sequence (breaks all):\n\"{}\"",
        render(compile(sequenced), 2, 10)
    );

    // Pack (align to first item position)
    let pack_inner = comp(
        text("first".to_string()),
        comp(
            text("second".to_string()),
            text("third".to_string()),
            true,
            false,
        ),
        true,
        false,
    );
    let packed = pack(pack_inner);
    let with_pack = comp(text("Start".to_string()), packed, true, false);
    println!("Pack alignment:\n\"{}\"", render(compile(with_pack), 2, 15));
}