Struct terms::pattern::Pattern

pub struct Pattern<F, X> { /* fields omitted */ }

Methods

impl<F, X> Pattern<F, X>

pub fn kind(&self) -> &PatternKind<F, X>

pub fn into_kind(self) -> PatternKind<F, X>

pub fn cons(f: F, subs: Vec<Self>) -> Self where
    F: Clone,
    X: Clone, 

pub fn from_slice(f: F, subs: &[Self]) -> Self where
    F: Clone,
    X: Clone, 

pub fn var(x: X) -> Self

pub fn symbol(&self) -> Option<&F>

pub fn sub_patterns(&self) -> Option<&Vec<Self>>

pub fn get(&self, i: usize) -> Option<&Self>

pub fn as_cons(&self) -> Option<(&F, &Vec<Self>)>

pub fn as_term(&self) -> Option<Term<F>> where
    F: Clone, 

Important traits for UniqueVariables<'a, X>

impl<'a, X: PartialEq> Iterator for UniqueVariables<'a, X> type Item = &'a X;

pub fn variables(&self) -> UniqueVariables<X> where
    X: PartialEq, 

pub fn map_variables<Y, M>(&self, g: &M) -> Pattern<F, Y> where
    M: Fn(&X) -> Pattern<F, Y>,
    F: Clone, 

pub fn try_map_variables<Y, M>(&self, g: &M) -> Option<Pattern<F, Y>> where
    M: Fn(&X) -> Option<Pattern<F, Y>>,
    F: Clone, 

pub fn renaming<Z: Clone, W: Clone, Y: AsRef<W>>(
    &self,
    other: &Pattern<F, Y>,
    renaming: &mut HashMap<Z, W>
) -> bool where
    X: AsRef<Z> + PartialOrd<Y>,
    Z: Hash + Eq,
    W: Eq,
    F: PartialEq, 

Find a renaming from X -> Y so that both patterns are equals.

impl<F: Clone, X: Index> Pattern<F, X>

pub fn reindex(&self) -> Pattern<F, X>

Trait Implementations

impl<F, X> PatternLike<F, X> for Pattern<F, X>

fn kind(&self) -> PatternLikeKind<F, X, Self>

impl<F, X> From<PatternKind<F, X>> for Pattern<F, X>

fn from(kind: PatternKind<F, X>) -> Pattern<F, X>

Performs the conversion.

impl<F, X> From<X> for Pattern<F, X>

fn from(x: X) -> Self

Performs the conversion.

impl<F: PartialEq, X: PartialEq> PartialEq<Pattern<F, X>> for Pattern<F, X>

fn eq(&self, other: &Pattern<F, X>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<F: Clone, X: Clone> Clone for Pattern<F, X>

fn clone(&self) -> Pattern<F, X>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: PartialEq + Eq, X: PartialEq + Eq> Eq for Pattern<F, X>

impl<F: Display, X: Display> Display for Pattern<F, X>

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

Formats the value using the given formatter.

impl<F: Debug, X: Debug> Debug for Pattern<F, X>

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

Formats the value using the given formatter.

impl<F: Hash, X: Hash> Hash for Pattern<F, X>

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, 

Feeds a slice of this type into the given [Hasher].