Qualify calls to Boost.Algorithm algs that have the same name as ones in the standard; prevents ADL ambiguities. Thanks to Billy O'Neill for the heads up.

include/boost/algorithm/cxx17/exclusive_scan.hpp

@@ -44,7 +44,7 @@ OutputIterator exclusive_scan(InputIterator first, InputIterator last,
                               OutputIterator result, T init)
 {
 	typedef typename std::iterator_traits<InputIterator>::value_type VT;
-    return exclusive_scan(first, last, result, init, std::plus<VT>());
+    return boost::algorithm::exclusive_scan(first, last, result, init, std::plus<VT>());
 }
 
 }} // namespace boost and algorithm

include/boost/algorithm/cxx17/inclusive_scan.hpp

@@ -41,7 +41,7 @@ OutputIterator inclusive_scan(InputIterator first, InputIterator last,
         typename std::iterator_traits<InputIterator>::value_type init = *first;
         *result++ = init;
         if (++first != last)
-            return inclusive_scan(first, last, result, bOp, init);
+            return boost::algorithm::inclusive_scan(first, last, result, bOp, init);
         }
 
     return result;
@@ -52,7 +52,7 @@ OutputIterator inclusive_scan(InputIterator first, InputIterator last,
                    OutputIterator result)
 {
     typedef typename std::iterator_traits<InputIterator>::value_type VT;
-    return inclusive_scan(first, last, result, std::plus<VT>());
+    return boost::algorithm::inclusive_scan(first, last, result, std::plus<VT>());
 }
 
 }} // namespace boost and algorithm

include/boost/algorithm/cxx17/reduce.hpp

@@ -34,14 +34,14 @@ template<class InputIterator, class T>
 T reduce(InputIterator first, InputIterator last, T init)
 {
 	typedef typename std::iterator_traits<InputIterator>::value_type VT;
-    return reduce(first, last, init, std::plus<VT>());
+    return boost::algorithm::reduce(first, last, init, std::plus<VT>());
 }
 
 template<class InputIterator>
 typename std::iterator_traits<InputIterator>::value_type
 reduce(InputIterator first, InputIterator last)
 {
-    return reduce(first, last,
+    return boost::algorithm::reduce(first, last,
        typename std::iterator_traits<InputIterator>::value_type());
 }
 
@@ -49,14 +49,14 @@ template<class Range>
 typename boost::range_value<Range>::type
 reduce(const Range &r)
 {
-    return reduce(boost::begin(r), boost::end(r));
+    return boost::algorithm::reduce(boost::begin(r), boost::end(r));
 }
 
 //	Not sure that this won't be ambiguous (1)
 template<class Range, class T>
 T reduce(const Range &r, T init)
 {
-    return reduce(boost::begin (r), boost::end (r), init);
+    return boost::algorithm::reduce(boost::begin (r), boost::end (r), init);
 }
 
 
@@ -64,7 +64,7 @@ T reduce(const Range &r, T init)
 template<class Range, class T, class BinaryOperation>
 T reduce(const Range &r, T init, BinaryOperation bOp)
 {
-    return reduce(boost::begin(r), boost::end(r), init, bOp);
+    return boost::algorithm::reduce(boost::begin(r), boost::end(r), init, bOp);
 }
 
 }} // namespace boost and algorithm

include/boost/algorithm/cxx17/transform_inclusive_scan.hpp

@@ -46,7 +46,8 @@ OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
         typename std::iterator_traits<InputIterator>::value_type init = uOp(*first);
         *result++ = init;
         if (++first != last)
-            return transform_inclusive_scan(first, last, result, bOp, uOp, init);
+            return boost::algorithm::transform_inclusive_scan
+                                              (first, last, result, bOp, uOp, init);
         }
 
     return result;

include/boost/algorithm/cxx17/transform_reduce.hpp

@@ -46,7 +46,7 @@ template<class InputIterator1, class InputIterator2, class T>
 T transform_reduce(InputIterator1 first1, InputIterator1 last1,
                    InputIterator2 first2, T init)
 {
-    return transform_reduce(first1, last1, first2, init,
+    return boost::algorithm::transform_reduce(first1, last1, first2, init,
                             std::plus<T>(), std::multiplies<T>());
 }