how to check if list contains lists recursively - rcpp

Question

I have a function in R that recursively builds a list of lists of varying depth. The output node may be be
node<-list(right=(0))
or
node<-list(right=list(right=0))
In Rcpp I would like to build a recursively deconstruct the list and return the integer member, 0 in this case.
My problem is checking if node has a named member right
library(Rcpp)
cppFunction(
'
int predict(List node){
if(node["right"]){
return predict(node["right"]);
}
else{
return node;
}
}
}
'
)
I've looked at Dynamic Wrapping to check type and use switch/case, but it doesn't seem to like named lists.

Answer 1

Trying to check for existence of a named value using a subset, e.g. if(node["right"]), will trigger the following error:
Error in predict_bad(node) : Not compatible with requested type: [type=list; target=logical].
To search a List or *Vector for a named element, use .containsElementNamed("name") member function.
For example, we have:
#include<Rcpp.h>
// [[Rcpp::export]]
Rcpp::List predict_list(Rcpp::List node){
// Check if name is present
if(node.containsElementNamed("right")) {
return predict_list(node["right"]);
}
return node;
}
Notice, here we are returning an Rcpp::List, e.g.
node1 = list(right = list(right = 0))
predict_list(node1)
# [[1]]
# [1] 0
To obtain only an integer, we must first subset the list and cast to the appropriate type. The second component, if we are tricky enough, we can allow Rcpp automagic to handle the conversion. (Thanks to Qiang for revealing the prior answer does not have to be positionally limited.)
#include<Rcpp.h>
// [[Rcpp::export]]
int predict_node_val(Rcpp::List node) {
// Check if name is present
if(node.containsElementNamed("right")) {
// Check if element isn't a list.
switch(TYPEOF(node["right"])) {
case REALSXP:
case INTSXP:
return node["right"];
default: // Keep going down the tree
return predict_node_val(node["right"]);
}
}
// Quiet compiler by providing a final output case
return -1;
}
Output:
node1 = list(right = list(right = 0))
node2 = list(right = 0)
predict_node_val(node1)
# [1] 0
predict_node_val(node2)
# [1] 0
There are a few assumptions made above... The first is we will always have a list architecture based on typing. The second is the value we want to retrieve is always listed as "right". The third

Answer 2

You can just get the names and check if there is an element right.
The following code should work:
library(Rcpp)
cppFunction(
'
int predict(List node) {
std::vector<std::string> list_names = node.names();
if (std::find(list_names.begin(), list_names.end(), "right") != list_names.end()) {
if (TYPEOF(node["right"]) == REALSXP) {
return node["right"];
} else {
return predict(node["right"]);
}
} else {
return -1;
}
}
'
)
The results
> node<-list(right=(0))
> predict(node)
[1] 0
> node<-list(right=list(right=0))
> predict(node)
[1] 0