Struct extendr_api::wrapper::function::Function

pub struct Function { /* private fields */ }

Wrapper for creating functions (CLOSSXP).

use extendr_api::prelude::*;
test! {
    // Closures are functions.
    let expr = R!("function(a = 1, b) {c <- a + b}")?;
    let func = expr.as_function().unwrap();

    let expected_formals = Pairlist::from_pairs(vec![("a", r!(1.0)), ("b", missing_arg().into())]);
    let expected_body = lang!(
        "{", lang!("<-", sym!(c), lang!("+", sym!(a), sym!(b))));
    assert_eq!(func.formals().unwrap(), expected_formals);
    assert_eq!(func.body().unwrap(), expected_body);
    assert_eq!(func.environment().unwrap(), global_env());

    // Primitives can also be functions.
    let expr = R!("`~`")?;
    let func = expr.as_function().unwrap();
    assert_eq!(func.formals(), None);
    assert_eq!(func.body(), None);
    assert_eq!(func.environment(), None);
}

Implementations

impl Function

pub fn from_parts( formals: Pairlist, body: Language, env: Environment ) -> Result<Self>

Make a function from parts.

use extendr_api::prelude::*;
test! {
    let formals = pairlist!(a=NULL);
    let body = lang!("+", sym!(a), r!(1)).try_into()?;
    let env = global_env();
    let f = r!(Function::from_parts(formals, body, env )?);
    assert_eq!(f.call(pairlist!(a=1))?, r!(2));
}

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

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

use extendr_api::prelude::*;
test! {
    let function = R!("function(a, b) a + b").unwrap().as_function().unwrap();
    assert_eq!(function.call(pairlist!(a=1, b=2)).unwrap(), r!(3));
}

pub fn formals(&self) -> Option<Pairlist>

Get the formal arguments of the function or None if it is a primitive.

pub fn body(&self) -> Option<Robj>

Get the body of the function or None if it is a primitive.

pub fn environment(&self) -> Option<Environment>

Get the environment of the function or None if it is a primitive.

Trait Implementations

impl Clone for Function

fn clone(&self) -> Function

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Conversions for Function

as_*()

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 Function

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

Formats the value using the given formatter.

impl From<&Function> for Robj

fn from(val: &Function) -> Self

Make an robj from a wrapper.

impl From<Function> for Robj

fn from(val: Function) -> Self

Make an robj from a wrapper.

impl<'a> FromRobj<'a> for Function

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

impl GetSexp for Function

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 Function

len() and is_empty()

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 Operators for Function

dollar() etc.

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 PartialEq<Function> for Function

fn eq(&self, other: &Function) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Function

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 Function

as_typed_slice_raw() etc.

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 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 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 Types for Function

rtype() and rany()

fn rtype(&self) -> Rtype

Get the type of an R object.

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

impl StructuralPartialEq for Function