Struct SyntaxError 

pub struct SyntaxError<E> {
    pub kind: SyntaxErrorKind<E>,
    /* private fields */
}

An error while compiling a template string.

A syntax error also contains range information concerning the location in the template string from which this syntax error was originally parsed. See SyntaxError::locate for more detail.

Fields

kind: SyntaxErrorKind<E>

The type of syntax error which occured.

Implementations

impl<E> SyntaxError<E>

pub fn locate(&self) -> Range<usize>

Locate the syntax error inside the original template string.

The returned range is guaranteed to correspond to a valid slice of the original template string, and represents the location at which the error was produced.

Examples

An expression failed to parse: recover the original expression text.

use mufmt::Template;

let s = "{ not a usize}";
let err = Template::<&str, usize>::compile(s).unwrap_err();
assert_eq!(&s[err.locate()], " not a usize");

Get the index of an unclosed delimeter.

let err = Template::<&str, &str>::compile("extra}").unwrap_err();
assert_eq!(err.locate().start, 5);

Get all of the trailing characters from an unclosed expression.

let s = " {# 12 }";
let err = Template::<&str, usize>::compile(s).unwrap_err();
assert_eq!(&s[err.locate()], "{# 12 }");

Ranges

The provided ranges depend on the error kind:

Syntax Error Kind	Range
SyntaxErrorKind::InvalidExpr	the contents of the expression before trimming whitespace, but not including the brackets.
SyntaxErrorKind::ExtraBracket	a range of length 1 containing precisely the extra bracket.
SyntaxErrorKind::UnclosedExpr	a range starting before the expression bracket and terminating at the end of the template string.

Trait Implementations

impl<E: Clone> Clone for SyntaxError<E>

fn clone(&self) -> SyntaxError<E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Debug> Debug for SyntaxError<E>

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

Formats the value using the given formatter.

impl<E, R> From<SyntaxError<E>> for Error<E, R>

fn from(err: SyntaxError<E>) -> Self

Converts to this type from the input type.

impl<E: PartialEq> PartialEq for SyntaxError<E>

fn eq(&self, other: &SyntaxError<E>) -> 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<E> StructuralPartialEq for SyntaxError<E>