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 copy 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

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 1 byte

Size for each variant:

• EatOuter: 0 bytes
• EatInner: 0 bytes
• EatBoth: 1 byte