Recommended approach for extracting Nullable values

[m-muecke]

I found the gallery post on working with Nullable, but couldn't find guidance specific to scalar types (integers and doubles) or Armadillo matrices. I wanted to check if the pattern below is a recommended approach.

void fn(Nullable<NumericMatrix>& x, Nullable<int>& c, Nullable<arma::mat>& mat) {
  // 1. using as<>
  if (x.isNotNull()) {
    NumericMatrix x_ = as<NumericMatrix>(x);
  }
  // 2. using constructor
  if (x.isNotNull()) {
    NumericMatrix x_(x);
  }
  // nullable for scalar
  if (c.isNotNull()) {
    int c_ = as<int>(c);
  }
  // with arma::mat works but creates a copy
  if (mat.isNotNull()) {
    arma::mat mat_ = as<arma::mat>(mat);
  }
}

[eddelbuettel]

It may help to step back. Nullable is for optional elements in a function signature for which we let Rcpp build an interface. This is constrained (by R itself) to work via .Call() where each element has to be a SEXP. So Nullable<> wraps around SEXP types. That is why the Gallery article mentions NumericMatrix, List, DataFrame (also a List, really).

'Plain old scalar' types like double are not a SEXP and cannot be overloaded that way. I might use the R ability to set them to NA to flag 'not here'. As for Armadillo's arma::mat and alike: similar. I would probably have to bite the bullet and a use NumericMatrix and then cast it if not null.

Otherwise what you do in your post seems roughly correct. The Nullable<> approach in Rcpp is a relatively simple trick, and in the 'object present' case you always have to cast so the ctor approach seems as valid as the as<> approach. As for Armadillo requiring a passage via NumericMatrix: that's just how the templating code is set up now. One could possibly add a bit more here but so far nobody has volunteered to do so, and what we have works well enough.

[m-muecke]

Much appreciated. Then I assume the above just worked "by accident" and isn't intended behaviour.
One more question: is there a preference between the as<> approach vs the constructor approach for extracting from Nullable, or is it purely stylistic?

[eddelbuettel]

Yep I would agree 😆 I think it is purely stylistic, and the end of the day we have to give the compiler something it can work with. I just played a little with this via Rcpp::cppFunction() and these all build (all of course skip the test for NonNull so it is really just a 'does it compile?' test and not meant to be used as is):

> cppFunction("arma::mat foo(Nullable<NumericMatrix> m) { NumericMatrix nm{m}; arma::mat am{Rcpp::as<arma::mat>(nm)}; return am; }", depends="RcppArmadillo")
> cppFunction("arma::mat foo(Nullable<NumericMatrix> m) { NumericMatrix nm{m}; arma::mat am{Rcpp::as<arma::mat>(m)}; return am; }", depends="RcppArmadillo")
> cppFunction("arma::mat foo(Nullable<NumericMatrix> m) { arma::mat am{Rcpp::as<arma::mat>(m)}; return am; }", depends="RcppArmadillo")

[eddelbuettel]

Actually, come to think about it, "by accident" is not right. These will likely invoke the same templating via as<>() that allow us to use double etc in a signature. So what you have works as intended. We just never (?) really documented it, but you unearthed it correctly.

> cppFunction("void foo(Nullable<double> s) { if (s.isNotNull()) { double d = as<double>(s); } }")
> 

In case like this is can be illuminating to look at either one of the unit tests (not much here) or within CRAN if the search is good and we see that Nullable<double> is indeed used that way in a few packages.

PS And even more for Nullable<int>

[eddelbuettel]

So a fuller answer may be: supports all types for we have SEXP converters -- including those for which you wrote your own (another Gallery etc topic).