extendr-api 0.9.0

Safe and user friendly bindings to the R programming language.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use extendr_api::prelude::*;

#[test]
fn test_derive_into_dataframe() {
    test! {
        use extendr_api::prelude::*;

        #[derive(Debug, IntoDataFrameRow)]
        struct MyStruct {
            x: Rint,
            y: Rstr,
        }

        let v = vec![MyStruct { x: 0.into(), y: "abc".into() }, MyStruct { x: 1.into(), y: "xyz".into() }];
        let df = v.into_dataframe()?;

        assert!(df.inherits("data.frame"));

        let list : List = df.as_list().unwrap();
        assert_eq!(list[0], r!([0, 1]));
        assert_eq!(list[1], r!(["abc", "xyz"]));

        // Note the odd RFC 2451 (I,). If you can fix this, I'll be a happy bunny.
        let df3 = ((0..2).map(|i| MyStruct { x: i.into(), y: i.to_string().into() }),).into_dataframe()?;
        assert!(df3.inherits("data.frame"));

        let list : List = df3.as_list().unwrap();
        assert_eq!(list[0], r!([0, 1]));
        assert_eq!(list[1], r!(["0", "1"]));
    }
}

#[test]
fn test_into_robj_dataframe() {
    test! {
        use extendr_api::prelude::*;

        #[derive(Clone, Debug, IntoDataFrameRow)]
        struct MyStruct {
            x: Rint,
            y: Rstr,
        }

        let v = vec![MyStruct { x: 0.into(), y: "abc".into() }, MyStruct { x: 1.into(), y: "xyz".into() }];
        let df = v.into_dataframe()?;

        assert_eq!(
            df.clone().as_robj().clone(),
            df.into_robj()
        );

    }
}

#[derive(IntoDataFrameRow)]
struct Row {
    name: u32,
}

#[extendr]
fn dataframe_conversion(_data_frame: Dataframe<Row>) -> Robj {
    vec![Row { name: 42 }].into_dataframe().unwrap().into_robj()
}

#[extendr]
fn dataframe_conversion_try_from(_data_frame: Dataframe<Row>) -> Robj {
    vec![Row { name: 42 }].into_dataframe().unwrap().into_robj()
}

#[extendr]
fn return_dataframe(_data_frame: Dataframe<Row>) -> Dataframe<Row> {
    vec![Row { name: 42 }].into_dataframe().unwrap()
}

#[extendr]
fn return_dataframe_try_from(_data_frame: Dataframe<Row>) -> Dataframe<Row> {
    vec![Row { name: 42 }].into_dataframe().unwrap()
}

#[test]
fn test_storing_external_ptr_as_row() {
    struct Row {
        _id: u32,
    }

    #[extendr]
    impl Row {}

    #[extendr]
    fn use_dataframe_exptr(data_frame: Dataframe<Row>) -> Dataframe<Row> {
        data_frame
    }
}

#[test]
fn test_dataframe_row_and_externalptr() {
    #[derive(IntoDataFrameRow)]
    struct RowAndExptr {
        id: u32,
    }

    #[extendr]
    impl RowAndExptr {}

    #[extendr]
    fn use_dataframe_exptr2(data_frame: Dataframe<RowAndExptr>) -> Dataframe<RowAndExptr> {
        data_frame
    }

    #[extendr]
    fn use_dataframe_exptr3(data_frame: Dataframe<RowAndExptr>) -> Dataframe<RowAndExptr> {
        data_frame
    }
}