Struct DataFrame 

pub struct DataFrame<T: IntoList> {
    rows: Vec<T>,
}

Convert row-oriented data into a column-oriented R data.frame.

This type collects a sequence of row elements (structs implementing IntoList) and transposes them into column vectors suitable for creating an R data.frame.

Example

use miniextendr_api::{miniextendr, convert::DataFrame};

#[derive(IntoList)]
struct Person {
    name: String,
    age: i32,
    height: f64,
}

#[miniextendr]
fn make_people() -> DataFrame<Person> {
    DataFrame::from_rows(vec![
        Person { name: "Alice".into(), age: 30, height: 165.0 },
        Person { name: "Bob".into(), age: 25, height: 180.0 },
        Person { name: "Carol".into(), age: 35, height: 170.0 },
    ])
}
// In R: make_people() returns a data.frame with 3 rows and columns: name, age, height

Row-oriented to Column-oriented

R data frames are column-oriented (each column is a vector), but data is often produced row-by-row in Rust. DataFrame handles the transposition:

Input (row-oriented):           Output (column-oriented):
Row 1: {name: "A", age: 30}     name column:  ["A", "B", "C"]
Row 2: {name: "B", age: 25}  →  age column:   [30, 25, 35]
Row 3: {name: "C", age: 35}

Fields

rows: Vec<T>

Implementations

impl<T: IntoList> DataFrame<T>

pub fn from_rows(rows: Vec<T>) -> Self

Create a new DataFrame from a vector of row elements.

pub fn new() -> Self

Create an empty DataFrame.

pub fn push(&mut self, row: T)

Add a row to the data frame.

pub fn len(&self) -> usize

Get the number of rows.

pub fn is_empty(&self) -> bool

Check if empty.

Trait Implementations

impl<T: Clone + IntoList> Clone for DataFrame<T>

fn clone(&self) -> DataFrame<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + IntoList> Debug for DataFrame<T>

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

Formats the value using the given formatter.

impl<T: IntoList> Default for DataFrame<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: IntoList> FromIterator<T> for DataFrame<T>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: IntoList> IntoDataFrame for DataFrame<T>

fn into_data_frame(self) -> List

Convert this value into an R data.frame.

#[doc(hidden)]

fn into_named_columns(self) -> Vec<(String, SEXP)>

where Self: Sized,

Extract named column SEXPs from this DataFrame.

impl<T: IntoList> IntoR for DataFrame<T>

IntoR implementation for DataFrame.

This allows DataFrame to be returned directly from #[miniextendr] functions.

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.

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