Enum Use 

pub enum Use<A: AstTypes = DefaultTypes> {
    Glob,
    Name(A::Symbol),
    Alias(A::Symbol, A::Symbol),
    Path(A::Symbol, Box<Use<A>>),
    Tree(Vec<Use<A>>),
}

A compound import declaration

Variants

Glob

“*”

Name(A::Symbol)

Identifier

Alias(A::Symbol, A::Symbol)

Identifier as Identifier

Path(A::Symbol, Box<Use<A>>)

Identifier :: Use

Tree(Vec<Use<A>>)

{ Use, * }

Trait Implementations

impl<A: Clone + AstTypes> Clone for Use<A>

where A::Symbol: Clone,

fn clone(&self) -> Use<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug + AstTypes> Debug for Use<A>

where A::Symbol: Debug,

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

Formats the value using the given formatter.

impl<A: AstTypes> Display for Use<A>

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

Formats the value using the given formatter.

impl<A: AstTypes, B: AstTypes> Foldable<A, B> for Use<A>

type Out = Use<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: Hash + AstTypes> Hash for Use<A>

where A::Symbol: 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<A: PartialEq + AstTypes> PartialEq for Use<A>

where A::Symbol: PartialEq,

fn eq(&self, other: &Use<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, A: AstTypes> Walk<'a, A> for Use<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<A: Eq + AstTypes> Eq for Use<A>

where A::Symbol: Eq,

impl<A: AstTypes> StructuralPartialEq for Use<A>