tauq 0.2.0

Token-efficient data notation - 49% fewer tokens than JSON (verified with tiktoken)
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
134
135
136
137
138
139
140
141
142

// Tauq Error Types
//
// Clean, helpful error messages for Tauq compilation

use thiserror::Error;

/// Span information for error reporting
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Span {
    /// 1-based line number
    pub line: usize,
    /// 1-based column number
    pub column: usize,
}

impl Span {
    /// Create a new span
    pub fn new(line: usize, column: usize) -> Self {
        Self { line, column }
    }
}

/// Top-level Tauq error type
#[derive(Debug, Error)]
pub enum TauqError {
    /// Lexical error (invalid token)
    #[error("{0}")]
    Lex(#[from] LexError),

    /// Parse error (invalid syntax)
    #[error("{0}")]
    Parse(#[from] ParseError),

    /// Interpretation error (runtime/logic error)
    #[error("{0}")]
    Interpret(#[from] InterpretError),

    /// I/O error
    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),
}

/// Lexer error
#[derive(Debug, Clone, PartialEq, Error)]
#[error("Lexer error at line {}, column {}: {message}", span.line, span.column)]
pub struct LexError {
    /// Error message
    pub message: String,
    /// Location of the error
    pub span: Span,
}

impl LexError {
    /// Create a new lexical error
    pub fn new(message: impl Into<String>, span: Span) -> Self {
        Self {
            message: message.into(),
            span,
        }
    }
}

/// Parser error with optional hint
#[derive(Debug, Clone, Error)]
pub struct ParseError {
    /// Error message
    pub message: String,
    /// Location of the error
    pub span: Span,
    /// Optional hint for fixing the error
    pub hint: Option<String>,
}

impl ParseError {
    /// Create a new parse error
    pub fn new(message: impl Into<String>, span: Span) -> Self {
        Self {
            message: message.into(),
            span,
            hint: None,
        }
    }

    /// Add a hint to the error
    pub fn with_hint(mut self, hint: impl Into<String>) -> Self {
        self.hint = Some(hint.into());
        self
    }
}

impl std::fmt::Display for ParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "Parse error at line {}, column {}: {}",
            self.span.line, self.span.column, self.message
        )?;
        if let Some(hint) = &self.hint {
            write!(f, "\n  Hint: {}", hint)?;
        }
        Ok(())
    }
}

/// Interpreter error
#[derive(Debug, Clone, Error)]
pub struct InterpretError {
    /// Error message
    pub message: String,
    /// Location of the error (optional)
    pub span: Option<Span>,
}

impl InterpretError {
    /// Create a new interpreter error
    pub fn new(message: impl Into<String>) -> Self {
        Self {
            message: message.into(),
            span: None,
        }
    }

    /// Add location info to the error
    pub fn with_span(mut self, span: Span) -> Self {
        self.span = Some(span);
        self
    }
}

impl std::fmt::Display for InterpretError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if let Some(span) = &self.span {
            write!(
                f,
                "Interpretation error at line {}, column {}: {}",
                span.line, span.column, self.message
            )
        } else {
            write!(f, "Interpretation error: {}", self.message)
        }
    }
}