Enum EnumRepr 

#[non_exhaustive]
pub enum EnumRepr {
    Flattened,
    ExternallyTagged,
    InternallyTagged {
        tag: &'static str,
    },
    AdjacentlyTagged {
        tag: &'static str,
        content: &'static str,
    },
}

How enum variants are represented in the serialized format.

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.

Flattened

Variant fields are flattened to the same level as other fields. Also used for #[facet(untagged)] enums where there’s no tag at all. Used by formats like TOML where all fields appear at one level. Example: {"name": "...", "host": "...", "port": 8080}

ExternallyTagged

Variant name is a key, variant content is nested under it. This is the default serde representation for enums. Example: {"name": "...", "Tcp": {"host": "...", "port": 8080}}

InternallyTagged

Tag field is inside the content, alongside variant fields. Used with #[facet(tag = "type")]. Example: {"type": "Tcp", "host": "...", "port": 8080}

Fields

tag: &'static str

The name of the tag field (e.g., “type”)

AdjacentlyTagged

Tag and content are adjacent fields at the same level. Used with #[facet(tag = "t", content = "c")]. Example: {"t": "Tcp", "c": {"host": "...", "port": 8080}}

Fields

tag: &'static str

The name of the tag field (e.g., “t”)

content: &'static str

The name of the content field (e.g., “c”)

Implementations

impl EnumRepr

pub const fn from_shape(shape: &'static Shape) -> Self

Detect the enum representation from a Shape’s attributes.

Returns:

• Flattened if #[facet(untagged)]
• InternallyTagged if #[facet(tag = "...")] without content
• AdjacentlyTagged if both #[facet(tag = "...", content = "...")]
• ExternallyTagged if no attributes (the default enum representation)

Trait Implementations

impl Clone for EnumRepr

fn clone(&self) -> EnumRepr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EnumRepr

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

Formats the value using the given formatter.

impl Default for EnumRepr

fn default() -> EnumRepr

Returns the “default value” for a type.

impl Eq for EnumRepr

impl PartialEq for EnumRepr

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