Index: test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp
+++ test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp
@@ -16,8 +16,11 @@
 //
 
 #include <numeric>
-#include <vector>
+#include <algorithm>
 #include <cassert>
+#include <functional>
+#include <iterator>
+#include <vector>
 
 #include "test_iterators.h"
 
Index: test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp
+++ test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp
@@ -17,8 +17,11 @@
 //                    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"
 
@@ -70,7 +73,7 @@
 //  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<>());
 
Index: test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp
+++ test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp
@@ -16,8 +16,11 @@
 //
 
 #include <numeric>
-#include <vector>
+#include <algorithm>
 #include <cassert>
+#include <functional>
+#include <iterator>
+#include <vector>
 
 #include "test_iterators.h"
 
Index: test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
+++ test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
@@ -17,9 +17,12 @@
 //                    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"
 
Index: test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp
+++ test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp
@@ -17,8 +17,11 @@
 //                    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"
 
@@ -95,7 +98,7 @@
 //  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);
 
Index: test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
+++ test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
@@ -19,27 +19,16 @@
 
 
 #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); }
-};
+const auto identity = [](auto&& x) { return std::forward<decltype(x)>(x); };
 
 template <class Iter1, class BOp, class UOp, class T, class Iter2>
 void
@@ -82,12 +71,12 @@
     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<>(),       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<>(),       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<>(),       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<>(),       std::negate<>(), 2, pResN2, pResN2 + i);
         test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), 2, mResN2, mResN2 + i);
         }
@@ -101,7 +90,7 @@
     {
     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<>(), identity);
     for (size_t i = 0; i < v.size(); ++i)
         assert(v[i] == 50 + (int) i * 3);
     }
@@ -109,7 +98,7 @@
     {
     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<>(), identity);
     for (size_t i = 0; i < v.size(); ++i)
         assert(v[i] == 30 + triangle(i-1));
     }
@@ -117,23 +106,23 @@
     {
     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<>(), identity);
     for (size_t i = 0; i < v.size(); ++i)
         assert(v[i] == 40 + triangle(i));
     }
 
     {
     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<>(), identity);
     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<>(), identity);
 
     assert(res.size() == 10);
     int j = 1;
Index: test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp
+++ test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp
@@ -20,27 +20,16 @@
 
 
 #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); }
-};
+const auto identity = [](auto&& x) { return std::forward<decltype(x)>(x); };
 
 template <class Iter1, class BOp, class UOp, class Iter2>
 void
@@ -75,8 +64,8 @@
     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<>(),       identity,    pResI0, pResI0 + i);
+        test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity,    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);
         }
@@ -90,7 +79,7 @@
     {
     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<>(), identity);
     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)
@@ -100,7 +89,7 @@
     {
     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<>(), identity);
     for (size_t i = 0; i < v.size(); ++i)
         assert(v[i] == triangle(i));
     }
@@ -108,14 +97,14 @@
     {
     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<>(), identity);
     for (size_t i = 0; i < v.size(); ++i)
         assert(v[i] == triangle(i + 1));
     }
 
     {
     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<>(), identity);
     assert(res.empty());
     }
 }
Index: test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp
+++ test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp
@@ -20,26 +20,15 @@
 
 
 #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); }
-};
+const auto identity = [](auto&& x) { return std::forward<decltype(x)>(x); };
 
 template <class Iter1, class BOp, class UOp, class T, class Iter2>
 void
@@ -82,12 +71,12 @@
     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<>(),       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<>(),       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<>(),       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<>(),       std::negate<>(), 2, pResN2, pResN2 + i);
         test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), 2, mResN2, mResN2 + i);
         }
@@ -101,7 +90,7 @@
     {
     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<>(), identity, 50);
     for (size_t i = 0; i < v.size(); ++i)
         assert(v[i] == 50 + (int) (i + 1) * 3);
     }
@@ -109,7 +98,7 @@
     {
     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<>(), identity, 30);
     for (size_t i = 0; i < v.size(); ++i)
         assert(v[i] == 30 + triangle(i));
     }
@@ -117,23 +106,23 @@
     {
     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<>(), identity, 40);
     for (size_t i = 0; i < v.size(); ++i)
         assert(v[i] == 40 + triangle(i + 1));
     }
 
     {
     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<>(), identity, 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<>(), identity, 1);
 
     assert(res.size() == 10);
     int j = 1;