Struct FieldPattern 

pub struct FieldPattern<'ast> {
    pub matched_id: LocIdent,
    pub annotation: Annotation<'ast>,
    pub default: Option<Ast<'ast>>,
    pub pattern: Pattern<'ast>,
    pub pos: TermPos,
}

A field pattern inside a record pattern. Every field can be annotated with a type, contracts or with a default value.

Fields

matched_id: LocIdent

The name of the matched field. For example, in {..., foo = {bar, baz}, ...}, the matched identifier is foo.

annotation: Annotation<'ast>

Type and contract annotations of this field.

default: Option<Ast<'ast>>

Potential default value, set with the ? value syntax.

pattern: Pattern<'ast>

The pattern on the right-hand side of the =. A pattern like {foo, bar}, without the = sign, is parsed as {foo=foo, bar=bar}. In this case, pattern.data will be PatternData::Any.

pos: TermPos

Trait Implementations

impl<'ast> Clone for FieldPattern<'ast>

fn clone(&self) -> FieldPattern<'ast>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CloneTo for FieldPattern<'_>

type Data<'ast> = FieldPattern<'ast>

This is always Self, be we need associated types to make Rust understand that Self is always parametric over the 'ast lifetime. We’re using GATs to emulate higher-kinded types.

fn clone_to<'to>(pat: Self::Data<'_>, dest: &'to AstAlloc) -> Self::Data<'to>

Clones owned data from the current allocator to dest.

impl<'ast> Debug for FieldPattern<'ast>

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

Formats the value using the given formatter.

impl<'ast> PartialEq for FieldPattern<'ast>

fn eq(&self, other: &FieldPattern<'ast>) -> 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<'ast> TraverseAlloc<'ast, Ast<'ast>> for FieldPattern<'ast>

fn traverse<F, E>( self, alloc: &'ast AstAlloc, f: &mut F, order: TraverseOrder, ) -> Result<Self, E>

where F: FnMut(Ast<'ast>) -> Result<Ast<'ast>, E>,

Same as Traverse::traverse, but takes an additional AST allocator.

fn traverse_ref<S, U>( &'ast self, f: &mut dyn FnMut(&'ast Ast<'ast>, &S) -> TraverseControl<S, U>, scope: &S, ) -> Option<U>

Same as Traverse::traverse_ref, but takes an additional AST allocator.

fn find_map<S>(&'ast self, pred: impl FnMut(&'ast T) -> Option<S>) -> Option<S>

where T: Clone + 'ast,

impl Allocable for FieldPattern<'_>

impl<'ast> Eq for FieldPattern<'ast>

impl<'ast> StructuralPartialEq for FieldPattern<'ast>