additional unary_function conversion in test file and vignettes

Author: eddelbuettel

ChangeLog

@@ -1,8 +1,16 @@
-2022-03-09  Dirk Eddelbuettel  <edd@debian.org>
+2022-03-10  Dirk Eddelbuettel  <edd@debian.org>
 
 	* DESCRIPTION (Version, Date): Roll minor version
 	* inst/include/Rcpp/config.h: Idem
 
+	* inst/tinytest/cpp/sugar.cpp: Also conditionally replace
+	std::unary_function with std::function
+	* vignettes/rmd/Rcpp-sugar.Rmd: Replace std::unary_function example
+	with std::function (implicitly requiring C++ in vignette example)
+	* vignettes/rmd/Rcpp-FAQ.Rmd: Idem
+
+2022-03-09  Dirk Eddelbuettel  <edd@debian.org>
+
 	* inst/include/Rcpp/Language.h: To quieten compilations, replace
 	std::(unary|binary)_function with std::function for C++11 or later
 	* inst/include/Rcpp/StringTransformer.he: Idem

DESCRIPTION

@@ -1,7 +1,7 @@
 Package: Rcpp
 Title: Seamless R and C++ Integration
 Version: 1.0.8.2
-Date: 2022-03-09
+Date: 2022-03-10
 Author: Dirk Eddelbuettel, Romain Francois, JJ Allaire, Kevin Ushey, Qiang Kou,
  Nathan Russell, Inaki Ucar, Douglas Bates and John Chambers
 Maintainer: Dirk Eddelbuettel <edd@debian.org>

inst/NEWS.Rd

@@ -3,15 +3,16 @@
 \newcommand{\ghpr}{\href{https://github.com/RcppCore/Rcpp/pull/#1}{##1}}
 \newcommand{\ghit}{\href{https://github.com/RcppCore/Rcpp/issues/#1}{##1}}
 
-\section{Changes in Rcpp hotfix release version 1.0.8.2 (2022-03-09)}{
+\section{Changes in Rcpp hotfix release version 1.0.8.2 (2022-03-10)}{
   \itemize{
     \item Changes in Rcpp API:
     \itemize{
       \item Accomodate C++98 compilation by adjusting attributes.cpp (Dirk in
       \ghpr{1193} fixing \ghit{1192})
-      \item Accomodate newest compilers by replacing deprecated
+      \item Accomodate newest compilers replacing deprecated
        \code{std::unary_function} and \code{std::binary_function} with
-       \code{std::function} (Dirk fixing \ghit{1201} and CRAN request)
+       \code{std::function} (Dirk in \ghpr{1202} fixing \ghit{1201} and
+       CRAN request)
     }
     \item Changes in Rcpp Documentation:
     \itemize{

inst/tinytest/cpp/sugar.cpp

@@ -1,8 +1,7 @@
-// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*-
-//
+
 // sugar.cpp: Rcpp R/C++ interface class library -- sugar unit tests
 //
-// Copyright (C) 2012 - 2015  Dirk Eddelbuettel and Romain Francois
+// Copyright (C) 2012 - 2022  Dirk Eddelbuettel and Romain Francois
 //
 // This file is part of Rcpp.
 //
@@ -23,7 +22,12 @@
 using namespace Rcpp ;
 
 template <typename T>
+
+#if __cplusplus < 201103L
 class square : public std::unary_function<T,T> {
+#else
+class square : public std::function<T(T)> {
+#endif
 public:
 	T operator()( T t) const { return t*t ; }
 } ;

vignettes/rmd/Rcpp-FAQ.Rmd

@@ -642,13 +642,14 @@ what we show below.
 
 
 ### Using inline with Templated Code
+
 Most certainly, consider this simple example of a templated class
 which squares its argument:
 
 ```{r}
 inc <- 'template <typename T>
         class square :
-          public std::unary_function<T,T> {
+          public std::function<T(T)> {
             public:
               T operator()( T t) const {
                 return t*t;
@@ -684,7 +685,7 @@ will even run the R part at the end.
 #include <Rcpp.h>
 
 template <typename T> class square :
-    public std::unary_function<T,T> {
+    public std::function<T(T)> {
       public:
       T operator()( T t) const {
         return t*t ;

vignettes/rmd/Rcpp-sugar.Rmd

@@ -137,7 +137,7 @@ high-level \proglang{R} syntax in \proglang{C++}. Hence, with \sugar, the
 \proglang{C++} version of `foo` now becomes:
 
 ```cpp
-Rcpp::NumericVector foo(Rcpp::NumericVector x, 
+Rcpp::NumericVector foo(Rcpp::NumericVector x,
                         Rcpp::NumericVector y) {
     return ifelse(x < y, x * x, -(y * y));
 }
@@ -308,7 +308,7 @@ length. Each element of the result expression evaluates to `TRUE` if
 the corresponding input is a missing value, or `FALSE` otherwise.
 
 ```cpp
-IntegerVector x = 
+IntegerVector x =
     IntegerVector::create(0, 1, NA_INTEGER, 3);
 
 is_na(x)
@@ -322,7 +322,7 @@ Given a sugar expression of any type, `seq_along` creates an
 integer sugar expression whose values go from 1 to the size of the input.
 
 ```cpp
-IntegerVector x = 
+IntegerVector x =
     IntegerVector::create( 0, 1, NA_INTEGER, 3 );
 
 IntegerVector y = seq_along(x);
@@ -337,7 +337,7 @@ second expression, since the abstract syntax tree is built at compile time.
 
 ### seq_len
 
-`seq_len` creates an integer sugar expression whose 
+`seq_len` creates an integer sugar expression whose
 \ith\ element expands to `i`. `seq_len` is particularly useful in
 conjunction with `sapply` and `lapply`.
 
@@ -411,7 +411,7 @@ called `result_type`
 
 ```cpp
 template <typename T>
-struct square : std::unary_function<T, T> {
+struct square : std::function<T(T)> {
     T operator()(const T& x){
         return x * x;
     }
@@ -491,9 +491,9 @@ beta, binom, cauchy, chisq, exp, f, gamma, geom, hyper, lnorm, logis, nbeta,
 nbinom, nbinom_mu, nchisq, nf, norm, nt, pois, t, unif, and weibull.
 
 Note that the parameterization used in these sugar functions may differ between
-the top-level functions exposed in an \proglang{R} session. For example, 
+the top-level functions exposed in an \proglang{R} session. For example,
 the internal \code{rexp} is parameterized by \code{scale},
-whereas the R-level \code{stats::rexp} is parameterized by \code{rate}. 
+whereas the R-level \code{stats::rexp} is parameterized by \code{rate}.
 Consult \href{http://cran.r-project.org/doc/manuals/r-release/R-exts.html#Distribution-functions}{Distribution Functions}
 for more details on the parameterization used for these sugar functions.
 
@@ -568,13 +568,13 @@ is given here:
 template <int RTYPE, bool na, typename VECTOR>
 class VectorBase {
 public:
-    struct r_type : 
+    struct r_type :
         traits::integral_constant<int,RTYPE>{};
     struct can_have_na :
         traits::integral_constant<bool,na>{};
-    
-    typedef typename 
-        traits::storage_type<RTYPE>::type 
+
+    typedef typename
+        traits::storage_type<RTYPE>::type
         stored_type;
 
     VECTOR& get_ref(){
@@ -586,18 +586,18 @@ public:
                            this)->operator[](i);
     }
 
-    inline int size() const { 
+    inline int size() const {
         return static_cast<const VECTOR*>(
-                           this)->size(); 
+                           this)->size();
     }
 
     /* definition ommited here */
     class iterator;
 
-    inline iterator begin() const { 
-        return iterator(*this, 0); 
+    inline iterator begin() const {
+        return iterator(*this, 0);
     }
-    inline iterator end() const { 
+    inline iterator end() const {
         return iterator(*this, size());
     }
 }
@@ -633,27 +633,27 @@ the template class `Rcpp::sugar::Sapply` is given below:
 template <int RTYPE, bool NA,
           typename T, typename Function>
 class Sapply : public VectorBase<
-    Rcpp::traits::r_sexptype_traits< typename 
+    Rcpp::traits::r_sexptype_traits< typename
         ::Rcpp::traits::result_of<Function>::type
     >::rtype,
     true,
     Sapply<RTYPE, NA, T, Function>
 > {
 public:
-    typedef typename 
+    typedef typename
       ::Rcpp::traits::result_of<Function>::type;
-    
+
     const static int RESULT_R_TYPE =
         Rcpp::traits::r_sexptype_traits<
             result_type>::rtype;
-    
+
     typedef Rcpp::VectorBase<RTYPE,NA,T> VEC;
-    
-    typedef typename 
+
+    typedef typename
         Rcpp::traits::r_vector_element_converter<
         RESULT_R_TYPE>::type
         converter_type;
-    
+
     typedef typename Rcpp::traits::storage_type<
         RESULT_R_TYPE>::type STORAGE;
 
@@ -663,9 +663,9 @@ public:
     inline STORAGE operator[]( int i ) const {
         return converter_type::get(fun(vec[i]));
     }
-    
-    inline int size() const { 
-        return vec.size(); 
+
+    inline int size() const {
+        return vec.size();
     }
 
 private:
@@ -675,13 +675,13 @@ private:
 
 // sugar
 
-template <int RTYPE, bool _NA_, 
+template <int RTYPE, bool _NA_,
           typename T, typename Function >
 inline sugar::Sapply<RTYPE, _NA_, T, Function>
 sapply(const Rcpp::VectorBase<RTYPE,_NA_,T>& t,
         Function fun) {
-    
-    return 
+
+    return
       sugar::Sapply<RTYPE,_NA_,T,Function>(t, fun);
 }
 ```
@@ -703,8 +703,8 @@ template class queries the template argument via the `Rcpp::traits::result_of`
 template.
 
 ```cpp
-typedef typename 
-    ::Rcpp::traits::result_of<Function>::type 
+typedef typename
+    ::Rcpp::traits::result_of<Function>::type
     result_type;
 ```
 
@@ -717,7 +717,7 @@ struct result_of{
     typedef typename T::result_type type;
 };
 
-template <typename RESULT_TYPE, 
+template <typename RESULT_TYPE,
           typename INPUT_TYPE>
 struct result_of<RESULT_TYPE (*)(INPUT_TYPE)> {
     typedef RESULT_TYPE type;
@@ -762,7 +762,7 @@ of a `REALSXP` expression is `double`.
 
 ```cpp
 typedef typename
-    Rcpp::traits::storage_type<RESULT_R_TYPE>::type 
+    Rcpp::traits::storage_type<RESULT_R_TYPE>::type
     STORAGE;
 ```
 
@@ -785,7 +785,7 @@ template <int RTYPE, bool NA,
           typename T, typename Function>
 class Sapply : public VectorBase<
     Rcpp::traits::r_sexptype_traits<
-        typename 
+        typename
         ::Rcpp::traits::result_of<Function>::type
     >::rtype,
     true,
@@ -799,13 +799,13 @@ is the manifestation of the _CRTP_.
 
 ### Constructor
 
- 
+
 The constructor of the `Sapply` class template is straightforward, it
 simply consists of holding the reference to the input expression and the
 function.
 
 ```cpp
-Sapply(const VEC& vec_, Function fun_): 
+Sapply(const VEC& vec_, Function fun_):
     vec(vec_), fun(fun_){}
 
 private:
@@ -825,8 +825,8 @@ and the converter. Both these methods are inline to maximize performance:
 inline STORAGE operator[](int i) const {
 	return converter_type::get(fun(vec[i]));
 }
-inline int size() const { 
-    return vec.size(); 
+inline int size() const {
+    return vec.size();
 }
 ```