[libcxx] [test] Fix Xxx_scan tests using nonstandard things and MSVC++ warnings

[BillyONeal]

Summary

• These tests use function objects from functional, back_inserter from iterator, and equal from algorithm, so add those headers.
• The use of iota targeting vector<unsigned char> with an int parameter triggers warnings on MSVC++ assigning an into a unsigned char&; so change the parameter to unsigned char with a static_cast.
• Avoid naming unary_function in identity here as that is removed in '17. (This also fixes naming _VSTD, _NOEXCEPT_, and other libcxx-isms)

[CaseyCarter]

test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp

36

Pre-existing: the identity transformation is an extremely poor choice for these transform_foo tests since failure to apply the transformation exactly once to each element does not affect the result of the algorithm.

[mclow.lists]

The use of iota targeting vector<unsigned char> with an int parameter triggers warnings on MSVC++ assigning an into a unsigned char&

I hate your compiler.

Other than that (and the bit about identity), this looks fine to me.

test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp

36

I think I'd rather have this. It's constexpr and noexcept, unlike the lambda.

struct identity {
    template <typename T>
    constexpr auto operator()(T&& x) const
    noexcept(noexcept(std::forward<T>(x)))
    -> decltype      (std::forward<T>(x))
        { return      std::forward<T>(x); }
};

36

I agree about the choice of identity as a transform.

[BillyONeal]

Also change predicate from identity to add_ten.

[BillyONeal]

I hate your compiler.

Seems like a valid warning to me :)

Changed predicate to one that adds 10 to each input.

[CaseyCarter]

test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp

33

Although it doesn't matter to these tests, this notably doesn't have return type SFINAE as @mclow.lists suggested in his comment. Marshall, do you care, and if so, why?

[BillyONeal]

@EricWF / @mclow.lists Any chance you could take a look sometime soon?

[BillyONeal]

It actually looks like I accidentally committed this back in January so I'm going to close this :)

test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp

 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // template<class InputIterator, class OutputIterator, class T>
 //     OutputIterator exclusive_scan(InputIterator first, InputIterator last,
 //                                   OutputIterator result, T init);
 //
 
 #include <numeric>
-#include <vector>
+#include <algorithm>
 #include <cassert>
+#include <functional>
+#include <iterator>
+#include <vector>
 
 #include "test_iterators.h"
 
 template <class Iter1, class T, class Iter2>
 void
 test(Iter1 first, Iter1 last, T init, Iter2 rFirst, Iter2 rLast)
 {
     std::vector<typename std::iterator_traits<Iter1>::value_type> v;

test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp

 
 // template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
 //     OutputIterator
 //     exclusive_scan(InputIterator first, InputIterator last,
 //                    OutputIterator result,
 //                    T init, BinaryOperation binary_op); // C++17
 
 #include <numeric>
-#include <vector>
+#include <algorithm>
 #include <cassert>
+#include <functional>
+#include <iterator>
+#include <vector>
 
 #include "test_iterators.h"
 
 template <class Iter1, class T, class Op, class Iter2>
 void
 test(Iter1 first, Iter1 last, T init, Op op, Iter2 rFirst, Iter2 rLast)
 {
     std::vector<typename std::iterator_traits<Iter1>::value_type> v;
//  All the iterator categories
     test<bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*> >();
     test<const int*>();
     test<      int*>();
 
 //  Make sure that the calculations are done using the init typedef
     {
     std::vector<unsigned char> v(10);
-    std::iota(v.begin(), v.end(), 1);
+    std::iota(v.begin(), v.end(), static_cast<unsigned char>(1));
     std::vector<int> res;
     std::exclusive_scan(v.begin(), v.end(), std::back_inserter(res), 1, std::multiplies<>());
 
     assert(res.size() == 10);
     int j = 1;
     assert(res[0] == 1);
     for (size_t i = 1; i < v.size(); ++i)
     {
         j *= i;
         assert(res[i] == j);
     }
     }
 }

test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp

 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // template<class InputIterator, class OutputIterator, class T>
 //     OutputIterator inclusive_scan(InputIterator first, InputIterator last,
 //                                   OutputIterator result, T init);
 //
 
 #include <numeric>
-#include <vector>
+#include <algorithm>
 #include <cassert>
+#include <functional>
+#include <iterator>
+#include <vector>
 
 #include "test_iterators.h"
 
 template <class Iter1, class Iter2>
 void
 test(Iter1 first, Iter1 last, Iter2 rFirst, Iter2 rLast)
 {
     std::vector<typename std::iterator_traits<Iter1>::value_type> v;

test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp

 
 // template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
 //     OutputIterator
 //     inclusive_scan(InputIterator first, InputIterator last,
 //                    OutputIterator result,
 //                    BinaryOperation binary_op); // C++17
 
 #include <numeric>
-#include <vector>
+#include <algorithm>
 #include <cassert>
+#include <functional>
 #include <iostream>
+#include <iterator>
+#include <vector>
 
 #include "test_iterators.h"
 
 template <class Iter1, class T, class Op, class Iter2>
 void
 test(Iter1 first, Iter1 last, Op op, Iter2 rFirst, Iter2 rLast)
 {
     std::vector<typename std::iterator_traits<Iter1>::value_type> v;

test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp

 
 // template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
 //     OutputIterator
 //     inclusive_scan(InputIterator first, InputIterator last,
 //                    OutputIterator result,
 //                    BinaryOperation binary_op, T init); // C++17
 
 #include <numeric>
-#include <vector>
+#include <algorithm>
 #include <cassert>
+#include <functional>
+#include <iterator>
+#include <vector>
 
 #include "test_iterators.h"
 
 template <class Iter1, class T, class Op, class Iter2>
 void
 test(Iter1 first, Iter1 last, Op op, T init, Iter2 rFirst, Iter2 rLast)
 {
     std::vector<typename std::iterator_traits<Iter1>::value_type> v;
void basic_tests()
     std::vector<int> v, res;
     std::inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::plus<>(), 40);
     assert(res.empty());
     }
 
 //  Make sure that the calculations are done using the init typedef
     {
     std::vector<unsigned char> v(10);
-    std::iota(v.begin(), v.end(), 1);
+    std::iota(v.begin(), v.end(), static_cast<unsigned char>(1));
     std::vector<int> res;
     std::inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::multiplies<>(), 1);
 
     assert(res.size() == 10);
     int j = 1;
     assert(res[0] == 1);
     for (size_t i = 1; i < v.size(); ++i)
     {

test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp

 //          class BinaryOperation, class UnaryOperation>
 //   OutputIterator transform_exclusive_scan(InputIterator first, InputIterator last,
 //                                           OutputIterator result, T init,
 //                                           BinaryOperation binary_op,
 //                                           UnaryOperation unary_op);
 
 
 #include <numeric>
-#include <vector>
+#include <algorithm>
 #include <cassert>
+#include <functional>
 #include <iostream>
+#include <iterator>
+#include <vector>
 
 #include "test_iterators.h"
 
-template <class T = void>
-struct identity : std::unary_function<T, T>
-{
-    constexpr const T& operator()(const T& x) const { return x;}
-};
-
-template <>
-struct identity<void>
-{
-    template <class T>
-    constexpr auto operator()(T&& x) const
-    _NOEXCEPT_(noexcept(_VSTD::forward<T>(x)))
-    -> decltype        (_VSTD::forward<T>(x))
-        { return        _VSTD::forward<T>(x); }
+struct add_ten {
+    template <typename T>
+    constexpr auto operator()(T x) const noexcept {
+        return static_cast<T>(x + 10);
+    }
 };
 
 template <class Iter1, class BOp, class UOp, class T, class Iter2>
 void
 test(Iter1 first, Iter1 last, BOp bop, UOp uop, T init, Iter2 rFirst, Iter2 rLast)
 {
     std::vector<typename std::iterator_traits<Iter1>::value_type> v;
 //  Test not in-place
     std::transform_exclusive_scan(first, last, std::back_inserter(v), init, bop, uop);
     assert(std::equal(v.begin(), v.end(), rFirst, rLast));
 
 //  Test in-place
     v.clear();
     v.assign(first, last);
     std::transform_exclusive_scan(v.begin(), v.end(), v.begin(), init, bop, uop);
     assert(std::equal(v.begin(), v.end(), rFirst, rLast));
 }
 
 
 template <class Iter>
 void
 test()
 {
           int ia[]     = { 1,  3,  5,   7,   9};
-    const int pResI0[] = { 0,  1,  4,   9,  16};        // with identity
+    const int pResI0[] = { 0, 11, 24,  39,  56};        // with add_ten
     const int mResI0[] = { 0,  0,  0,   0,   0};
     const int pResN0[] = { 0, -1, -4,  -9, -16};        // with negate
     const int mResN0[] = { 0,  0,  0,   0,   0};
-    const int pResI2[] = { 2,  3,  6,  11,  18};        // with identity
-    const int mResI2[] = { 2,  2,  6,  30, 210};
-    const int pResN2[] = { 2,  1, -2,  -7, -14};        // with negate
-    const int mResN2[] = { 2, -2,  6, -30, 210};
+    const int pResI2[] = { 2, 13, 26,  41,  58};        // with add_ten
+    const int mResI2[] = { 2, 22, 286, 4290, 72930};
+    const int pResN2[] = { 2,  1,  -2,  -7, -14};       // with negate
+    const int mResN2[] = { 2, -2,   6, -30, 210};
     const unsigned sa = sizeof(ia) / sizeof(ia[0]);
     static_assert(sa == sizeof(pResI0) / sizeof(pResI0[0]));       // just to be sure
     static_assert(sa == sizeof(mResI0) / sizeof(mResI0[0]));       // just to be sure
     static_assert(sa == sizeof(pResN0) / sizeof(pResN0[0]));       // just to be sure
     static_assert(sa == sizeof(mResN0) / sizeof(mResN0[0]));       // just to be sure
     static_assert(sa == sizeof(pResI2) / sizeof(pResI2[0]));       // just to be sure
     static_assert(sa == sizeof(mResI2) / sizeof(mResI2[0]));       // just to be sure
     static_assert(sa == sizeof(pResN2) / sizeof(pResN2[0]));       // just to be sure
     static_assert(sa == sizeof(mResN2) / sizeof(mResN2[0]));       // just to be sure
 
     for (unsigned int i = 0; i < sa; ++i ) {
-        test(Iter(ia), Iter(ia + i), std::plus<>(),       identity<>(),    0, pResI0, pResI0 + i);
-        test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity<>(),    0, mResI0, mResI0 + i);
+        test(Iter(ia), Iter(ia + i), std::plus<>(),       add_ten{},       0, pResI0, pResI0 + i);
+        test(Iter(ia), Iter(ia + i), std::multiplies<>(), add_ten{},       0, mResI0, mResI0 + i);
         test(Iter(ia), Iter(ia + i), std::plus<>(),       std::negate<>(), 0, pResN0, pResN0 + i);
         test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), 0, mResN0, mResN0 + i);
-        test(Iter(ia), Iter(ia + i), std::plus<>(),       identity<>(),    2, pResI2, pResI2 + i);
-        test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity<>(),    2, mResI2, mResI2 + i);
+        test(Iter(ia), Iter(ia + i), std::plus<>(),       add_ten{},       2, pResI2, pResI2 + i);
+        test(Iter(ia), Iter(ia + i), std::multiplies<>(), add_ten{},       2, mResI2, mResI2 + i);
         test(Iter(ia), Iter(ia + i), std::plus<>(),       std::negate<>(), 2, pResN2, pResN2 + i);
         test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), 2, mResN2, mResN2 + i);
         }
 }
 
 int triangle(int n) { return n*(n+1)/2; }
 
 //  Basic sanity
 void basic_tests()
 {
     {
     std::vector<int> v(10);
     std::fill(v.begin(), v.end(), 3);
-    std::transform_exclusive_scan(v.begin(), v.end(), v.begin(), 50, std::plus<>(), identity<>());
+    std::transform_exclusive_scan(v.begin(), v.end(), v.begin(), 50, std::plus<>(), add_ten{});
     for (size_t i = 0; i < v.size(); ++i)
-        assert(v[i] == 50 + (int) i * 3);
+        assert(v[i] == 50 + (int) i * 13);
     }
 
     {
     std::vector<int> v(10);
     std::iota(v.begin(), v.end(), 0);
-    std::transform_exclusive_scan(v.begin(), v.end(), v.begin(), 30, std::plus<>(), identity<>());
+    std::transform_exclusive_scan(v.begin(), v.end(), v.begin(), 30, std::plus<>(), add_ten{});
     for (size_t i = 0; i < v.size(); ++i)
-        assert(v[i] == 30 + triangle(i-1));
+        assert(v[i] == 30 + triangle(i - 1) + i * 10);
     }
 
     {
     std::vector<int> v(10);
     std::iota(v.begin(), v.end(), 1);
-    std::transform_exclusive_scan(v.begin(), v.end(), v.begin(), 40, std::plus<>(), identity<>());
+    std::transform_exclusive_scan(v.begin(), v.end(), v.begin(), 40, std::plus<>(), add_ten{});
     for (size_t i = 0; i < v.size(); ++i)
-        assert(v[i] == 40 + triangle(i));
+        assert(v[i] == 40 + triangle(i) + i * 10);
     }
 
     {
     std::vector<int> v, res;
-    std::transform_exclusive_scan(v.begin(), v.end(), std::back_inserter(res), 40, std::plus<>(), identity<>());
+    std::transform_exclusive_scan(v.begin(), v.end(), std::back_inserter(res), 40, std::plus<>(), add_ten{});
     assert(res.empty());
     }
 
 //  Make sure that the calculations are done using the init typedef
     {
     std::vector<unsigned char> v(10);
-    std::iota(v.begin(), v.end(), 1);
+    std::iota(v.begin(), v.end(), static_cast<unsigned char>(1));
     std::vector<int> res;
-    std::transform_exclusive_scan(v.begin(), v.end(), std::back_inserter(res), 1, std::multiplies<>(), identity<>());
+    std::transform_exclusive_scan(v.begin(), v.end(), std::back_inserter(res), 1, std::multiplies<>(), add_ten{});
 
     assert(res.size() == 10);
     int j = 1;
     assert(res[0] == 1);
     for (size_t i = 1; i < res.size(); ++i)
     {
-        j *= i;
+        j *= i + 10;
         assert(res[i] == j);
     }
     }
 }
 
 int main()
 {
     basic_tests();

test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp

 //          class BinaryOperation, class UnaryOperation>
 //   OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
 //                                           OutputIterator result,
 //                                           BinaryOperation binary_op,
 //                                           UnaryOperation unary_op);
 
 
 #include <numeric>
-#include <vector>
+#include <algorithm>
 #include <cassert>
+#include <functional>
 #include <iostream>
+#include <iterator>
+#include <vector>
 
 #include "test_iterators.h"
 
-template <class T = void>
-struct identity : std::unary_function<T, T>
-{
-    constexpr const T& operator()(const T& x) const { return x;}
-};
-
-template <>
-struct identity<void>
-{
-    template <class T>
-    constexpr auto operator()(T&& x) const
-    _NOEXCEPT_(noexcept(_VSTD::forward<T>(x)))
-    -> decltype        (_VSTD::forward<T>(x))
-        { return        _VSTD::forward<T>(x); }
+struct add_ten {
+    template <typename T>
+    constexpr auto operator()(T x) const noexcept {
+        return static_cast<T>(x + 10);
+    }
 };
 
 template <class Iter1, class BOp, class UOp, class Iter2>
 void
 test(Iter1 first, Iter1 last, BOp bop, UOp uop, Iter2 rFirst, Iter2 rLast)
 {
     std::vector<typename std::iterator_traits<Iter1>::value_type> v;
 //  Test not in-place
     std::transform_inclusive_scan(first, last, std::back_inserter(v), bop, uop);
     assert(std::equal(v.begin(), v.end(), rFirst, rLast));
 
 //  Test in-place
     v.clear();
     v.assign(first, last);
     std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), bop, uop);
     assert(std::equal(v.begin(), v.end(), rFirst, rLast));
 }
 
 
 template <class Iter>
 void
 test()
 {
           int ia[]     = {  1,  3,   5,   7,    9};
-    const int pResI0[] = {  1,  4,   9,  16,   25};        // with identity
-    const int mResI0[] = {  1,  3,  15, 105,  945};
+    const int pResI0[] = { 11, 24,  39,  56,   75};        // with add_ten
+    const int mResI0[] = { 11, 143, 2145, 36465, 692835};
     const int pResN0[] = { -1, -4,  -9, -16,  -25};        // with negate
     const int mResN0[] = { -1,  3, -15, 105, -945};
     const unsigned sa = sizeof(ia) / sizeof(ia[0]);
     static_assert(sa == sizeof(pResI0) / sizeof(pResI0[0]));       // just to be sure
     static_assert(sa == sizeof(mResI0) / sizeof(mResI0[0]));       // just to be sure
     static_assert(sa == sizeof(pResN0) / sizeof(pResN0[0]));       // just to be sure
     static_assert(sa == sizeof(mResN0) / sizeof(mResN0[0]));       // just to be sure
 
     for (unsigned int i = 0; i < sa; ++i ) {
-        test(Iter(ia), Iter(ia + i), std::plus<>(),       identity<>(),    pResI0, pResI0 + i);
-        test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity<>(),    mResI0, mResI0 + i);
+        test(Iter(ia), Iter(ia + i), std::plus<>(),       add_ten{},       pResI0, pResI0 + i);
+        test(Iter(ia), Iter(ia + i), std::multiplies<>(), add_ten{},       mResI0, mResI0 + i);
         test(Iter(ia), Iter(ia + i), std::plus<>(),       std::negate<>(), pResN0, pResN0 + i);
         test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), mResN0, mResN0 + i);
         }
 }
 
 int triangle(int n) { return n*(n+1)/2; }
 
 //  Basic sanity
 void basic_tests()
 {
     {
     std::vector<int> v(10);
     std::fill(v.begin(), v.end(), 3);
-    std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity<>());
+    std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), add_ten{});
     std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
     std::cout << std::endl;
     for (size_t i = 0; i < v.size(); ++i)
-        assert(v[i] == (int)(i+1) * 3);
+        assert(v[i] == (int)(i+1) * 13);
     }
 
     {
     std::vector<int> v(10);
     std::iota(v.begin(), v.end(), 0);
-    std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity<>());
+    std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), add_ten{});
     for (size_t i = 0; i < v.size(); ++i)
-        assert(v[i] == triangle(i));
+        assert(v[i] == triangle(i) + (i + 1) * 10);
     }
 
     {
     std::vector<int> v(10);
     std::iota(v.begin(), v.end(), 1);
-    std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity<>());
+    std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), add_ten{});
     for (size_t i = 0; i < v.size(); ++i)
-        assert(v[i] == triangle(i + 1));
+        assert(v[i] == triangle(i + 1) + (i + 1) * 10);
     }
 
     {
     std::vector<int> v, res;
-    std::transform_inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::plus<>(), identity<>());
+    std::transform_inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::plus<>(), add_ten{});
     assert(res.empty());
     }
 }
 
 int main()
 {
     basic_tests();
 
 //  All the iterator categories
     test<input_iterator        <const int*> >();
     test<forward_iterator      <const int*> >();
     test<bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*> >();
     test<const int*>();
     test<      int*>();
 }

test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp

 //   OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
 //                                           OutputIterator result,
 //                                           BinaryOperation binary_op,
 //                                           UnaryOperation unary_op,
 //                                           T init);
 
 
 #include <numeric>
-#include <vector>
+#include <algorithm>
 #include <cassert>
+#include <functional>
+#include <iterator>
+#include <vector>
 
 #include "test_iterators.h"
 
-template <class T = void>
-struct identity : std::unary_function<T, T>
-{
-    constexpr const T& operator()(const T& x) const { return x;}
-};
-
-template <>
-struct identity<void>
-{
-    template <class T>
-    constexpr auto operator()(T&& x) const
-    _NOEXCEPT_(noexcept(_VSTD::forward<T>(x)))
-    -> decltype        (_VSTD::forward<T>(x))
-        { return        _VSTD::forward<T>(x); }
+struct add_ten {
+    template <typename T>
+    constexpr auto operator()(T x) const noexcept {
+        return static_cast<T>(x + 10);
+    }
 };
 
 template <class Iter1, class BOp, class UOp, class T, class Iter2>
 void
 test(Iter1 first, Iter1 last, BOp bop, UOp uop, T init, Iter2 rFirst, Iter2 rLast)
 {
     std::vector<typename std::iterator_traits<Iter1>::value_type> v;
 //  Test not in-place
     std::transform_inclusive_scan(first, last, std::back_inserter(v), bop, uop, init);
     assert(std::equal(v.begin(), v.end(), rFirst, rLast));
 
 //  Test in-place
     v.clear();
     v.assign(first, last);
     std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), bop, uop, init);
     assert(std::equal(v.begin(), v.end(), rFirst, rLast));
 }
 
 
 template <class Iter>
 void
 test()
 {
           int ia[]     = {  1,  3,   5,    7,     9};
-    const int pResI0[] = {  1,  4,   9,   16,    25};        // with identity
+    const int pResI0[] = { 11, 24,  39,   56,    75};        // with add_ten
     const int mResI0[] = {  0,  0,   0,    0,     0};
     const int pResN0[] = { -1, -4,  -9,  -16,   -25};        // with negate
     const int mResN0[] = {  0,  0,   0,    0,     0};
-    const int pResI2[] = {  3,  6,  11,   18,    27};        // with identity
-    const int mResI2[] = {  2,  6,  30,  210,  1890};
+    const int pResI2[] = { 13, 26,  41,   58,    77};        // with add_ten
+    const int mResI2[] = { 22, 286, 4290, 72930, 1385670};
     const int pResN2[] = {  1, -2,  -7,  -14,   -23};        // with negate
     const int mResN2[] = { -2,  6, -30,  210, -1890};
     const unsigned sa = sizeof(ia) / sizeof(ia[0]);
     static_assert(sa == sizeof(pResI0) / sizeof(pResI0[0]));       // just to be sure
     static_assert(sa == sizeof(mResI0) / sizeof(mResI0[0]));       // just to be sure
     static_assert(sa == sizeof(pResN0) / sizeof(pResN0[0]));       // just to be sure
     static_assert(sa == sizeof(mResN0) / sizeof(mResN0[0]));       // just to be sure
     static_assert(sa == sizeof(pResI2) / sizeof(pResI2[0]));       // just to be sure
     static_assert(sa == sizeof(mResI2) / sizeof(mResI2[0]));       // just to be sure
     static_assert(sa == sizeof(pResN2) / sizeof(pResN2[0]));       // just to be sure
     static_assert(sa == sizeof(mResN2) / sizeof(mResN2[0]));       // just to be sure
 
     for (unsigned int i = 0; i < sa; ++i ) {
-        test(Iter(ia), Iter(ia + i), std::plus<>(),       identity<>(),    0, pResI0, pResI0 + i);
-        test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity<>(),    0, mResI0, mResI0 + i);
+        test(Iter(ia), Iter(ia + i), std::plus<>(),       add_ten{},       0, pResI0, pResI0 + i);
+        test(Iter(ia), Iter(ia + i), std::multiplies<>(), add_ten{},       0, mResI0, mResI0 + i);
         test(Iter(ia), Iter(ia + i), std::plus<>(),       std::negate<>(), 0, pResN0, pResN0 + i);
         test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), 0, mResN0, mResN0 + i);
-        test(Iter(ia), Iter(ia + i), std::plus<>(),       identity<>(),    2, pResI2, pResI2 + i);
-        test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity<>(),    2, mResI2, mResI2 + i);
+        test(Iter(ia), Iter(ia + i), std::plus<>(),       add_ten{},       2, pResI2, pResI2 + i);
+        test(Iter(ia), Iter(ia + i), std::multiplies<>(), add_ten{},       2, mResI2, mResI2 + i);
         test(Iter(ia), Iter(ia + i), std::plus<>(),       std::negate<>(), 2, pResN2, pResN2 + i);
         test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), 2, mResN2, mResN2 + i);
         }
 }
 
 int triangle(int n) { return n*(n+1)/2; }
 
 //  Basic sanity
 void basic_tests()
 {
     {
     std::vector<int> v(10);
     std::fill(v.begin(), v.end(), 3);
-    std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity<>(), 50);
+    std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), add_ten{}, 50);
     for (size_t i = 0; i < v.size(); ++i)
-        assert(v[i] == 50 + (int) (i + 1) * 3);
+        assert(v[i] == 50 + (int) (i + 1) * 13);
     }
 
     {
     std::vector<int> v(10);
     std::iota(v.begin(), v.end(), 0);
-    std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity<>(), 30);
+    std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), add_ten{}, 30);
     for (size_t i = 0; i < v.size(); ++i)
-        assert(v[i] == 30 + triangle(i));
+        assert(v[i] == 30 + triangle(i) + (i + 1) * 10);
     }
 
     {
     std::vector<int> v(10);
     std::iota(v.begin(), v.end(), 1);
-    std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity<>(), 40);
+    std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), add_ten{}, 40);
     for (size_t i = 0; i < v.size(); ++i)
-        assert(v[i] == 40 + triangle(i + 1));
+        assert(v[i] == 40 + triangle(i + 1) + (i + 1) * 10);
     }
 
     {
     std::vector<int> v, res;
-    std::transform_inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::plus<>(), identity<>(), 1);
+    std::transform_inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::plus<>(), add_ten{}, 1);
     assert(res.empty());
     }
 
 //  Make sure that the calculations are done using the init typedef
     {
     std::vector<unsigned char> v(10);
-    std::iota(v.begin(), v.end(), 1);
+    std::iota(v.begin(), v.end(), static_cast<unsigned char>(1));
     std::vector<int> res;
-    std::transform_inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::multiplies<>(), identity<>(), 1);
+    std::transform_inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::multiplies<>(), add_ten{}, 1);
 
     assert(res.size() == 10);
-    int j = 1;
-    assert(res[0] == 1);
+    int j = 11;
+    assert(res[0] == 11);
     for (size_t i = 1; i < res.size(); ++i)
     {
-        j *= i + 1;
+        j *= i + 11;
         assert(res[i] == j);
     }
     }
 }
 
 int main()
 {
     basic_tests();