Struct ToDataFrame 

pub struct ToDataFrame<T: IntoDataFrame>(pub T);

Wrap a value and convert it to an R data.frame via IntoDataFrame when returned from Rust.

Use this wrapper when you want to convert a single value to an R data.frame without making that the default behavior for the type.

Example

struct TimeSeries {
    timestamps: Vec<f64>,
    values: Vec<f64>,
}

impl IntoDataFrame for TimeSeries {
    fn into_data_frame(self) -> List {
        List::from_pairs(vec![
            ("timestamp", self.timestamps),
            ("value", self.values),
        ])
        .set_class_str(&["data.frame"])
        .set_row_names_int(self.timestamps.len())
    }
}

#[miniextendr]
fn make_time_series() -> ToDataFrame<TimeSeries> {
    ToDataFrame(TimeSeries {
        timestamps: vec![1.0, 2.0, 3.0],
        values: vec![10.0, 20.0, 30.0],
    })
}
// In R: make_time_series() returns a data.frame

Tuple Fields

0: T

Trait Implementations

impl<T: Clone + IntoDataFrame> Clone for ToDataFrame<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + IntoDataFrame> Debug for ToDataFrame<T>

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

Formats the value using the given formatter.

impl<T: IntoDataFrame> From<T> for ToDataFrame<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: IntoDataFrame> IntoR for ToDataFrame<T>

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<T: Copy + IntoDataFrame> Copy for ToDataFrame<T>

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.