Enum DataFrameShape 

pub enum DataFrameShape {
    Bare(BuiltDataFrame),
    Split {
        results: SplitResults,
        error: BuiltDataFrame,
    },
    PerVariantList(Vec<(String, BuiltDataFrame)>),
}

Categorical return shape of the data.frame split verbs: IntoDataFrameSplit::into_dataframe_split and the serde helpers vec_to_dataframe_split / result_to_dataframe (feature = "serde").

Carries enough type information that downstream Rust code can match on the variant without dispatching on SEXP type. Convert to a SEXP via the IntoR impl (or just return it from a #[miniextendr] fn), which collapses every variant to the equivalent R value (bare data.frame / named list of data.frames / list(results=, error=)).

GC discipline (rooted by construction, #1265, #1750)

Every frame inside the shape is an owned, GC-rooted BuiltDataFrame, and the SplitResults::None sentinel carries its own Preserved root — so holding a DataFrameShape across R allocations is safe by construction; there is no convert-immediately contract. The IntoR conversion consumes the handles, re-rooting each child in the assembled R value.

Variants

Bare(BuiltDataFrame)

Single data.frame.

Used by:

• into_dataframe_split on a single-variant enum, always.
• serde vec_to_dataframe_split when only one variant is present (and SplitShape::PerVariantList or SplitShape::PerVariantListWithTag is selected — the single-variant short-circuit) or always under SplitShape::Collated.
• serde result_to_dataframe under ResultShape::Auto when every row is Ok, and always under ResultShape::Collated.

Split

list(results = <df | sentinel>, error = df).

Produced only by serde result_to_dataframe: under ResultShape::Auto when at least one Err is present, and always under ResultShape::Split. The split verbs never produce it.

Fields

results: SplitResults

The Ok partition.

error: BuiltDataFrame

The error partition (always present, possibly zero-row).

PerVariantList(Vec<(String, BuiltDataFrame)>)

list(VariantA = df, VariantB = df, …).

Produced by:

• into_dataframe_split on a multi-variant enum, always: one entry per declared variant, in declaration order, keyed by the snake_case variant name. A variant absent from the input is a 0-row frame with that variant’s columns.
• serde vec_to_dataframe_split under SplitShape::PerVariantList / SplitShape::PerVariantListWithTag when the input contains more than one variant. Order matches first-seen order in the input slice.

Trait Implementations

impl IntoR for DataFrameShape

type Error = !

The error type for fallible conversions.

fn try_into_sexp(self) -> Result<SEXP, Self::Error>

Try to convert this value to an R SEXP.

unsafe fn try_into_sexp_unchecked(self) -> Result<SEXP, Self::Error>

Try to convert to SEXP without thread safety checks.

fn into_sexp(self) -> SEXP

where Self: Sized,

Convert this value to an R SEXP, panicking on error.

unsafe fn into_sexp_unchecked(self) -> SEXP

where Self: Sized,

Convert to SEXP without thread safety checks, panicking on error.

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: 40 bytes

Size for each variant:

• Bare: 24 bytes
• Split: 40 bytes
• PerVariantList: 32 bytes