Enum Reason 

#[non_exhaustive]
pub enum Reason {
    Kind,
    Variant {
        index: u32,
        count: u32,
    },
    Fields {
        expected: usize,
        found: usize,
    },
    EmptyRange,
    OutOfDomain,
    Length {
        expected: u32,
        found: usize,
    },
}

What is wrong with a pattern, in Error::InvalidPattern.

Examples

use match_lang::Reason;

let reason = Reason::Fields { expected: 1, found: 2 };
assert_eq!(reason.to_string(), "expected 1 fields, found 2");

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Kind

The kind of pattern does not fit the type’s signature, such as an integer pattern on a sum type.

Variant

A variant index at or past the sum type’s variant count.

Fields

index: u32

The variant index used.

count: u32

The number of variants the type has.

Fields

A variant or product pattern with the wrong number of fields.

Fields

expected: usize

The number of fields the model reports.

found: usize

The number of field patterns given.

EmptyRange

A range whose low end is above its high end.

OutOfDomain

An integer or range outside the bounds of an Int type.

Length

An array pattern that cannot have the array’s length: a fixed slice pattern of another length, or a rest pattern needing more elements.

Fields

expected: u32

The array’s length.

found: usize

The number of elements the pattern requires.

Trait Implementations

impl Clone for Reason

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Reason

impl Debug for Reason

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

Formats the value using the given formatter.

impl Display for Reason

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

Formats the value using the given formatter.

impl Eq for Reason

impl Hash for Reason

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Reason

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Reason