Возможность компиляции в C++17

include/burst/container/k_ary_search_set.hpp

@@ -289,7 +289,7 @@ namespace burst
         void initialize (const RandomAccessRange & range)
         {
             const auto is_sorted_and_unique =
-                std::adjacent_find(range.begin(), range.end(), not_fn(m_compare)) == range.end();
+                std::adjacent_find(range.begin(), range.end(), burst::not_fn(m_compare)) == range.end();
             if (is_sorted_and_unique)
             {
                 initialize_trusted(range);
@@ -300,7 +300,7 @@ namespace burst
                 std::sort(buffer.begin(), buffer.end(), m_compare);
                 buffer.erase
                 (
-                    std::unique(buffer.begin(), buffer.end(), not_fn(m_compare)),
+                    std::unique(buffer.begin(), buffer.end(), burst::not_fn(m_compare)),
                     buffer.end()
                 );
 
@@ -325,7 +325,7 @@ namespace burst
         {
             BOOST_ASSERT
             (
-                std::adjacent_find(range.begin(), range.end(), not_fn(m_compare)) == range.end()
+                std::adjacent_find(range.begin(), range.end(), burst::not_fn(m_compare)) == range.end()
             );
             if (not range.empty())
             {

include/burst/functional/non_strict.hpp

@@ -15,7 +15,7 @@ namespace burst
     template <typename BinaryPredicate>
     auto non_strict (BinaryPredicate && strict_order)
     {
-        return not_fn(invert(std::forward<BinaryPredicate>(strict_order)));
+        return burst::not_fn(invert(std::forward<BinaryPredicate>(strict_order)));
     }
 }
 

include/burst/functional/part.hpp

@@ -24,21 +24,21 @@ namespace burst
         template <typename ... As>
         constexpr decltype(auto) operator () (As && ... as) const &
         {
-            return apply(invoke,
+            return burst::apply(invoke,
                 std::tuple_cat(forward_tuple(t), std::forward_as_tuple(std::forward<As>(as)...)));
         }
 
         template <typename ... As>
         constexpr decltype(auto) operator () (As && ... as) &
         {
-            return apply(invoke,
+            return burst::apply(invoke,
                 std::tuple_cat(forward_tuple(t), std::forward_as_tuple(std::forward<As>(as)...)));
         }
 
         template <typename ... As>
         constexpr decltype(auto) operator () (As && ... as) &&
         {
-            return apply(invoke,
+            return burst::apply(invoke,
                 std::tuple_cat(forward_tuple(std::move(t)), std::forward_as_tuple(std::forward<As>(as)...)));
         }
 

include/burst/range/adaptor/adaptor.hpp

@@ -56,7 +56,7 @@ namespace burst
     auto operator | (Range && range, adaptor_compare_forwarder_t<Adaptor, Tuple> forwarder)
     {
         return
-            apply
+            burst::apply
             (
                 forwarder.adaptor,
                 std::tuple_cat

include/burst/tuple/apply.hpp

@@ -34,19 +34,19 @@ namespace burst
         template <typename Tuple>
         constexpr decltype(auto) operator () (Tuple && t) const &
         {
-            return apply(f, std::forward<Tuple>(t));
+            return burst::apply(f, std::forward<Tuple>(t));
         }
 
         template <typename Tuple>
         constexpr decltype(auto) operator () (Tuple && t) &
         {
-            return apply(f, std::forward<Tuple>(t));
+            return burst::apply(f, std::forward<Tuple>(t));
         }
 
         template <typename Tuple>
         constexpr decltype(auto) operator () (Tuple && t) &&
         {
-            return apply(std::move(f), std::forward<Tuple>(t));
+            return burst::apply(std::move(f), std::forward<Tuple>(t));
         }
 
         NaryFunction f;

include/burst/tuple/forward_tuple.hpp

@@ -24,7 +24,7 @@ namespace burst
         template <typename T>
         constexpr decltype(auto) operator () (T && t) const
         {
-            return apply(forward_as_tuple, std::forward<T>(t));
+            return burst::apply(forward_as_tuple, std::forward<T>(t));
         }
     };