Struct At 

pub struct At<T: AstNode, A: AstTypes = DefaultTypes>(pub T, pub A::Annotation);

A value with an annotation.

Tuple Fields

0: T

1: A::Annotation

Implementations

impl<T: AstNode, A: AstTypes> At<T, A>

pub fn value(&self) -> &T

pub fn a(&self) -> &A::Annotation

pub fn map<U: AstNode>(self, f: impl FnOnce(T) -> U) -> At<U, A>

pub fn map_ref<U: AstNode>(&self, f: impl FnOnce(&T) -> U) -> At<U, A>

pub fn map_a<B: AstTypes>( self, f: impl FnOnce(A::Annotation) -> B::Annotation, ) -> At<T, B>

Trait Implementations

impl<T: Clone + AstNode, A: Clone + AstTypes> Clone for At<T, A>

where A::Annotation: Clone,

fn clone(&self) -> At<T, A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: AstNode, A: AstTypes> Debug for At<T, A>

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

Formats the value using the given formatter.

impl<T: Display + AstNode, A: AstTypes> Display for At<T, A>

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

Formats the value using the given formatter.

impl<A: AstTypes, B: AstTypes> Foldable<A, B> for At<Expr<A>, A>

type Out = At<Expr<B>, B>

The return type of the associated Fold function

fn fold_in<F: Fold<A, B> + ?Sized>( self, folder: &mut F, ) -> Result<Self::Out, F::Error>

Calls Self’s appropriate Folder function(s)

fn children<F: Fold<A, B> + ?Sized>( self, folder: &mut F, ) -> Result<Self::Out, F::Error>

Destructures self, calling Foldable::fold_in on all foldable members, and rebuilds a Self out of the results.

impl<A: AstTypes, B: AstTypes> Foldable<A, B> for At<Pat<A>, A>

type Out = At<Pat<B>, B>

The return type of the associated Fold function

fn fold_in<F: Fold<A, B> + ?Sized>( self, folder: &mut F, ) -> Result<Self::Out, F::Error>

Calls Self’s appropriate Folder function(s)

fn children<F: Fold<A, B> + ?Sized>( self, folder: &mut F, ) -> Result<Self::Out, F::Error>

Destructures self, calling Foldable::fold_in on all foldable members, and rebuilds a Self out of the results.

impl<T: Hash + AstNode, A: Hash + AstTypes> Hash for At<T, A>

where A::Annotation: Hash,

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<M: Match<A> + AstNode, A: AstTypes> Match<A> for At<M, A>

fn recurse(sub: &mut Subst<A>, pat: &Self, expr: &Self) -> bool

Implements recursive Subst-building for Self

fn apply(&mut self, sub: &Subst<A>)

With self as the pattern, recursively applies the Subst

fn apply_rule(&mut self, pat: &Self, template: &Self) -> bool

where Self: Sized + Clone,

Applies a substitution rule from pat to template on self

fn match_with(&self, pat: &Self) -> Option<Subst<A>>

Matches self against the provided pattern

impl<T: PartialEq + AstNode, A: PartialEq + AstTypes> PartialEq for At<T, A>

where A::Annotation: PartialEq,

fn eq(&self, other: &At<T, A>) -> 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<'a, T: AstNode + Walk<'a, A>, A: AstTypes> Walk<'a, A> for At<T, A>

fn children<V: Visit<'a, A> + ?Sized>( &'a self, v: &mut V, ) -> Result<(), V::Error>

fn visit_in<V: Visit<'a, A> + ?Sized>( &'a self, v: &mut V, ) -> Result<(), V::Error>

impl<T: Eq + AstNode, A: Eq + AstTypes> Eq for At<T, A>

where A::Annotation: Eq,

impl<T: AstNode, A: AstTypes> StructuralPartialEq for At<T, A>