Enum Pattern 

pub enum Pattern {
    Anything,
    Var(Ident),
    Literal(Literal),
    Unit,
    Tuple(Vec<Spanned<Pattern>>),
    Constructor {
        module_name: ModuleName,
        name: Ident,
        args: Vec<Spanned<Pattern>>,
    },
    Record(Vec<Spanned<Ident>>),
    Cons {
        head: Box<Spanned<Pattern>>,
        tail: Box<Spanned<Pattern>>,
    },
    List(Vec<Spanned<Pattern>>),
    As {
        pattern: Box<Spanned<Pattern>>,
        name: Spanned<Ident>,
    },
    Parenthesized(Box<Spanned<Pattern>>),
    Hex(i64),
}

A pattern in Elm source code.

Patterns appear in function arguments, case branches, let destructuring, and lambda arguments.

Variants

Anything

Wildcard pattern: _

Var(Ident)

Variable binding: x, name

Literal(Literal)

Literal pattern: 42, "hello", 'c'

Unit

Unit pattern: ()

Tuple(Vec<Spanned<Pattern>>)

Tuple pattern: ( a, b ) or ( a, b, c )

Constructor

Constructor pattern, possibly qualified: Just x, Maybe.Nothing

Fields

module_name: ModuleName

name: Ident

args: Vec<Spanned<Pattern>>

Record(Vec<Spanned<Ident>>)

Record destructuring pattern: { name, age }

Cons

Cons pattern: x :: xs

Fields

head: Box<Spanned<Pattern>>

tail: Box<Spanned<Pattern>>

List(Vec<Spanned<Pattern>>)

List pattern: [ x, y, z ]

As

As pattern: _ as name, (x, y) as point

Fields

pattern: Box<Spanned<Pattern>>

name: Spanned<Ident>

Parenthesized(Box<Spanned<Pattern>>)

Parenthesized pattern: ( pattern )

Hex(i64)

Hex literal pattern: 0xFF

Trait Implementations

impl Clone for Pattern

fn clone(&self) -> Pattern

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Pattern

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

Formats the value using the given formatter.

impl Display for Pattern

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

Formats the value using the given formatter.

impl PartialEq for Pattern

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

impl StructuralPartialEq for Pattern