Struct `Translator`

pub struct Translator { /* private fields */ }

A translator maps abstract syntax to a high level intermediate representation.

A translator may be benefit from reuse. That is, a translator can translate many abstract syntax trees.

A Translator can be configured in more detail via a TranslatorBuilder.

Implementations

`impl Translator`

fn new() -> Translator

Create a new translator using the default configuration.

fn translate(&mut self, pattern: &str, ast: &Ast) -> Result<Hir, Error>

Translate the given abstract syntax tree (AST) into a high level intermediate representation (HIR).

If there was a problem doing the translation, then an HIR-specific error is returned.

The original pattern string used to produce the Ast must also be provided. The translator does not use the pattern string during any correct translation, but is used for error reporting.

Trait Implementations

`impl Clone for Translator`

fn clone(&self) -> Self

`impl Debug for Translator`

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

Auto Trait Implementations

`impl !Freeze for Translator`

`impl !RefUnwindSafe for Translator`

`impl !Sync for Translator`

`impl Send for Translator`

`impl Unpin for Translator`

`impl UnsafeUnpin for Translator`

`impl UnwindSafe for Translator`

Blanket Implementations

`impl<T> Any for Translator where T: 'static + ?Sized,`

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for Translator where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for Translator where T: ?Sized,`

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

`impl<T> CloneToUninit for Translator where T: Clone,`

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

`impl<T> From<T> for Translator`

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

`impl<T> ToOwned for Translator where T: Clone,`

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

`impl<T, U> Into for Translator where U: From<T>,`

fn into(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 Translator where U: Into<T>,`

type Error = never;
fn try_from(value: U) -> Result<T, never>

`impl<T, U> TryInto for Translator where U: TryFrom<T>,`

type Error = >::Error;
fn try_into(self) -> Result<U, >::Error>