Struct DataFrameView 

pub struct DataFrameView {
    inner: NamedList,
    nrow: usize,
}

A validated R data.frame backed by NamedList for O(1) column access.

This type wraps an existing R data.frame SEXP and provides:

• O(1) column access by name via the NamedList index
• O(1) column access by position
• Schema validation via TypedListSpec
• Conversion back to NamedList or raw SEXP

Construction

Use DataFrameView::from_sexp to wrap an existing R data.frame, or NamedList::as_data_frame / List::as_data_frame to promote a list.

Relationship to DataFrame<T>

DataFrame<T> is for creating data frames from row-oriented Rust data (implements IntoDataFrame). DataFrameView is for receiving data frames from R and inspecting their contents.

Fields

inner: NamedList

nrow: usize

Implementations

impl DataFrameView

pub fn from_sexp(sexp: SEXP) -> Result<Self, DataFrameError>

Wrap an existing R data.frame SEXP.

Validates that the object:

1. Is a VECSXP (list)
2. Inherits from "data.frame"
3. Has a names attribute
4. Has extractable row.names for nrow

Errors

Returns DataFrameError if validation fails.

fn from_named_list(inner: NamedList, nrow: usize) -> Self

Construct an DataFrameView from a NamedList and a pre-validated nrow.

This is used internally by NamedList::as_data_frame after validation.

pub fn column<T>(&self, name: &str) -> Option<T>

where T: TryFromSexp<Error = SexpError>,

Get a column by name, converting each element to type T.

Uses O(1) name lookup via the NamedList index.

Returns None if the column name is not found or conversion fails.

Example

let x: Option<Vec<f64>> = df.column("x");

pub fn column_index<T>(&self, idx: usize) -> Option<T>

where T: TryFromSexp<Error = SexpError>,

Get a column by 0-based index, converting to type T.

Returns None if the index is out of bounds or conversion fails.

pub fn column_raw(&self, name: &str) -> Option<SEXP>

Get the raw SEXP for a column by name.

Returns None if the column name is not found.

pub fn nrow(&self) -> usize

Number of rows.

pub fn ncol(&self) -> usize

Number of columns (number of named elements in the list).

pub fn names(&self) -> impl Iterator<Item = &str>

Iterate over column names (unordered, from the HashMap index).

pub fn contains_column(&self, name: &str) -> bool

Check if a column name exists.

pub fn validate( &self, spec: &TypedListSpec, ) -> Result<TypedList, TypedListError>

Validate the data frame’s column types against a TypedListSpec.

This bridges the typed_list validation infrastructure to data frames, allowing schema checks like:

let spec = TypedListSpec::new(vec![
    TypedEntry::required("x", TypeSpec::Numeric(None)),
    TypedEntry::required("y", TypeSpec::Integer(None)),
]);
df.validate(&spec)?;

pub fn into_named_list(self) -> NamedList

Convert to the underlying NamedList, consuming the data frame wrapper.

The SEXP retains its data.frame class attribute.

pub fn as_list(&self) -> List

Get the underlying List.

pub fn as_sexp(&self) -> SEXP

Get the underlying SEXP.

Trait Implementations

impl Debug for DataFrameView

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

Formats the value using the given formatter.

impl IntoR for DataFrameView

type Error = Infallible

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

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.

impl TryFromSexp for DataFrameView

type Error = SexpError

The error type returned when conversion fails.

fn try_from_sexp(sexp: SEXP) -> Result<Self, Self::Error>

Attempt to convert an R SEXP to this Rust type.

unsafe fn try_from_sexp_unchecked(sexp: SEXP) -> Result<Self, Self::Error>

Convert from SEXP without thread safety checks.

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