Enum InheritedRefMatchRule 

enum InheritedRefMatchRule {
    EatOuter,
    EatInner,
    EatBoth {
        consider_inherited_ref: bool,
    },
}

Variations on RFC 3627’s Rule 4: when do reference patterns match against inherited references?

“Inherited reference” designates the &/&mut types that arise from using match ergonomics, i.e. from matching a reference type with a non-reference pattern. E.g. when Some(x) matches on &mut Option<&T>, x gets type &mut &T and the outer &mut is considered “inherited”.

Variants

EatOuter

Reference patterns consume only the inherited reference if possible, regardless of whether the underlying type being matched against is a reference type. If there is no inherited reference, a reference will be consumed from the underlying type.

EatInner

Reference patterns consume only a reference from the underlying type if possible. If the underlying type is not a reference type, the inherited reference will be consumed.

EatBoth

When the underlying type is a reference type, reference patterns consume both layers of reference, i.e. they both reset the binding mode and consume the reference type.

Fields

consider_inherited_ref: bool

If true, an inherited reference will be considered when determining whether a reference pattern matches a given type:

• If the underlying type is not a reference, a reference pattern may eat the inherited reference;
• If the underlying type is a reference, a reference pattern matches if it can eat either one of the underlying and inherited references. E.g. a &mut pattern is allowed if either the underlying type is &mut or the inherited reference is &mut.

If false, a reference pattern is only matched against the underlying type. This is false for stable Rust and true for both the ref_pat_eat_one_layer_2024 and ref_pat_eat_one_layer_2024_structural feature gates.

Trait Implementations

impl Clone for InheritedRefMatchRule

fn clone(&self) -> InheritedRefMatchRule

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InheritedRefMatchRule

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

Formats the value using the given formatter.

impl PartialEq for InheritedRefMatchRule

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

impl Eq for InheritedRefMatchRule

impl StructuralPartialEq for InheritedRefMatchRule