Struct RecordPattern 

pub struct RecordPattern<'ast> {
    pub patterns: &'ast [FieldPattern<'ast>],
    pub tail: TailPattern,
    pub pos: TermPos,
}

A record pattern.

Fields

patterns: &'ast [FieldPattern<'ast>]

The patterns for each field in the record.

tail: TailPattern

The tail of the pattern, indicating if the pattern is open, i.e. if it ended with an ellipsis, capturing the rest or not.

pos: TermPos

Implementations

impl RecordPattern<'_>

pub fn check_dup(&self) -> Result<(), ParseError>

Check the matches for duplication, and raise an error if any occurs.

Note that for backwards-compatibility reasons this function only checks top-level matches. In Nickel 1.0, this code panicked:

let f = fun { x, x, .. } => x in f { x = 1 }

However this “works”, even though the binding to y is duplicated.

let f =
  fun { x = { y }, z = { y }, .. } => y
in f { x = { y = 1 }, z = { y = 2 } }
# evaluates to 1

This function aims to raise errors in the first case, but maintain the behaviour in the second case.

pub fn is_open(&self) -> bool

Check if this record contract is open, meaning that it accepts additional fields to be present, whether the rest is captured or not.

Trait Implementations

impl<'ast> Clone for RecordPattern<'ast>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CloneTo for RecordPattern<'_>

type Data<'ast> = RecordPattern<'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 RecordPattern<'ast>

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

Formats the value using the given formatter.

impl Display for RecordPattern<'_>

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

Formats the value using the given formatter.

impl<'ast> PartialEq for RecordPattern<'ast>

fn eq(&self, other: &RecordPattern<'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<'a> Pretty<'a, Allocator> for &RecordPattern<'_>

fn pretty(self, allocator: &'a Allocator) -> DocBuilder<'a, Allocator>

Converts self into a document

impl Allocable for RecordPattern<'_>

impl<'ast> Eq for RecordPattern<'ast>

impl<'ast> StructuralPartialEq for RecordPattern<'ast>