Enum Error 

pub enum Error {
    StreamNotConsumed {
        remaining: usize,
    },
    RecursionLimitExceeded {
        depth: usize,
        limit: usize,
    },
    TokenLimitExceeded {
        consumed: usize,
        limit: usize,
    },
}

Core synkit error type.

This enum captures errors that originate from synkit’s internal operations. User-defined parsers should define their own error types and implement From<Error> to convert synkit errors into their domain-specific errors.

Example

use thiserror::Error;

#[derive(Error, Debug)]
pub enum MyParseError {
    #[error("stream not fully consumed: {remaining} tokens remaining")]
    StreamNotConsumed { remaining: usize },

    #[error("expected {expect}, found {found}")]
    Expected { expect: &'static str, found: String },

    // ... other variants
}

impl From<synkit::Error> for MyParseError {
    fn from(err: synkit::Error) -> Self {
        match err {
            synkit::Error::StreamNotConsumed { remaining } => {
                MyParseError::StreamNotConsumed { remaining }
            }
        }
    }
}

Variants

StreamNotConsumed

The token stream was not fully consumed after parsing.

This error is returned by ensure_consumed() when there are remaining tokens (excluding whitespace) in the stream.

Fields

remaining: usize

Number of remaining tokens (excluding whitespace).

RecursionLimitExceeded

Recursion limit exceeded during parsing.

This error is returned when nested parsing exceeds the configured maximum recursion depth. This limit exists to prevent stack overflow from deeply nested malicious input.

Example

Input like [[[[[[...]]]]]] with thousands of nesting levels would trigger this error with the default limit of 128.

Fields

depth: usize

Current recursion depth when limit was exceeded.

limit: usize

Maximum allowed recursion depth.

TokenLimitExceeded

Token limit exceeded during parsing.

This error is returned when the parser has consumed more tokens than the configured maximum. This limit exists to prevent resource exhaustion from extremely long inputs.

Fields

consumed: usize

Number of tokens consumed when limit was exceeded.

limit: usize

Maximum allowed token count.

Trait Implementations

impl Clone for Error

fn clone(&self) -> Error

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

Available on crate feature std only.

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl PartialEq for Error

fn eq(&self, other: &Error) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Error

impl Eq for Error

impl StructuralPartialEq for Error