toon-rust 0.1.3

Token-Oriented Object Notation (TOON) - JSON for LLM prompts at half the tokens. Rust implementation.
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

//! Options for encoding and decoding TOON format

/// Delimiter character for tabular arrays
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Delimiter {
    /// Comma delimiter (default)
    #[default]
    Comma,
    /// Tab delimiter
    Tab,
    /// Pipe delimiter
    Pipe,
}

impl Delimiter {
    /// Get the delimiter character
    pub fn as_char(self) -> char {
        match self {
            Delimiter::Comma => ',',
            Delimiter::Tab => '\t',
            Delimiter::Pipe => '|',
        }
    }
}

/// Options for encoding TOON format
#[derive(Debug, Clone, Default)]
pub struct EncodeOptions {
    /// Delimiter for tabular arrays (default: comma)
    pub delimiter: Option<Delimiter>,
    /// Optional hash prefix for array lengths (e.g., `[#3]` instead of `[3]`)
    pub length_marker: Option<char>,
    /// Number of spaces per indentation level (default: 2)
    pub indent: Option<usize>,
}

impl EncodeOptions {
    /// Create new default options
    pub fn new() -> Self {
        Self::default()
    }

    /// Set the delimiter
    pub fn delimiter(mut self, delimiter: Delimiter) -> Self {
        self.delimiter = Some(delimiter);
        self
    }

    /// Set the length marker (typically `'#'`)
    pub fn length_marker(mut self, marker: char) -> Self {
        self.length_marker = Some(marker);
        self
    }

    /// Set the indentation level
    pub fn indent(mut self, indent: usize) -> Self {
        self.indent = Some(indent);
        self
    }

    /// Get the delimiter, defaulting to comma
    pub fn get_delimiter(&self) -> char {
        self.delimiter.unwrap_or_default().as_char()
    }

    /// Get the indentation, defaulting to 2
    pub fn get_indent(&self) -> usize {
        self.indent.unwrap_or(2)
    }
}

/// Options for decoding TOON format
#[derive(Debug, Clone, Default)]
pub struct DecodeOptions {
    /// Expected number of spaces per indentation level (default: 2)
    pub indent: Option<usize>,
    /// Enable strict validation (default: true)
    pub strict: Option<bool>,
}

impl DecodeOptions {
    /// Create new default options
    pub fn new() -> Self {
        Self::default()
    }

    /// Set the expected indentation level
    pub fn indent(mut self, indent: usize) -> Self {
        self.indent = Some(indent);
        self
    }

    /// Set strict mode
    pub fn strict(mut self, strict: bool) -> Self {
        self.strict = Some(strict);
        self
    }

    /// Get the indentation, defaulting to 2
    pub fn get_indent(&self) -> usize {
        self.indent.unwrap_or(2)
    }

    /// Get strict mode, defaulting to true
    pub fn get_strict(&self) -> bool {
        self.strict.unwrap_or(true)
    }
}