Struct extendr_api::robj::Robj

pub struct Robj { /* fields omitted */ }

Wrapper for an R S-expression pointer (SEXP).

Create R objects from rust types and iterators:

use extendr_api::prelude::*;
test! {
    // Different ways of making integer scalar 1.
    let non_na : Option<i32> = Some(1);
    let a : Robj = vec![1].into();
    let b = r!(1);
    let c = r!(vec![1]);
    let d = r!(non_na);
    let e = r!([1]);
    assert_eq!(a, b);
    assert_eq!(a, c);
    assert_eq!(a, d);
    assert_eq!(a, e);

    // Different ways of making boolean scalar TRUE.
    let a : Robj = true.into();
    let b = r!(TRUE);
    assert_eq!(a, b);

    // Create a named list
    let a = list!(a = 1, b = "x");
    assert_eq!(a.len(), 2);

    // Use an iterator (like 1:10)
    let a = r!(1 ..= 10);
    assert_eq!(a, r!([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]));

    // Use an iterator (like (1:10)[(1:10) %% 3 == 0])
    let a = (1 ..= 10).filter(|v| v % 3 == 0).collect_robj();
    assert_eq!(a, r!([3, 6, 9]));
}

Convert to/from Rust vectors.

use extendr_api::prelude::*;
test! {
    let a : Robj = r!(vec![1., 2., 3., 4.]);
    let b : Vec<f64> = a.as_real_vector().unwrap();
    assert_eq!(a.len(), 4);
    assert_eq!(b, vec![1., 2., 3., 4.]);
}

Iterate over names and values.

use extendr_api::prelude::*;
test! {
    let abc = list!(a = 1, b = "x", c = vec![1, 2]);
    let names : Vec<_> = abc.names().unwrap().collect();
    let names_and_values : Vec<_> = abc.as_list().unwrap().iter().collect();
    assert_eq!(names, vec!["a", "b", "c"]);
    assert_eq!(names_and_values, vec![("a", r!(1)), ("b", r!("x")), ("c", r!(vec![1, 2]))]);
}

NOTE: as much as possible we wish to make this object safe (ie. no segfaults).

If you avoid using unsafe functions it is more likely that you will avoid panics and segfaults. We will take great trouble to ensure that this is true.

Implementations

impl Robj

pub fn from_sexp(sexp: SEXP) -> Self

impl Robj

pub fn is_na(&self) -> bool

Is this object is an NA scalar? Works for character, integer and numeric types.

use extendr_api::prelude::*;
test! {

assert_eq!(r!(NA_INTEGER).is_na(), true);
assert_eq!(r!(NA_REAL).is_na(), true);
assert_eq!(r!(NA_STRING).is_na(), true);
}

pub fn as_integer_slice<'a>(&self) -> Option<&'a [i32]>

Get a read-only reference to the content of an integer vector.

use extendr_api::prelude::*;
test! {

let robj = r!([1, 2, 3]);
assert_eq!(robj.as_integer_slice().unwrap(), [1, 2, 3]);
}

pub fn as_integers(&self) -> Option<Integers>

Convert an Robj into Integers.

pub fn as_integer_vector(&self) -> Option<Vec<i32>>

Get a Vec copied from the object.

use extendr_api::prelude::*;
test! {

let robj = r!([1, 2, 3]);
assert_eq!(robj.as_integer_slice().unwrap(), vec![1, 2, 3]);
}

pub fn as_logical_slice(&self) -> Option<&[Rbool]>

Get a read-only reference to the content of a logical vector using the tri-state Rbool. Returns None if not a logical vector.

use extendr_api::prelude::*;
test! {
    let robj = r!([TRUE, FALSE]);
    assert_eq!(robj.as_logical_slice().unwrap(), [TRUE, FALSE]);
}

pub fn as_logical_vector(&self) -> Option<Vec<Rbool>>

Get a Vec copied from the object using the tri-state Rbool. Returns None if not a logical vector.

use extendr_api::prelude::*;
test! {
    let robj = r!([TRUE, FALSE]);
    assert_eq!(robj.as_logical_vector().unwrap(), vec![TRUE, FALSE]);
}

pub fn as_logical_iter(&self) -> Option<impl Iterator<Item = &Rbool>>

Get an iterator over logical elements of this slice.

use extendr_api::prelude::*;
test! {
    let robj = r!([TRUE, FALSE, NA_LOGICAL]);
    let mut num_na = 0;
    for val in robj.as_logical_iter().unwrap() {
      if val.is_na() {
          num_na += 1;
      }
    }
    assert_eq!(num_na, 1);
}

pub fn as_real_slice(&self) -> Option<&[f64]>

Get a read-only reference to the content of a double vector. Note: the slice may contain NaN or NA values. We may introduce a “Real” type to handle this like the Rbool type.

use extendr_api::prelude::*;
test! {
    let robj = r!([Some(1.), None, Some(3.)]);
    let mut tot = 0.;
    for val in robj.as_real_slice().unwrap() {
      if !val.is_na() {
        tot += val;
      }
    }
    assert_eq!(tot, 4.);
}

pub fn as_real_iter(&self) -> Option<impl Iterator<Item = &f64>>

Get an iterator over real elements of this slice.

use extendr_api::prelude::*;
test! {
    let robj = r!([1., 2., 3.]);
    let mut tot = 0.;
    for val in robj.as_real_iter().unwrap() {
      if !val.is_na() {
        tot += val;
      }
    }
    assert_eq!(tot, 6.);
}

pub fn as_real_vector(&self) -> Option<Vec<f64>>

Get a Vec copied from the object.

use extendr_api::prelude::*;
test! {
    let robj = r!([1., 2., 3.]);
    assert_eq!(robj.as_real_vector().unwrap(), vec![1., 2., 3.]);
}

pub fn as_raw_slice(&self) -> Option<&[u8]>

Get a read-only reference to the content of an integer or logical vector.

use extendr_api::prelude::*;
test! {
    let robj = r!(Raw::from_bytes(&[1, 2, 3]));
    assert_eq!(robj.as_raw_slice().unwrap(), &[1, 2, 3]);
}

pub fn as_integer_slice_mut(&mut self) -> Option<&mut [i32]>

Get a read-write reference to the content of an integer or logical vector. Note that rust slices are 0-based so slice[1] is the middle value.

use extendr_api::prelude::*;
test! {
    let mut robj = r!([1, 2, 3]);
    let slice : & mut [i32] = robj.as_integer_slice_mut().unwrap();
    slice[1] = 100;
    assert_eq!(robj, r!([1, 100, 3]));
}

pub fn as_real_slice_mut(&mut self) -> Option<&mut [f64]>

Get a read-write reference to the content of a double vector. Note that rust slices are 0-based so slice[1] is the middle value.

use extendr_api::prelude::*;
test! {
    let mut robj = r!([1.0, 2.0, 3.0]);
    let slice = robj.as_real_slice_mut().unwrap();
    slice[1] = 100.0;
    assert_eq!(robj, r!([1.0, 100.0, 3.0]));
}

pub fn as_raw_slice_mut(&mut self) -> Option<&mut [u8]>

Get a read-write reference to the content of a raw vector.

use extendr_api::prelude::*;
test! {
    let mut robj = r!(Raw::from_bytes(&[1, 2, 3]));
    let slice = robj.as_raw_slice_mut().unwrap();
    slice[1] = 100;
    assert_eq!(robj, r!(Raw::from_bytes(&[1, 100, 3])));
}

pub fn as_string_vector(&self) -> Option<Vec<String>>

Get a vector of owned strings. Owned strings have long lifetimes, but are much slower than references.

use extendr_api::prelude::*;
test! {
   let robj1 = Robj::from("xyz");
   assert_eq!(robj1.as_string_vector(), Some(vec!["xyz".to_string()]));
   let robj2 = Robj::from(1);
   assert_eq!(robj2.as_string_vector(), None);
}

pub fn as_str_vector(&self) -> Option<Vec<&str>>

Get a vector of string references. String references (&str) are faster, but have short lifetimes.

use extendr_api::prelude::*;
test! {
   let robj1 = Robj::from("xyz");
   assert_eq!(robj1.as_str_vector(), Some(vec!["xyz"]));
   let robj2 = Robj::from(1);
   assert_eq!(robj2.as_str_vector(), None);
}

pub fn as_str<'a>(&self) -> Option<&'a str>

Get a read-only reference to a scalar string type.

use extendr_api::prelude::*;
test! {
   let robj1 = Robj::from("xyz");
   let robj2 = Robj::from(1);
   assert_eq!(robj1.as_str(), Some("xyz"));
   assert_eq!(robj2.as_str(), None);
}

pub fn as_integer(&self) -> Option<i32>

Get a scalar integer.

use extendr_api::prelude::*;
test! {
   let robj1 = Robj::from("xyz");
   let robj2 = Robj::from(1);
   let robj3 = Robj::from(NA_INTEGER);
   assert_eq!(robj1.as_integer(), None);
   assert_eq!(robj2.as_integer(), Some(1));
   assert_eq!(robj3.as_integer(), None);
}

pub fn as_real(&self) -> Option<f64>

Get a scalar real.

use extendr_api::prelude::*;
test! {
   let robj1 = Robj::from(1);
   let robj2 = Robj::from(1.);
   let robj3 = Robj::from(NA_REAL);
   assert_eq!(robj1.as_real(), None);
   assert_eq!(robj2.as_real(), Some(1.));
   assert_eq!(robj3.as_real(), None);
}

pub fn as_bool(&self) -> Option<bool>

Get a scalar rust boolean.

use extendr_api::prelude::*;
test! {
   let robj1 = Robj::from(TRUE);
   let robj2 = Robj::from(1.);
   let robj3 = Robj::from(NA_LOGICAL);
   assert_eq!(robj1.as_bool(), Some(true));
   assert_eq!(robj2.as_bool(), None);
   assert_eq!(robj3.as_bool(), None);
}

pub fn as_logical(&self) -> Option<Rbool>

Get a scalar boolean as a tri-boolean Rbool value.

use extendr_api::prelude::*;
test! {
   let robj1 = Robj::from(TRUE);
   let robj2 = Robj::from([TRUE, FALSE]);
   let robj3 = Robj::from(NA_LOGICAL);
   assert_eq!(robj1.as_logical(), Some(TRUE));
   assert_eq!(robj2.as_logical(), None);
   assert_eq!(robj3.as_logical().unwrap().is_na(), true);
}

Trait Implementations

impl<Rhs> Add<Rhs> for Robj where
    Rhs: Into<Robj>, 

fn add(self, rhs: Rhs) -> Self::Output

Add two R objects, consuming the left hand side. panics on error.

use extendr_api::prelude::*;
test! {

// lhs and rhs get dropped here
let lhs = r!([1, 2]);
let rhs = r!([10, 20]);
assert_eq!(lhs + rhs, r!([11, 22]));

// lhs gets dropped and rhs is a temporary object.
let lhs = r!([1, 2]);
assert_eq!(lhs + 1000, r!([1001, 1002]));

// Only lhs gets dropped.
let lhs = r!([1, 2]);
let rhs = r!([10, 20]);
assert_eq!(lhs + &rhs, r!([11, 22]));
}

type Output = Robj

The resulting type after applying the + operator.

impl AsStrIter for Robj

fn as_str_iter(&self) -> Option<StrIter>

Get an iterator over a string vector. Returns None if the object is not a string vector but works for factors.

impl<'a> AsTypedSlice<'a, Complex<f64>> for Robj where
    Self: 'a, 

fn as_typed_slice(&self) -> Option<&'a [c64]>

fn as_typed_slice_mut(&mut self) -> Option<&'a mut [c64]>

impl<'a> AsTypedSlice<'a, Rbool> for Robj where
    Self: 'a, 

fn as_typed_slice(&self) -> Option<&'a [Rbool]>

fn as_typed_slice_mut(&mut self) -> Option<&'a mut [Rbool]>

impl<'a> AsTypedSlice<'a, Rcomplex> for Robj where
    Self: 'a, 

fn as_typed_slice(&self) -> Option<&'a [Rcomplex]>

fn as_typed_slice_mut(&mut self) -> Option<&'a mut [Rcomplex]>

impl<'a> AsTypedSlice<'a, Rcplx> for Robj where
    Self: 'a, 

fn as_typed_slice(&self) -> Option<&'a [Rcplx]>

fn as_typed_slice_mut(&mut self) -> Option<&'a mut [Rcplx]>

impl<'a> AsTypedSlice<'a, Rfloat> for Robj where
    Self: 'a, 

fn as_typed_slice(&self) -> Option<&'a [Rfloat]>

fn as_typed_slice_mut(&mut self) -> Option<&'a mut [Rfloat]>

impl<'a> AsTypedSlice<'a, Rint> for Robj where
    Self: 'a, 

fn as_typed_slice(&self) -> Option<&'a [Rint]>

fn as_typed_slice_mut(&mut self) -> Option<&'a mut [Rint]>

impl<'a> AsTypedSlice<'a, Robj> for Robj where
    Self: 'a, 

fn as_typed_slice(&self) -> Option<&'a [Robj]>

fn as_typed_slice_mut(&mut self) -> Option<&'a mut [Robj]>

impl<'a> AsTypedSlice<'a, Rstr> for Robj where
    Self: 'a, 

fn as_typed_slice(&self) -> Option<&'a [Rstr]>

fn as_typed_slice_mut(&mut self) -> Option<&'a mut [Rstr]>

impl<'a> AsTypedSlice<'a, f64> for Robj where
    Self: 'a, 

fn as_typed_slice(&self) -> Option<&'a [f64]>

fn as_typed_slice_mut(&mut self) -> Option<&'a mut [f64]>

impl<'a> AsTypedSlice<'a, i32> for Robj where
    Self: 'a, 

fn as_typed_slice(&self) -> Option<&'a [i32]>

fn as_typed_slice_mut(&mut self) -> Option<&'a mut [i32]>

impl<'a> AsTypedSlice<'a, u8> for Robj where
    Self: 'a, 

fn as_typed_slice(&self) -> Option<&'a [u8]>

fn as_typed_slice_mut(&mut self) -> Option<&'a mut [u8]>

impl Attributes for Robj

fn get_attrib<'a, N>(&self, name: N) -> Option<Robj> where
    Self: 'a,
    Robj: From<N> + 'a, 

Get a specific attribute as a borrowed robj if it exists.

fn has_attrib<'a, N>(&self, name: N) -> bool where
    Self: 'a,
    Robj: From<N> + 'a, 

Return true if an attribute exists.

fn set_attrib<N, V>(&self, name: N, value: V) -> Result<Robj> where
    N: Into<Robj>,
    V: Into<Robj>, 

Set a specific attribute and return the object.

fn names(&self) -> Option<StrIter>

Get the names attribute as a string iterator if one exists.

fn has_names(&self) -> bool

Return true if this object has names.

fn set_names<T>(&mut self, names: T) -> Result<Robj> where
    T: IntoIterator,
    T::IntoIter: ExactSizeIterator,
    T::Item: ToVectorValue + AsRef<str>, 

Set the names attribute from a string iterator.

fn dim(&self) -> Option<Integers>

Get the dim attribute as an integer iterator if one exists.

fn dimnames(&self) -> Option<ListIter>

Get the dimnames attribute as a list iterator if one exists.

fn class(&self) -> Option<StrIter>

Get the class attribute as a string iterator if one exists.

fn set_class<T>(&self, class: T) -> Result<Robj> where
    T: IntoIterator,
    T::IntoIter: ExactSizeIterator,
    T::Item: ToVectorValue + AsRef<str>, 

Set the class attribute from a string iterator, returning a new object.

fn inherits(&self, classname: &str) -> bool

Return true if this class inherits this class.

fn levels(&self) -> Option<StrIter>

Get the levels attribute as a string iterator if one exists.

impl Clone for Robj

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Conversions for Robj

fn as_symbol(&self) -> Option<Symbol>

Convert a symbol object to a Symbol wrapper.

fn as_char(&self) -> Option<Rstr>

Convert a CHARSXP object to a Rstr wrapper.

fn as_raw(&self) -> Option<Raw>

Convert a raw object to a Rstr wrapper.

fn as_language(&self) -> Option<Language>

Convert a language object to a Language wrapper.

fn as_pairlist(&self) -> Option<Pairlist>

Convert a pair list object (LISTSXP) to a Pairlist wrapper.

fn as_list(&self) -> Option<List>

Convert a list object (VECSXP) to a List wrapper.

fn as_expressions(&self) -> Option<Expressions>

Convert an expression object (EXPRSXP) to a Expr wrapper.

fn as_environment(&self) -> Option<Environment>

Convert an environment object (ENVSXP) to a Env wrapper.

fn as_function(&self) -> Option<Function>

Convert a function object (CLOSXP) to a Function wrapper.

fn as_promise(&self) -> Option<Promise>

Get a wrapper for a promise.

impl Debug for Robj

Implement {:?} formatting.

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

Formats the value using the given formatter.

impl Default for Robj

fn default() -> Self

Returns the “default value” for a type.

impl<Rhs> Div<Rhs> for Robj where
    Rhs: Into<Robj>, 

fn div(self, rhs: Rhs) -> Self::Output

Divide two R objects, consuming the left hand side. panics on error.

use extendr_api::prelude::*;
test! {

// lhs and rhs get dropped here
let lhs = r!([10.0, 20.0]);
let rhs = r!([1.0, 2.0]);
assert_eq!(lhs / rhs, r!([10.0, 10.0]));

// lhs gets dropped and rhs is a temporary object.
let lhs = r!([10.0, 30.0]);
assert_eq!(lhs / 10.0, r!([1.0, 3.0]));

// Only lhs gets dropped.
let lhs = r!([10.0, 20.0]);
let rhs = r!([1.0, 2.0]);
assert_eq!(lhs / &rhs, r!([10.0, 10.0]));
}

type Output = Robj

The resulting type after applying the / operator.

impl Drop for Robj

Release any owned objects.

fn drop(&mut self)

Executes the destructor for this type.

impl Eval for Robj

fn eval(&self) -> Result<Robj>

Evaluate the expression in R and return an error or an R object.

fn eval_with_env(&self, env: &Environment) -> Result<Robj>

Evaluate the expression in R and return an error or an R object.

fn eval_blind(&self) -> Robj

Evaluate the expression and return NULL or an R object.

impl From<&'_ Robj> for Robj

Convert an Robj reference into a borrowed Robj.

fn from(val: &Robj) -> Self

Performs the conversion.

impl<'a, T> From<&'a [T]> for Robj where
    Self: 'a,
    T: 'a,
    &'a T: ToVectorValue, 

fn from(val: &'a [T]) -> Self

Performs the conversion.

impl<'a, T> From<[T; 1]> for Robj where
    Self: 'a,
    T: Clone + 'a,
    T: ToVectorValue, 

fn from(val: [T; 1]) -> Self

Performs the conversion.

impl<'a, T> From<[T; 10]> for Robj where
    Self: 'a,
    T: Clone + 'a,
    T: ToVectorValue, 

fn from(val: [T; 10]) -> Self

Performs the conversion.

impl<'a, T> From<[T; 11]> for Robj where
    Self: 'a,
    T: Clone + 'a,
    T: ToVectorValue, 

fn from(val: [T; 11]) -> Self

Performs the conversion.

impl<'a, T> From<[T; 12]> for Robj where
    Self: 'a,
    T: Clone + 'a,
    T: ToVectorValue, 

fn from(val: [T; 12]) -> Self

Performs the conversion.

impl<'a, T> From<[T; 13]> for Robj where
    Self: 'a,
    T: Clone + 'a,
    T: ToVectorValue, 

fn from(val: [T; 13]) -> Self

Performs the conversion.

impl<'a, T> From<[T; 14]> for Robj where
    Self: 'a,
    T: Clone + 'a,
    T: ToVectorValue, 

fn from(val: [T; 14]) -> Self

Performs the conversion.

impl<'a, T> From<[T; 15]> for Robj where
    Self: 'a,
    T: Clone + 'a,
    T: ToVectorValue, 

fn from(val: [T; 15]) -> Self

Performs the conversion.

impl<'a, T> From<[T; 16]> for Robj where
    Self: 'a,
    T: Clone + 'a,
    T: ToVectorValue, 

fn from(val: [T; 16]) -> Self

Performs the conversion.

impl<'a, T> From<[T; 17]> for Robj where
    Self: 'a,
    T: Clone + 'a,
    T: ToVectorValue, 

fn from(val: [T; 17]) -> Self

Performs the conversion.

impl<'a, T> From<[T; 18]> for Robj where
    Self: 'a,
    T: Clone + 'a,
    T: ToVectorValue, 

fn from(val: [T; 18]) -> Self

Performs the conversion.

impl<'a, T> From<[T; 19]> for Robj where
    Self: 'a,
    T: Clone + 'a,
    T: ToVectorValue, 

fn from(val: [T; 19]) -> Self

Performs the conversion.

impl<'a, T> From<[T; 2]> for Robj where
    Self: 'a,
    T: Clone + 'a,
    T: ToVectorValue, 

fn from(val: [T; 2]) -> Self

Performs the conversion.

impl<'a, T> From<[T; 3]> for Robj where
    Self: 'a,
    T: Clone + 'a,
    T: ToVectorValue, 

fn from(val: [T; 3]) -> Self

Performs the conversion.

impl<'a, T> From<[T; 4]> for Robj where
    Self: 'a,
    T: Clone + 'a,
    T: ToVectorValue, 

fn from(val: [T; 4]) -> Self

Performs the conversion.

impl<'a, T> From<[T; 5]> for Robj where
    Self: 'a,
    T: Clone + 'a,
    T: ToVectorValue, 

fn from(val: [T; 5]) -> Self

Performs the conversion.

impl<'a, T> From<[T; 6]> for Robj where
    Self: 'a,
    T: Clone + 'a,
    T: ToVectorValue, 

fn from(val: [T; 6]) -> Self

Performs the conversion.

impl<'a, T> From<[T; 7]> for Robj where
    Self: 'a,
    T: Clone + 'a,
    T: ToVectorValue, 

fn from(val: [T; 7]) -> Self

Performs the conversion.

impl<'a, T> From<[T; 8]> for Robj where
    Self: 'a,
    T: Clone + 'a,
    T: ToVectorValue, 

fn from(val: [T; 8]) -> Self

Performs the conversion.

impl<'a, T> From<[T; 9]> for Robj where
    Self: 'a,
    T: Clone + 'a,
    T: ToVectorValue, 

fn from(val: [T; 9]) -> Self

Performs the conversion.

impl From<()> for Robj

Convert a null to an Robj.

fn from(_: ()) -> Self

Performs the conversion.

impl From<Altrep> for Robj

fn from(val: Altrep) -> Self

Make an robj from a wrapper.

impl From<Arg> for Robj

fn from(val: Arg) -> Self

Performs the conversion.

impl From<Complexes> for Robj

fn from(val: Complexes) -> Self

Make an robj from a wrapper.

impl From<Doubles> for Robj

fn from(val: Doubles) -> Self

Make an robj from a wrapper.

impl From<Environment> for Robj

fn from(val: Environment) -> Self

Make an robj from a wrapper.

impl From<Expressions> for Robj

fn from(val: Expressions) -> Self

Make an robj from a wrapper.

impl<T: Any + Debug> From<ExternalPtr<T>> for Robj

fn from(val: ExternalPtr<T>) -> Self

Performs the conversion.

impl From<Func> for Robj

fn from(val: Func) -> Self

Performs the conversion.

impl From<Function> for Robj

fn from(val: Function) -> Self

Make an robj from a wrapper.

impl From<Impl> for Robj

fn from(val: Impl) -> Self

Performs the conversion.

impl From<Integers> for Robj

fn from(val: Integers) -> Self

Make an robj from a wrapper.

impl From<Language> for Robj

fn from(val: Language) -> Self

Make an robj from a wrapper.

impl From<List> for Robj

fn from(val: List) -> Self

Make an robj from a wrapper.

impl From<ListIter> for Robj

fn from(iter: ListIter) -> Self

You can return a ListIter from a function.

use extendr_api::prelude::*;
test! {
    let listiter = list!(1, 2).values();
    assert_eq!(Robj::from(listiter), Robj::from(list!(1, 2)));
}

impl From<Logicals> for Robj

fn from(val: Logicals) -> Self

Make an robj from a wrapper.

impl From<Metadata> for Robj

fn from(val: Metadata) -> Self

Performs the conversion.

impl<T> From<Nullable<T>> for Robj where
    T: Into<Robj>, 

fn from(val: Nullable<T>) -> Self

Convert a rust object to NULL or another type.

use extendr_api::prelude::*;
test! {
    assert_eq!(r!(Nullable::<i32>::Null), r!(NULL));
    assert_eq!(r!(Nullable::<i32>::NotNull(1)), r!(1));
}

impl From<Pairlist> for Robj

fn from(val: Pairlist) -> Self

Make an robj from a wrapper.

impl From<PairlistIter> for Robj

fn from(iter: PairlistIter) -> Self

You can return a PairlistIter from a function.

impl From<Primitive> for Robj

fn from(val: Primitive) -> Self

Make an robj from a wrapper.

impl From<Promise> for Robj

fn from(val: Promise) -> Self

Make an robj from a wrapper.

impl<T, D> From<RArray<T, D>> for Robj

fn from(array: RArray<T, D>) -> Self

Convert a column, matrix or matrix3d to an Robj.

impl<T> From<Range<T>> for Robj where
    Range<T>: RobjItertools,
    <Range<T> as Iterator>::Item: ToVectorValue,
    T: ToVectorValue, 

fn from(val: Range<T>) -> Self

Performs the conversion.

impl<T> From<RangeInclusive<T>> for Robj where
    RangeInclusive<T>: RobjItertools,
    <RangeInclusive<T> as Iterator>::Item: ToVectorValue,
    T: ToVectorValue, 

fn from(val: RangeInclusive<T>) -> Self

Performs the conversion.

impl From<Raw> for Robj

fn from(val: Raw) -> Self

Make an robj from a wrapper.

impl<T> From<Result<T, Error>> for Robj where
    T: Into<Robj>, 

Convert a Result to an Robj. This is used to allow functions to use the ? operator and return Result.

Panics if there is an error.

use extendr_api::prelude::*;
fn my_func() -> Result<f64> {
    Ok(1.0)
}

test! {
    assert_eq!(r!(my_func()), r!(1.0));
}

fn from(res: Result<T>) -> Self

Performs the conversion.

impl From<Rfloat> for Robj

fn from(value: Rfloat) -> Self

Performs the conversion.

impl From<Rint> for Robj

fn from(value: Rint) -> Self

Performs the conversion.

impl From<Rstr> for Robj

fn from(val: Rstr) -> Self

Make an robj from a wrapper.

impl From<S4> for Robj

fn from(val: S4) -> Self

Make an robj from a wrapper.

impl From<Strings> for Robj

fn from(val: Strings) -> Self

Make an robj from a wrapper.

impl From<Symbol> for Robj

fn from(val: Symbol) -> Self

Make an robj from a wrapper.

impl<T> From<T> for Robj where
    T: ToVectorValue, 

fn from(scalar: T) -> Self

Performs the conversion.

impl<'a> From<Vec<Robj, Global>> for Robj

fn from(val: Vec<Robj>) -> Self

Convert a vector of Robj into a list.

impl<'a, T> From<Vec<T, Global>> for Robj where
    Self: 'a,
    T: Clone + 'a,
    T: ToVectorValue, 

fn from(val: Vec<T>) -> Self

Performs the conversion.

impl<'a> FromRobj<'a> for Robj

Pass-through Robj conversion, essentially a clone.

fn from_robj(robj: &'a Robj) -> Result<Self, &'static str>

impl GetSexp for Robj

unsafe fn get(&self) -> SEXP

Get a copy of the underlying SEXP.

fn as_robj(&self) -> &Robj

Get a reference to a Robj for this type.

fn as_robj_mut(&mut self) -> &mut Robj

Get a mutable reference to a Robj for this type.

impl Length for Robj

fn len(&self) -> usize

Get the extended length of the object.

fn is_empty(&self) -> bool

Returns true if the Robj contains no elements.

impl MatrixConversions for Robj

fn as_column<'a, E: 'a>(&self) -> Option<RColumn<E>> where
    Robj: AsTypedSlice<'a, E>, 

fn as_matrix<'a, E: 'a>(&self) -> Option<RMatrix<E>> where
    Robj: AsTypedSlice<'a, E>, 

fn as_matrix3d<'a, E: 'a>(&self) -> Option<RMatrix3D<E>> where
    Robj: AsTypedSlice<'a, E>, 

impl<Rhs> Mul<Rhs> for Robj where
    Rhs: Into<Robj>, 

fn mul(self, rhs: Rhs) -> Self::Output

Multiply two R objects, consuming the left hand side. panics on error.

use extendr_api::prelude::*;
test! {

// lhs and rhs get dropped here
let lhs = r!([10.0, 20.0]);
let rhs = r!([1.0, 2.0]);
assert_eq!(lhs * rhs, r!([10.0, 40.0]));

// lhs gets dropped and rhs is a temporary object.
let lhs = r!([1.0, 2.0]);
assert_eq!(lhs * 10.0, r!([10.0, 20.0]));

// Only lhs gets dropped.
let lhs = r!([10.0, 20.0]);
let rhs = r!([1.0, 2.0]);
assert_eq!(lhs * &rhs, r!([10.0, 40.0]));
}

type Output = Robj

The resulting type after applying the * operator.

impl Operators for Robj

fn dollar<T>(&self, symbol: T) -> Result<Robj> where
    T: AsRef<str>, 

Do the equivalent of x$y

fn slice<T>(&self, rhs: T) -> Result<Robj> where
    T: Into<Robj>, 

Do the equivalent of x[y]

fn index<T>(&self, rhs: T) -> Result<Robj> where
    T: Into<Robj>, 

Do the equivalent of x[[y]]

fn tilde<T>(&self, rhs: T) -> Result<Robj> where
    T: Into<Robj>, 

Do the equivalent of x ~ y

fn double_colon<T>(&self, rhs: T) -> Result<Robj> where
    T: Into<Robj>, 

Do the equivalent of x :: y

fn call(&self, args: Pairlist) -> Result<Robj>

Do the equivalent of x(a, b, c)

impl<'a> PartialEq<[f64]> for Robj

Compare equality with slices of double.

fn eq(&self, rhs: &[f64]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<[i32]> for Robj

Compare equality with integer slices.

fn eq(&self, rhs: &[i32]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Robj> for Robj

Compare equality with two Robjs.

fn eq(&self, rhs: &Robj) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<str> for Robj

Compare equality with strings.

fn eq(&self, rhs: &str) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Rinternals for Robj

fn is_null(&self) -> bool

Return true if this is the null object.

fn is_symbol(&self) -> bool

Return true if this is a symbol.

fn is_logical(&self) -> bool

Return true if this is a boolean (logical) vector

fn is_real(&self) -> bool

Return true if this is a real (f64) vector.

fn is_complex(&self) -> bool

Return true if this is a complex vector.

fn is_expressions(&self) -> bool

Return true if this is an expression.

fn is_environment(&self) -> bool

Return true if this is an environment.

fn is_promise(&self) -> bool

Return true if this is an environment.

fn is_string(&self) -> bool

Return true if this is a string.

fn is_object(&self) -> bool

Return true if this is an object (ie. has a class attribute).

fn is_s4(&self) -> bool

Return true if this is a S4 object.

fn is_external_pointer(&self) -> bool

Return true if this is an expression.

fn get_current_srcref(val: i32) -> Robj

Get the source ref.

fn get_src_filename(&self) -> Robj

Get the source filename.

fn as_character_vector(&self) -> Robj

Convert to a string vector.

fn coerce_vector(&self, sexptype: u32) -> Robj

Convert to vectors of many kinds.

fn pair_to_vector_list(&self) -> Robj

Convert a pairlist (LISTSXP) to a vector list (VECSXP).

fn vector_to_pair_list(&self) -> Robj

Convert a vector list (VECSXP) to a pair list (LISTSXP)

fn as_character_factor(&self) -> Robj

Convert a factor to a string vector.

fn alloc_matrix(sexptype: SEXPTYPE, rows: i32, cols: i32) -> Robj

Allocate a matrix object.

fn duplicate(&self) -> Robj

Do a deep copy of this object. Note that clone() only adds a reference.

fn find_function<K: TryInto<Symbol, Error = Error>>(
    &self,
    key: K
) -> Result<Robj>

Find a function in an environment ignoring other variables.

fn find_var<K: TryInto<Symbol, Error = Error>>(&self, key: K) -> Result<Robj>

Find a variable in an environment.

fn eval_promise(&self) -> Result<Robj>

If this object is a promise, evaluate it, otherwise return the object.

fn ncols(&self) -> usize

Number of columns of a matrix

fn nrows(&self) -> usize

Number of rows of a matrix

fn xlengthgets(&self, new_len: usize) -> Result<Robj>

Copy a vector and resize it. See. https://github.com/hadley/r-internals/blob/master/vectors.md

fn alloc_vector(sexptype: u32, len: usize) -> Robj

Allocated an owned object of a certain type.

fn conformable(a: &Robj, b: &Robj) -> bool

Return true if two arrays have identical dims.

fn is_array(&self) -> bool

Return true if this is an array.

fn is_factor(&self) -> bool

Return true if this is factor.

fn is_frame(&self) -> bool

Return true if this is a data frame.

fn is_function(&self) -> bool

Return true if this is a function or a primitive (CLOSXP, BUILTINSXP or SPECIALSXP)

fn is_integer(&self) -> bool

Return true if this is an integer vector (INTSXP) but not a factor.

fn is_language(&self) -> bool

Return true if this is a language object (LANGSXP).

fn is_pairlist(&self) -> bool

Return true if this is NILSXP or LISTSXP.

fn is_matrix(&self) -> bool

Return true if this is a matrix.

fn is_list(&self) -> bool

Return true if this is NILSXP or VECSXP.

fn is_number(&self) -> bool

Return true if this is INTSXP, LGLSXP or REALSXP but not a factor.

fn is_primitive(&self) -> bool

Return true if this is a primitive function BUILTINSXP, SPECIALSXP.

fn is_ts(&self) -> bool

Return true if this is a time series vector (see tsp).

fn is_user_binop(&self) -> bool

Return true if this is a user defined binop.

fn is_valid_string(&self) -> bool

Return true if this is a valid string.

fn is_valid_string_f(&self) -> bool

Return true if this is a valid string.

fn is_vector(&self) -> bool

Return true if this is a vector.

fn is_vector_atomic(&self) -> bool

Return true if this is an atomic vector.

fn is_vector_list(&self) -> bool

Return true if this is a vector list.

fn is_vectorizable(&self) -> bool

Return true if this is can be made into a vector.

fn is_raw(&self) -> bool

Return true if this is RAWSXP.

fn is_char(&self) -> bool

Return true if this is CHARSXP.

fn is_missing_arg(&self) -> bool

fn is_unbound_value(&self) -> bool

fn is_package_env(&self) -> bool

fn package_env_name(&self) -> Robj

fn is_namespace_env(&self) -> bool

fn namespace_env_spec(&self) -> Robj

fn is_altrep(&self) -> bool

Returns true if this is an ALTREP object.

fn is_altinteger(&self) -> bool

Returns true if this is an integer ALTREP object.

fn is_altreal(&self) -> bool

Returns true if this is an real ALTREP object.

fn is_altlogical(&self) -> bool

Returns true if this is an logical ALTREP object.

fn is_altraw(&self) -> bool

Returns true if this is a raw ALTREP object.

fn is_altstring(&self) -> bool

Returns true if this is an integer ALTREP object.

fn deparse(&self) -> Result<String>

Generate a text representation of this object.

impl Serialize for Robj

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl Slices for Robj

unsafe fn as_typed_slice_raw<T>(&self) -> &[T]

Get an immutable slice to this object’s data.

unsafe fn as_typed_slice_raw_mut<T>(&mut self) -> &mut [T]

Get a mutable slice to this object’s data.

impl<Rhs> Sub<Rhs> for Robj where
    Rhs: Into<Robj>, 

fn sub(self, rhs: Rhs) -> Self::Output

Subtract two R objects, consuming the left hand side. panics on error.

use extendr_api::prelude::*;
test! {

// lhs and rhs get dropped here
let lhs = r!([10, 20]);
let rhs = r!([1, 2]);
assert_eq!(lhs - rhs, r!([9, 18]));

// lhs gets dropped and rhs is a temporary object.
let lhs = r!([1000, 2000]);
assert_eq!(lhs - 1, r!([999, 1999]));

// Only lhs gets dropped.
let lhs = r!([10, 20]);
let rhs = r!([1, 2]);
assert_eq!(lhs - &rhs, r!([9, 18]));
}

type Output = Robj

The resulting type after applying the - operator.

impl<A, S, D> TryFrom<&'_ ArrayBase<S, D>> for Robj where
    S: Data<Elem = A>,
    A: Copy + ToVectorValue,
    D: Dimension, 

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: &ArrayBase<S, D>) -> Result<Self>

Performs the conversion.

impl TryFrom<Robj> for u8

fn try_from(robj: Robj) -> Result<Self>

Convert a numeric object to an integer value.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for u16

fn try_from(robj: Robj) -> Result<Self>

Convert a numeric object to an integer value.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Rbool

fn try_from(robj: Robj) -> Result<Self>

Convert an LGLSXP object into a Rbool (tri-state boolean). Use value.is_na() to detect NA values.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for bool

fn try_from(robj: Robj) -> Result<Self>

Convert an LGLSXP object into a boolean. NAs are not allowed.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for &str

fn try_from(robj: Robj) -> Result<Self>

Convert a scalar STRSXP object into a string slice. NAs are not allowed.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for String

fn try_from(robj: Robj) -> Result<Self>

Convert an scalar STRSXP object into a String. Note: Unless you plan to store the result, use a string slice instead. NAs are not allowed.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Vec<i32>

fn try_from(robj: Robj) -> Result<Self>

Convert an INTSXP object into a vector of i32 (integer). Note: Unless you plan to store the result, use a slice instead. Use value.is_na() to detect NA values.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Vec<f64>

fn try_from(robj: Robj) -> Result<Self>

Convert a REALSXP object into a vector of f64 (double precision floating point). Note: Unless you plan to store the result, use a slice instead. Use value.is_na() to detect NA values.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Vec<Rbool>

fn try_from(robj: Robj) -> Result<Self>

Convert a LGLSXP object into a vector of Rbool (tri-state booleans). Note: Unless you plan to store the result, use a slice instead. Use value.is_na() to detect NA values.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Vec<u8>

fn try_from(robj: Robj) -> Result<Self>

Convert a RAWSXP object into a vector of bytes. Note: Unless you plan to store the result, use a slice instead.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Vec<String>

fn try_from(robj: Robj) -> Result<Self>

Convert a STRSXP object into a vector of Strings. Note: Unless you plan to store the result, use a slice instead.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Option<u8>

fn try_from(robj: Robj) -> Result<Self>

Convert a scalar object that may be NA type to an Option of a corresponding type. Returns None if the scalar is NA.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for u32

fn try_from(robj: Robj) -> Result<Self>

Convert a numeric object to an integer value.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Option<u16>

fn try_from(robj: Robj) -> Result<Self>

Convert a scalar object that may be NA type to an Option of a corresponding type. Returns None if the scalar is NA.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Option<u32>

fn try_from(robj: Robj) -> Result<Self>

Convert a scalar object that may be NA type to an Option of a corresponding type. Returns None if the scalar is NA.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Option<u64>

fn try_from(robj: Robj) -> Result<Self>

Convert a scalar object that may be NA type to an Option of a corresponding type. Returns None if the scalar is NA.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Option<i8>

fn try_from(robj: Robj) -> Result<Self>

Convert a scalar object that may be NA type to an Option of a corresponding type. Returns None if the scalar is NA.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Option<i16>

fn try_from(robj: Robj) -> Result<Self>

Convert a scalar object that may be NA type to an Option of a corresponding type. Returns None if the scalar is NA.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Option<i32>

fn try_from(robj: Robj) -> Result<Self>

Convert a scalar object that may be NA type to an Option of a corresponding type. Returns None if the scalar is NA.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Option<i64>

fn try_from(robj: Robj) -> Result<Self>

Convert a scalar object that may be NA type to an Option of a corresponding type. Returns None if the scalar is NA.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Option<f32>

fn try_from(robj: Robj) -> Result<Self>

Convert a scalar object that may be NA type to an Option of a corresponding type. Returns None if the scalar is NA.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Option<f64>

fn try_from(robj: Robj) -> Result<Self>

Convert a scalar object that may be NA type to an Option of a corresponding type. Returns None if the scalar is NA.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Option<Rbool>

fn try_from(robj: Robj) -> Result<Self>

Convert a scalar object that may be NA type to an Option of a corresponding type. Returns None if the scalar is NA.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for u64

fn try_from(robj: Robj) -> Result<Self>

Convert a numeric object to an integer value.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Option<bool>

fn try_from(robj: Robj) -> Result<Self>

Convert a scalar object that may be NA type to an Option of a corresponding type. Returns None if the scalar is NA.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Option<&str>

fn try_from(robj: Robj) -> Result<Self>

Convert a scalar object that may be NA type to an Option of a corresponding type. Returns None if the scalar is NA.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Option<String>

fn try_from(robj: Robj) -> Result<Self>

Convert a scalar object that may be NA type to an Option of a corresponding type. Returns None if the scalar is NA.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Option<Vec<i32>>

fn try_from(robj: Robj) -> Result<Self>

Convert a scalar object that may be NA type to an Option of a corresponding type. Returns None if the scalar is NA.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Option<Vec<f64>>

fn try_from(robj: Robj) -> Result<Self>

Convert a scalar object that may be NA type to an Option of a corresponding type. Returns None if the scalar is NA.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Option<Vec<String>>

fn try_from(robj: Robj) -> Result<Self>

Convert a scalar object that may be NA type to an Option of a corresponding type. Returns None if the scalar is NA.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for &[i32]

fn try_from(robj: Robj) -> Result<Self>

Convert an INTSXP object into a slice of i32 (integer). Use value.is_na() to detect NA values.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for &[Rbool]

fn try_from(robj: Robj) -> Result<Self>

Convert a LGLSXP object into a slice of Rbool (tri-state booleans). Use value.is_na() to detect NA values.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for &[u8]

fn try_from(robj: Robj) -> Result<Self>

Convert a RAWSXP object into a slice of bytes.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for &[f64]

fn try_from(robj: Robj) -> Result<Self>

Convert a REALSXP object into a slice of f64 (double precision floating point). Use value.is_na() to detect NA values.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for i8

fn try_from(robj: Robj) -> Result<Self>

Convert a numeric object to an integer value.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Rfloat

type Error = Error

The type returned in the event of a conversion error.

fn try_from(robj: Robj) -> Result<Self>

Performs the conversion.

impl TryFrom<Robj> for Rint

type Error = Error

The type returned in the event of a conversion error.

fn try_from(robj: Robj) -> Result<Self>

Performs the conversion.

impl TryFrom<Robj> for Rcplx

type Error = Error

The type returned in the event of a conversion error.

fn try_from(robj: Robj) -> Result<Self>

Performs the conversion.

impl<T: Any + Debug> TryFrom<Robj> for ExternalPtr<T>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(robj: Robj) -> Result<Self>

Performs the conversion.

impl<T> TryFrom<Robj> for FromList<Vec<T>> where
    T: TryFrom<Robj>,
    <T as TryFrom<Robj>>::Error: Into<Error>, 

fn try_from(robj: Robj) -> Result<Self>

You can use the FromList wrapper to coerce a Robj into a list.

use extendr_api::prelude::*;
test! {
    let list = Robj::from(list!(1, 2));
    let vec : FromList<Vec<i32>> = list.try_into()?;
    assert_eq!(vec.0, vec![1, 2]);
}

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for ListIter

fn try_from(robj: Robj) -> Result<Self>

You can pass a ListIter to a function.

use extendr_api::prelude::*;
test! {
    let list = Robj::from(list!(1, 2));
    let vec : ListIter = list.try_into()?;
    assert_eq!(vec.collect::<Vec<_>>(), vec![r!(1), r!(2)]);
}

type Error = Error

The type returned in the event of a conversion error.

impl<'a, T: 'a> TryFrom<Robj> for RColumn<T> where
    Robj: AsTypedSlice<'a, T>, 

type Error = Error

The type returned in the event of a conversion error.

fn try_from(robj: Robj) -> Result<Self>

Performs the conversion.

impl<'a, T: 'a> TryFrom<Robj> for RMatrix<T> where
    Robj: AsTypedSlice<'a, T>, 

type Error = Error

The type returned in the event of a conversion error.

fn try_from(robj: Robj) -> Result<Self>

Performs the conversion.

impl<'a, T: 'a> TryFrom<Robj> for RMatrix3D<T> where
    Robj: AsTypedSlice<'a, T>, 

type Error = Error

The type returned in the event of a conversion error.

fn try_from(robj: Robj) -> Result<Self>

Performs the conversion.

impl TryFrom<Robj> for PairlistIter

fn try_from(robj: Robj) -> Result<Self>

You can pass a PairlistIter to a function.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for i16

fn try_from(robj: Robj) -> Result<Self>

Convert a numeric object to an integer value.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Pairlist

fn try_from(robj: Robj) -> Result<Self>

Make a wrapper from a robj if it matches.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Function

fn try_from(robj: Robj) -> Result<Self>

Make a wrapper from a robj if it matches.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Raw

fn try_from(robj: Robj) -> Result<Self>

Make a wrapper from a robj if it matches.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Rstr

fn try_from(robj: Robj) -> Result<Self>

Make a wrapper from a robj if it matches.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Environment

fn try_from(robj: Robj) -> Result<Self>

Make a wrapper from a robj if it matches.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for List

fn try_from(robj: Robj) -> Result<Self>

Make a wrapper from a robj if it matches.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Expressions

fn try_from(robj: Robj) -> Result<Self>

Make a wrapper from a robj if it matches.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Language

fn try_from(robj: Robj) -> Result<Self>

Make a wrapper from a robj if it matches.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Symbol

fn try_from(robj: Robj) -> Result<Self>

Make a wrapper from a robj if it matches.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Primitive

fn try_from(robj: Robj) -> Result<Self>

Make a wrapper from a robj if it matches.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for i32

fn try_from(robj: Robj) -> Result<Self>

Convert a numeric object to an integer value.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Promise

fn try_from(robj: Robj) -> Result<Self>

Make a wrapper from a robj if it matches.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Altrep

fn try_from(robj: Robj) -> Result<Self>

Make a wrapper from a robj if it matches.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for S4

fn try_from(robj: Robj) -> Result<Self>

Make a wrapper from a robj if it matches.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Integers

fn try_from(robj: Robj) -> Result<Self>

Make a wrapper from a robj if it matches.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Logicals

fn try_from(robj: Robj) -> Result<Self>

Make a wrapper from a robj if it matches.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Doubles

fn try_from(robj: Robj) -> Result<Self>

Make a wrapper from a robj if it matches.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Complexes

fn try_from(robj: Robj) -> Result<Self>

Make a wrapper from a robj if it matches.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for Strings

fn try_from(robj: Robj) -> Result<Self>

Make a wrapper from a robj if it matches.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for i64

fn try_from(robj: Robj) -> Result<Self>

Convert a numeric object to an integer value.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for f32

fn try_from(robj: Robj) -> Result<Self>

Convert a numeric object to a real value.

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<Robj> for f64

fn try_from(robj: Robj) -> Result<Self>

Convert a numeric object to a real value.

type Error = Error

The type returned in the event of a conversion error.

impl Types for Robj

fn rtype(&self) -> Rtype

Get the type of an R object.

fn as_any(&self) -> Rany<'_>