Struct RecordPattern 

pub struct RecordPattern {
    pub patterns: Vec<FieldPattern>,
    pub tail: TailPattern,
    pub pos: TermPos,
}

A record pattern.

Fields

patterns: Vec<FieldPattern>

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 Clone for RecordPattern

fn clone(&self) -> RecordPattern

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CompilePart for RecordPattern

fn compile_part(&self, value_id: LocIdent, bindings_id: LocIdent) -> RichTerm

Compile part of a broader pattern to a Nickel expression with two free variables (which is equivalent to a function of two arguments):

impl Debug for RecordPattern

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> FromMainline<'ast, RecordPattern> for PatternData<'ast>

fn from_mainline(alloc: &'ast AstAlloc, record_pat: &RecordPattern) -> Self

impl PartialEq for RecordPattern

fn eq(&self, other: &RecordPattern) -> 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 StructuralPartialEq for RecordPattern