A new approach of NA handling

README.md

I've implemented a new approch of NA handling in Rcpp11 (it is straightforward to port this to Rcpp).

To test for missing values in Rcpp there are several ways:

• rely on R api macros (NA_REAL, ...)
• use Vector<RTYPE>::is_na(.)
• use traits::is_na(.)

These lack expressiveness and what I've implemented in Rcpp11 allows this syntax:

double x ; int y; String s ; // ... values coming from somewhere 

// we can just us the equality operator to test for equality against NA: 

double b1 = x == NA ;
double b2 = NA == x ;

double b1 = y == NA ;
double b2 = NA == y ;

double b1 = s == NA ;
double b2 = NA == s ;

NA_Proxy.h

// Copyright (C) 2013 Romain Francois
//
// This file is part of Rcpp11.
//
// Rcpp11 is free software: you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 2 of the License, or
// (at your option) any later version.
//
// Rcpp11 is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Rcpp11.  If not, see <http://www.gnu.org/licenses/>.

#ifndef Rcpp_Na_Proxy_h
#define Rcpp_Na_Proxy_h

namespace Rcpp{
    class Na_Proxy{} ;
    static Na_Proxy NA ;    
}

inline bool operator==(double x      , Rcpp::Na_Proxy){ return Rcpp::traits::is_na<REALSXP>(x) ; }
inline bool operator==(int x         , Rcpp::Na_Proxy){ return Rcpp::traits::is_na<INTSXP>(x) ; }
inline bool operator==(Rcpp::String x, Rcpp::Na_Proxy){ return Rcpp::traits::is_na<STRSXP>(x.get_sexp()) ; }
inline bool operator==(Rcomplex x    , Rcpp::Na_Proxy){ return Rcpp::traits::is_na<CPLXSXP>(x) ; }
inline bool operator==(SEXP x        , Rcpp::Na_Proxy){ return TYPEOF(x)==CHARSXP && Rcpp::traits::is_na<STRSXP>(x) ; }
inline bool operator==(std::string x , Rcpp::Na_Proxy){ return false ; }
inline bool operator==(const char* x , Rcpp::Na_Proxy){ return false ; }
inline bool operator==(Rcpp::internal::string_proxy<STRSXP> x, Rcpp::Na_Proxy){ return Rcpp::traits::is_na<STRSXP>(x.get()) ; }

inline bool operator==(Rcpp::Na_Proxy, double x       ){ return Rcpp::traits::is_na<REALSXP>(x) ; }
inline bool operator==(Rcpp::Na_Proxy, int x          ){ return Rcpp::traits::is_na<INTSXP>(x) ; }
inline bool operator==(Rcpp::Na_Proxy, Rcpp::String x ){ return Rcpp::traits::is_na<STRSXP>(x.get_sexp()) ; }
inline bool operator==(Rcpp::Na_Proxy, SEXP x         ){ return TYPEOF(x)==CHARSXP && Rcpp::traits::is_na<STRSXP>(x) ; }
inline bool operator==(Rcpp::Na_Proxy, Rcomplex x     ){ return Rcpp::traits::is_na<CPLXSXP>(x) ; }
inline bool operator==(Rcpp::Na_Proxy, std::string x  ){ return false ; }
inline bool operator==(Rcpp::Na_Proxy, const char* x  ){ return false ; }
inline bool operator==(Rcpp::Na_Proxy, Rcpp::internal::string_proxy<STRSXP> x){ return Rcpp::traits::is_na<STRSXP>(x.get()) ; }

#endif

test.cpp

#include <Rcpp.h>
using namespace Rcpp ;

// [[Rcpp::export]]
LogicalVector na_proxy(){
    CharacterVector s = { "foo" } ;
    return LogicalVector::create( 
        NA_REAL    == NA, 
        NA_INTEGER == NA,
        NA_STRING  == NA,
        true       == NA, 
        false      == NA, 
        1.2        == NA, 
        12         == NA,
        "foo"      == NA,
        s[0]       == NA, 
        
        NA         == NA_REAL, 
        NA         == NA_INTEGER,
        NA         == NA_STRING,
        NA         == true, 
        NA         == false,
        NA         == 1.2  , 
        NA         == 12   ,
        NA         == "foo", 
        NA         == s[0]
        ) ;
}   
/*** R
  stopifnot( identical( na_proxy(), rep(c(TRUE,TRUE,TRUE,FALSE,FALSE,FALSE,FALSE,FALSE,FALSE) , 2) ) )
*/