Struct `Error`

struct Error { ... }

An error that occurred while parsing a regular expression into an abstract syntax tree.

Note that not all ASTs represents a valid regular expression. For example, an AST is constructed without error for \p{Quux}, but Quux is not a valid Unicode property name. That particular error is reported when translating an AST to the high-level intermediate representation (HIR).

Implementations

`impl Error`

fn kind(self: &Self) -> &ErrorKind

Return the type of this error.

fn pattern(self: &Self) -> &str

The original pattern string in which this error occurred.

Every span reported by this error is reported in terms of this string.

fn span(self: &Self) -> &Span

Return the span at which this error occurred.

fn auxiliary_span(self: &Self) -> Option<&Span>

Return an auxiliary span. This span exists only for some errors that benefit from being able to point to two locations in the original regular expression. For example, "duplicate" errors will have the main error position set to the duplicate occurrence while its auxiliary span will be set to the initial occurrence.

`impl Clone for Error`

fn clone(self: &Self) -> Error

`impl Debug for Error`

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

`impl Display for Error`

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

`impl Eq for Error`

`impl Error for Error`

`impl Freeze for Error`

`impl PartialEq for Error`

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

`impl RefUnwindSafe for Error`

`impl Send for Error`

`impl StructuralPartialEq for Error`

`impl Sync for Error`

`impl Unpin for Error`

`impl UnsafeUnpin for Error`

`impl UnwindSafe for Error`

`impl<T> Any for Error`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Error`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for Error`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for Error`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> From for Error`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for Error`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T> ToString for Error`

fn to_string(self: &Self) -> String

`impl<T, U> Into for Error`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Error`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for Error`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>