[PATCH 1/3] libstdc++: Eliminate __gnu_cxx::__ops function objects
Tomasz Kaminski
tkaminsk@redhat.com
Thu Sep 25 14:36:55 GMT 2025
On Thu, Sep 25, 2025 at 4:21 PM Jonathan Wakely <jwakely@redhat.com> wrote:
> This removes the indirect functors from <bits/predefined_ops.h> that are
> used by our STL algorithms. Currently we wrap all predicates and values
> into callables which accept iterator arguments, and automatically
> dereference the iterators. With this change we no longer do that
> dereferencing and so all predicates are passed values not iterators, and
> the algorithms that invoke those predicates must dereference the
> iterators.
>
> This avoids wrapping user-provided predicates into another predicate
> that does the dereferencing. User-provided predicates are now passed
> unchanged to our internal algos like __search_n. For the overloads that
> take a value instead of a predicate, we still need to create a predicate
> that does comparison to the value, but we can now use std::less<void>
> and std::equal_to<void> as the base predicate and bind the value to
> those base predicates.
>
> Because the "transparent operators" std::less<void> and
> std::equal_to<void> were not added until C++14, this change defines
> those explicit specializations unconditionally for C++98 and C++11 too
> (but the default template arguments that make std::less<> and
> std::equal_to<> refer to those specializations are still only present
> for C++14 and later, because we don't need to rely on those default
> template arguments for our internal uses).
>
> When binding a predicate and a value into a new call wrapper, we now
> decide whether to store the predicate by value when it's an empty type
> or a scalar (such as a function pointer). This avoids a
> double-indirection through function pointers, and avoids storing and
> invoking stateless empty functors through a reference. For C++11 and
> later we also use [[no_unique_address]] to avoid wasted storage for
> empty predicates (which includes all standard relational ops, such as
> std::less).
>
> The call wrappers in bits/predefined_ops.h all have non-const operator()
> because we can't be sure that the predicates they wrap are
> const-invocable. The requirements in [algorithms.requirements] for
> Predicate and BinaryPredicate template arguments require pred(*i) to be
> valid, but do not require that std::to_const(pred)(*i) has to be valid,
> and similarly for binary_pred.
>
> libstdc++-v3/ChangeLog:
>
> * include/bits/predefined_ops.h (equal_to, less): Define aliases
> for std::equal_to<void> and std::less<void>.
> (bind1st, bind2nd, not1, __equal_to): New object generator
> functions for adapting predicates.
> (__iter_less_iter, __iter_less_val, __iter_comp_val)
> (__val_less_iter, __val_comp_iter, __iter_equal_to_iter)
> (__iter_equal_to_val, __iter_comp_iter, __negate): Remove all
> object generator functions and the class templates they return.
> * include/bits/stl_algo.h (__move_median_to_first, __find_if_not)
> (__find_if_not_n, __search_n_aux, find_end, find_if_not)
> (__remove_copy_if, remove_copy, remove_copy_if, remove)
> (remove_if, __adjacent_find, __unique, unique, __unique_copy)
> (__unique_copy_1, __stable_partition_adaptive, stable_partition)
> (__heap_select, __partial_sort_copy, partial_sort_copy)
> (__unguarded_linear_insert, __insertion_sort)
> (__unguarded_insertion_sort, __unguarded_partition)
> (lower_bound, __upper_bound, upper_bound, __equal_range)
> (equal_range, binary_search, __move_merge_adaptive)
> (__move_merge_adaptive_backward, __merge_adaptive_resize)
> (__merge_without_buffer, inplace_merge, __move_merge)
> (__includes, includes, __next_permutation, next_permutation)
> (__prev_permutation, prev_permutation, __replace_copy_if)
> (replace_copy, replace_copy_if, __is_sorted_until)
> (is_sorted_until, __minmax_element, minmax_element, minmax)
> (is_permutation, __is_permutation, find, find_if, adjacent_find)
> (count, count_if, search, search_n, unique_copy, partial_sort)
> (nth_element, sort, __merge, merge, stable_sort, __set_union)
> (set_union, __set_intersection, set_intersection)
> (__set_difference, set_difference, __set_symmetric_difference)
> (set_symmetric_difference, __min_element, min_element)
> (__max_element, max_element, min, max): Use direct predicates
> instead of __iter_equal_to_iter, __iter_comp_iter, and
> __iter_less_iter, __negate etc. Dereference iterators when
> invoking predicates.
> * include/bits/stl_algobase.h (__lexicographical_compare_impl)
> (__lexicographical_compare::__lc, __lower_bound, lower_bound)
> (lexicographical_compare, __mismatch, mismatch, __find_if)
> (__count_if, __remove_if, __search, __is_permutation)
> (is_permutation, search): Likewise.
> * include/bits/stl_function.h (equal_to<void>, less<void>):
> Define transparent comparison functions for C++98 and C++11.
> * include/bits/stl_heap.h (__is_heap_until, __is_heap)
> (__push_heap, push_heap, __adjust_heap, pop_heap, make_heap)
> (sort_heap, is_heap_until, is_heap): Likewise.
> * include/std/deque (erase_if): Remove call to __pred_iter.
> (erase): Replace __iter_equals_val with __equal_to.
> * include/std/inplace_vector (erase_if, erase): Likewise.
> * include/std/string (erase_if, erase): Likewise.
> * include/std/vector (erase_if, erase): Likewise.
>
> ---
>
> Tested powerpc64le-linux and x86_64-linux.
>
> Most of this was already reviewed by Tomasz and François on the forge:
> https://forge.sourceware.org/gcc/gcc-TEST/pulls/78
>
> The changes relative to the code there are:
>
> - bind1st, bind2nd and not1 functions that create the call wrappers take
> the target callable by lvalue reference not forwarding reference, to
> prevent binding a dangling reference to a prvalue. This also ensures
> that the __by_ref_or_value_fn helper works as intended and we store
> empty types and function pointers by value not by reference.
>
> - _Comp_with_val and _Unary_negate call wrappers have a non-const
> operator() (as explained in the commit message above). This change was
> needed because fixing the type deduction to store _Func instead of
> _Func& meant that we could no longer call non-const _Func::operator()
> when the call wrapper's operator() was const.
>
> The changes to the algos themselves didn't change, except for splitting
> some changes out into the next patch in this series.
>
> libstdc++-v3/include/bits/predefined_ops.h | 477 +++++++--------------
> libstdc++-v3/include/bits/stl_algo.h | 399 ++++++++---------
> libstdc++-v3/include/bits/stl_algobase.h | 54 +--
> libstdc++-v3/include/bits/stl_function.h | 52 +++
> libstdc++-v3/include/bits/stl_heap.h | 53 +--
> libstdc++-v3/include/std/deque | 4 +-
> libstdc++-v3/include/std/inplace_vector | 4 +-
> libstdc++-v3/include/std/string | 4 +-
> libstdc++-v3/include/std/vector | 4 +-
> 9 files changed, 428 insertions(+), 623 deletions(-)
>
> diff --git a/libstdc++-v3/include/bits/predefined_ops.h
> b/libstdc++-v3/include/bits/predefined_ops.h
> index 5759ebd0e5bc..5940d64ba350 100644
> --- a/libstdc++-v3/include/bits/predefined_ops.h
> +++ b/libstdc++-v3/include/bits/predefined_ops.h
> @@ -30,376 +30,193 @@
> #ifndef _GLIBCXX_PREDEFINED_OPS_H
> #define _GLIBCXX_PREDEFINED_OPS_H 1
>
> -#include <bits/move.h>
> +#include <bits/stl_function.h> // less<void>, equal_to<void>
> +#if __cplusplus >= 201103L
> +# include <type_traits> // is_empty, is_scalar, __conditional_t,
> __or_
> +#else
> +# include <ext/type_traits.h> // __conditional_type
> +#endif
>
> namespace __gnu_cxx
> {
> namespace __ops
> {
> - struct _Iter_less_iter
> - {
> - template<typename _Iterator1, typename _Iterator2>
> - _GLIBCXX14_CONSTEXPR
> - bool
> - operator()(_Iterator1 __it1, _Iterator2 __it2) const
> - { return *__it1 < *__it2; }
> - };
> + // These two explicit specializations are always defined by libstdc++,
> + // even when __cpp_lib_transparent_operators is not defined.
> + typedef std::equal_to<void> equal_to;
> + typedef std::less<void> less;
>
> - _GLIBCXX14_CONSTEXPR
> - inline _Iter_less_iter
> - __iter_less_iter()
> - { return _Iter_less_iter(); }
> -
> - struct _Iter_less_val
> - {
> #if __cplusplus >= 201103L
> - constexpr _Iter_less_val() = default;
> -#else
> - _Iter_less_val() { }
> -#endif
>
> - _GLIBCXX20_CONSTEXPR
> - explicit
> - _Iter_less_val(_Iter_less_iter) { }
> + template<typename _Fn>
> + using __by_ref_or_value_fn
> + = std::__conditional_t<std::__or_<std::is_empty<_Fn>,
> + std::is_scalar<_Fn>>::value,
> + _Fn, _Fn&>;
>
> - template<typename _Iterator, typename _Value>
> - _GLIBCXX20_CONSTEXPR
> - bool
> - operator()(_Iterator __it, _Value& __val) const
> - { return *__it < __val; }
> - };
> + // More generic replacements for the deprecated utilities
> + // std::bind1st, std::bind2nd, and std::not1.
> + // These aren't fully "transparent" like std::less<void> because they
> + // do not use perfect forwarding, everything is treated as an lvalue.
>
> - _GLIBCXX20_CONSTEXPR
> - inline _Iter_less_val
> - __iter_less_val()
> - { return _Iter_less_val(); }
> -
> - _GLIBCXX20_CONSTEXPR
> - inline _Iter_less_val
> - __iter_comp_val(_Iter_less_iter)
> - { return _Iter_less_val(); }
> -
> - struct _Val_less_iter
> - {
> -#if __cplusplus >= 201103L
> - constexpr _Val_less_iter() = default;
> -#else
> - _Val_less_iter() { }
> -#endif
> -
> - _GLIBCXX20_CONSTEXPR
> - explicit
> - _Val_less_iter(_Iter_less_iter) { }
> -
> - template<typename _Value, typename _Iterator>
> - _GLIBCXX20_CONSTEXPR
> - bool
> - operator()(_Value& __val, _Iterator __it) const
> - { return __val < *__it; }
> - };
> -
> - _GLIBCXX20_CONSTEXPR
> - inline _Val_less_iter
> - __val_less_iter()
> - { return _Val_less_iter(); }
> -
> - _GLIBCXX20_CONSTEXPR
> - inline _Val_less_iter
> - __val_comp_iter(_Iter_less_iter)
> - { return _Val_less_iter(); }
> -
> - struct _Iter_equal_to_iter
> - {
> - template<typename _Iterator1, typename _Iterator2>
> - _GLIBCXX20_CONSTEXPR
> - bool
> - operator()(_Iterator1 __it1, _Iterator2 __it2) const
> - { return *__it1 == *__it2; }
> - };
> -
> - _GLIBCXX20_CONSTEXPR
> - inline _Iter_equal_to_iter
> - __iter_equal_to_iter()
> - { return _Iter_equal_to_iter(); }
> -
> - struct _Iter_equal_to_val
> - {
> - template<typename _Iterator, typename _Value>
> - _GLIBCXX20_CONSTEXPR
> - bool
> - operator()(_Iterator __it, _Value& __val) const
> - { return *__it == __val; }
> - };
> -
> - _GLIBCXX20_CONSTEXPR
> - inline _Iter_equal_to_val
> - __iter_equal_to_val()
> - { return _Iter_equal_to_val(); }
> -
> - _GLIBCXX20_CONSTEXPR
> - inline _Iter_equal_to_val
> - __iter_comp_val(_Iter_equal_to_iter)
> - { return _Iter_equal_to_val(); }
> -
> - template<typename _Compare>
> - struct _Iter_comp_iter
> + template<typename _Func, typename _Value, bool _Val_2nd = false>
> + struct _Comp_with_val
> {
> - _Compare _M_comp;
> + using _Fn = __by_ref_or_value_fn<_Func>;
>
> - explicit _GLIBCXX14_CONSTEXPR
> - _Iter_comp_iter(_Compare __comp)
> - : _M_comp(_GLIBCXX_MOVE(__comp))
> - { }
> + explicit constexpr
> + _Comp_with_val(_Fn __f, const _Value& __v)
> + : _M_f(__f), _M_val(__v) { }
>
> - template<typename _Iterator1, typename _Iterator2>
> - _GLIBCXX14_CONSTEXPR
> - bool
> - operator()(_Iterator1 __it1, _Iterator2 __it2)
> - { return bool(_M_comp(*__it1, *__it2)); }
> + [[__no_unique_address__]] _Fn _M_f;
> + const _Value& _M_val;
> +
> + template<typename _Tp>
> + _GLIBCXX14_CONSTEXPR bool
> + operator()(_Tp&& __arg)
> + {
> +#pragma GCC diagnostic push
> +#pragma GCC diagnostic ignored "-Wc++17-extensions"
> + if constexpr (_Val_2nd)
> + return _M_f(__arg, _M_val);
> + else
> + return _M_f(_M_val, __arg);
> +#pragma GCC diagnostic pop
> + }
> };
>
> - template<typename _Compare>
> - _GLIBCXX14_CONSTEXPR
> - inline _Iter_comp_iter<_Compare>
> - __iter_comp_iter(_Compare __comp)
> - { return _Iter_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp)); }
> + template<typename _Func, typename _Value>
> + using _Comp_with_val_1st = _Comp_with_val<_Func, _Value, false>;
> + template<typename _Func, typename _Value>
> + using _Comp_with_val_2nd = _Comp_with_val<_Func, _Value, true>;
>
> - template<typename _Compare>
> - struct _Iter_comp_val
> + // N.B. these functions take lvalue references because we want to avoid
> + // returning a call wrapper that has a dangling reference to a prvalue.
> +
> + template<typename _Func, typename _Value>
> + constexpr _Comp_with_val_1st<_Func, _Value>
> + bind1st(_Func& __f, const _Value& __val)
> + { return _Comp_with_val_1st<_Func, _Value>(__f, __val); }
> +
> + template<typename _Func, typename _Value>
> + constexpr _Comp_with_val_2nd<_Func, _Value>
> + bind2nd(_Func& __f, const _Value& __val)
> + { return _Comp_with_val_2nd<_Func, _Value>(__f, __val); }
> +
> + // Equivalent to bind2nd(equal_to{}, val)
> + template<typename _Value>
> + constexpr _Comp_with_val_2nd<equal_to, _Value>
> + __equal_to(const _Value& __val)
> + { return _Comp_with_val_2nd<equal_to, _Value>(equal_to(), __val); }
>
These functions are now the same in C++98 and C++11+ mode, as both
take _Func& so they are defined outside the split, as we have typedefs
that matches name.
> +
> + template<typename _Func>
> + struct _Unary_negate
> {
> - _Compare _M_comp;
> + using _Fn = __by_ref_or_value_fn<_Func>;
>
> - _GLIBCXX20_CONSTEXPR
> - explicit
> - _Iter_comp_val(_Compare __comp)
> - : _M_comp(_GLIBCXX_MOVE(__comp))
> - { }
> + explicit constexpr
> + _Unary_negate(_Fn __f) : _M_f(__f) { }
>
> - _GLIBCXX20_CONSTEXPR
> - explicit
> - _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp)
> - : _M_comp(__comp._M_comp)
> - { }
> + [[__no_unique_address__]] _Fn _M_f;
>
> -#if __cplusplus >= 201103L
> - _GLIBCXX20_CONSTEXPR
> - explicit
> - _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp)
> - : _M_comp(std::move(__comp._M_comp))
> - { }
> -#endif
> -
> - template<typename _Iterator, typename _Value>
> - _GLIBCXX20_CONSTEXPR
> - bool
> - operator()(_Iterator __it, _Value& __val)
> - { return bool(_M_comp(*__it, __val)); }
> + template<typename _Tp>
> + _GLIBCXX14_CONSTEXPR bool
> + operator()(_Tp&& __arg) { return !_M_f(__arg); }
> };
>
> - template<typename _Compare>
> - _GLIBCXX20_CONSTEXPR
> - inline _Iter_comp_val<_Compare>
> - __iter_comp_val(_Compare __comp)
> - { return _Iter_comp_val<_Compare>(_GLIBCXX_MOVE(__comp)); }
> + template<typename _Func>
> + constexpr _Unary_negate<_Func>
>
We could do a similar thing for not1, if we use _Unary_negate_1 name for
C++11 with _Unary_negate alias. And _Unary_negate name for C++98.
Not sure that is worth tho.
> + not1(_Func& __f)
> + { return _Unary_negate<_Func>(__f); }
>
> - template<typename _Compare>
> - _GLIBCXX20_CONSTEXPR
> - inline _Iter_comp_val<_Compare>
> - __iter_comp_val(_Iter_comp_iter<_Compare> __comp)
> - { return _Iter_comp_val<_Compare>(_GLIBCXX_MOVE(__comp)); }
> +#else // <= C++11
>
> - template<typename _Compare>
> - struct _Val_comp_iter
> + template<typename _Fn>
> + struct __by_ref_or_value_fn
> + : __conditional_type<__is_empty(_Fn), _Fn, _Fn&>
> + { };
> +
> + template<typename _Fn>
> + struct __by_ref_or_value_fn<_Fn*>
> + { typedef _Fn* __type; };
> +
> + // We don't use std::bind1st, std::bind2nd, or std::not1 here because
> they
> + // require adaptable function objects, i.e. with nested result_type and
> + // either argument_type or first_argument_type and second_argument_type.
> +
> + template<typename _Func, typename _Value>
> + struct _Comp_with_val_1st
> {
> - _Compare _M_comp;
> + typedef typename __by_ref_or_value_fn<_Func>::__type _Fn;
>
> - _GLIBCXX20_CONSTEXPR
> explicit
> - _Val_comp_iter(_Compare __comp)
> - : _M_comp(_GLIBCXX_MOVE(__comp))
> - { }
> + _Comp_with_val_1st(_Fn __f, const _Value& __v)
> + : _M_f(__f), _M_val(__v) { }
>
> - _GLIBCXX20_CONSTEXPR
> - explicit
> - _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp)
> - : _M_comp(__comp._M_comp)
> - { }
> + _Fn _M_f;
> + const _Value& _M_val;
>
> -#if __cplusplus >= 201103L
> - _GLIBCXX20_CONSTEXPR
> - explicit
> - _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp)
> - : _M_comp(std::move(__comp._M_comp))
> - { }
> -#endif
> -
> - template<typename _Value, typename _Iterator>
> - _GLIBCXX20_CONSTEXPR
> - bool
> - operator()(_Value& __val, _Iterator __it)
> - { return bool(_M_comp(__val, *__it)); }
> + template<typename _Tp>
> + bool operator()(_Tp& __arg) { return _M_f(_M_val, __arg); }
> + template<typename _Tp>
> + bool operator()(const _Tp& __arg) { return _M_f(_M_val, __arg); }
> };
>
> - template<typename _Compare>
> - _GLIBCXX20_CONSTEXPR
> - inline _Val_comp_iter<_Compare>
> - __val_comp_iter(_Compare __comp)
> - { return _Val_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp)); }
> + template<typename _Func, typename _Value>
> + struct _Comp_with_val_2nd
> + {
> + typedef typename __by_ref_or_value_fn<_Func>::__type _Fn;
>
> - template<typename _Compare>
> - _GLIBCXX20_CONSTEXPR
> - inline _Val_comp_iter<_Compare>
> - __val_comp_iter(_Iter_comp_iter<_Compare> __comp)
> - { return _Val_comp_iter<_Compare>(_GLIBCXX_MOVE(__comp)); }
> + explicit
> + _Comp_with_val_2nd(_Fn __f, const _Value& __v)
> + : _M_f(__f), _M_val(__v) { }
> +
> + _Fn _M_f;
> + const _Value& _M_val;
> +
> + template<typename _Tp>
> + bool operator()(_Tp& __arg) { return _M_f(__arg, _M_val); }
> + template<typename _Tp>
> + bool operator()(const _Tp& __arg) { return _M_f(__arg, _M_val); }
> + };
> +
> + template<typename _Func, typename _Value>
> + inline _Comp_with_val_1st<_Func, _Value>
> + bind1st(_Func& __f, const _Value& __val)
> + { return _Comp_with_val_1st<_Func, _Value>(__f, __val); }
> +
> + template<typename _Func, typename _Value>
> + inline _Comp_with_val_2nd<_Func, _Value>
> + bind2nd(_Func& __f, const _Value& __val)
> + { return _Comp_with_val_2nd<_Func, _Value>(__f, __val); }
>
> template<typename _Value>
> - struct _Iter_equals_val
> + inline _Comp_with_val_2nd<equal_to, _Value>
> + __equal_to(const _Value& __val)
> + { return _Comp_with_val_2nd<equal_to, _Value>(equal_to(), __val); }
> +
> + template<typename _Func>
> + struct _Unary_negate_1 // N.B. different name for C++98 to satisfy ODR
> {
> - _Value& _M_value;
> + typedef typename __by_ref_or_value_fn<_Func>::__type _Fn;
>
> - _GLIBCXX20_CONSTEXPR
> - explicit
> - _Iter_equals_val(_Value& __value)
> - : _M_value(__value)
> - { }
> + explicit _Unary_negate_1(_Fn __f) : _M_f(__f) { }
>
> - template<typename _Iterator>
> - _GLIBCXX20_CONSTEXPR
> + _Fn _M_f;
> +
> + template<typename _Tp>
> bool
> - operator()(_Iterator __it)
> - { return *__it == _M_value; }
> + operator()(_Tp& __arg) { return !_M_f(__arg); }
> + template<typename _Tp>
> + bool
> + operator()(const _Tp& __arg) { return !_M_f(__arg); }
> };
>
> - template<typename _Value>
> - _GLIBCXX20_CONSTEXPR
> - inline _Iter_equals_val<_Value>
> - __iter_equals_val(_Value& __val)
> - { return _Iter_equals_val<_Value>(__val); }
> -
> - template<typename _Iterator1>
> - struct _Iter_equals_iter
> - {
> - _Iterator1 _M_it1;
> -
> - _GLIBCXX20_CONSTEXPR
> - explicit
> - _Iter_equals_iter(_Iterator1 __it1)
> - : _M_it1(__it1)
> - { }
> -
> - template<typename _Iterator2>
> - _GLIBCXX20_CONSTEXPR
> - bool
> - operator()(_Iterator2 __it2)
> - { return *__it2 == *_M_it1; }
> - };
> -
> - template<typename _Iterator>
> - _GLIBCXX20_CONSTEXPR
> - inline _Iter_equals_iter<_Iterator>
> - __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
> - { return _Iter_equals_iter<_Iterator>(__it); }
> -
> - template<typename _Predicate>
> - struct _Iter_pred
> - {
> - _Predicate _M_pred;
> -
> - _GLIBCXX20_CONSTEXPR
> - explicit
> - _Iter_pred(_Predicate __pred)
> - : _M_pred(_GLIBCXX_MOVE(__pred))
> - { }
> -
> - template<typename _Iterator>
> - _GLIBCXX20_CONSTEXPR
> - bool
> - operator()(_Iterator __it)
> - { return bool(_M_pred(*__it)); }
> - };
> -
> - template<typename _Predicate>
> - _GLIBCXX20_CONSTEXPR
> - inline _Iter_pred<_Predicate>
> - __pred_iter(_Predicate __pred)
> - { return _Iter_pred<_Predicate>(_GLIBCXX_MOVE(__pred)); }
> -
> - template<typename _Compare, typename _Value>
> - struct _Iter_comp_to_val
> - {
> - _Compare _M_comp;
> - _Value& _M_value;
> -
> - _GLIBCXX20_CONSTEXPR
> - _Iter_comp_to_val(_Compare __comp, _Value& __value)
> - : _M_comp(_GLIBCXX_MOVE(__comp)), _M_value(__value)
> - { }
> -
> - template<typename _Iterator>
> - _GLIBCXX20_CONSTEXPR
> - bool
> - operator()(_Iterator __it)
> - { return bool(_M_comp(*__it, _M_value)); }
> - };
> -
> - template<typename _Compare, typename _Value>
> - _Iter_comp_to_val<_Compare, _Value>
> - _GLIBCXX20_CONSTEXPR
> - __iter_comp_val(_Compare __comp, _Value &__val)
> - {
> - return _Iter_comp_to_val<_Compare, _Value>(_GLIBCXX_MOVE(__comp),
> __val);
> - }
> -
> - template<typename _Compare, typename _Iterator1>
> - struct _Iter_comp_to_iter
> - {
> - _Compare _M_comp;
> - _Iterator1 _M_it1;
> -
> - _GLIBCXX20_CONSTEXPR
> - _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
> - : _M_comp(_GLIBCXX_MOVE(__comp)), _M_it1(__it1)
> - { }
> -
> - template<typename _Iterator2>
> - _GLIBCXX20_CONSTEXPR
> - bool
> - operator()(_Iterator2 __it2)
> - { return bool(_M_comp(*__it2, *_M_it1)); }
> - };
> -
> - template<typename _Compare, typename _Iterator>
> - _GLIBCXX20_CONSTEXPR
> - inline _Iter_comp_to_iter<_Compare, _Iterator>
> - __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)
> - {
> - return _Iter_comp_to_iter<_Compare, _Iterator>(
> - _GLIBCXX_MOVE(__comp._M_comp), __it);
> - }
> -
> - template<typename _Predicate>
> - struct _Iter_negate
> - {
> - _Predicate _M_pred;
> -
> - _GLIBCXX20_CONSTEXPR
> - explicit
> - _Iter_negate(_Predicate __pred)
> - : _M_pred(_GLIBCXX_MOVE(__pred))
> - { }
> -
> - template<typename _Iterator>
> - _GLIBCXX20_CONSTEXPR
> - bool
> - operator()(_Iterator __it)
> - { return !bool(_M_pred(*__it)); }
> - };
> -
> - template<typename _Predicate>
> - _GLIBCXX20_CONSTEXPR
> - inline _Iter_negate<_Predicate>
> - __negate(_Iter_pred<_Predicate> __pred)
> - { return _Iter_negate<_Predicate>(_GLIBCXX_MOVE(__pred._M_pred)); }
> + template<typename _Func>
> + inline _Unary_negate_1<_Func>
> + not1(_Func& __f)
> + { return _Unary_negate_1<_Func>(__f); }
> +#endif
>
> } // namespace __ops
> } // namespace __gnu_cxx
> diff --git a/libstdc++-v3/include/bits/stl_algo.h
> b/libstdc++-v3/include/bits/stl_algo.h
> index b296e12cf0f8..7ff5dd84a97a 100644
> --- a/libstdc++-v3/include/bits/stl_algo.h
> +++ b/libstdc++-v3/include/bits/stl_algo.h
> @@ -85,21 +85,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> template<typename _Iterator, typename _Compare>
> _GLIBCXX20_CONSTEXPR
> void
> - __move_median_to_first(_Iterator __result,_Iterator __a, _Iterator
> __b,
> + __move_median_to_first(_Iterator __result, _Iterator __a, _Iterator
> __b,
> _Iterator __c, _Compare __comp)
> {
> - if (__comp(__a, __b))
> + if (__comp(*__a, *__b))
> {
> - if (__comp(__b, __c))
> + if (__comp(*__b, *__c))
> std::iter_swap(__result, __b);
> - else if (__comp(__a, __c))
> + else if (__comp(*__a, *__c))
> std::iter_swap(__result, __c);
> else
> std::iter_swap(__result, __a);
> }
> - else if (__comp(__a, __c))
> + else if (__comp(*__a, *__c))
> std::iter_swap(__result, __a);
> - else if (__comp(__b, __c))
> + else if (__comp(*__b, *__c))
> std::iter_swap(__result, __c);
> else
> std::iter_swap(__result, __b);
> @@ -113,7 +113,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> _Predicate __pred)
> {
> return std::__find_if(__first, __last,
> - __gnu_cxx::__ops::__negate(__pred));
> + __gnu_cxx::__ops::not1(__pred));
> }
>
> /// Like find_if_not(), but uses and updates a count of the
> @@ -125,7 +125,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate
> __pred)
> {
> for (; __len; --__len, (void) ++__first)
> - if (!__pred(__first))
> + if (!__pred(*__first))
> break;
> return __first;
> }
> @@ -162,7 +162,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> __n = __count;
> _ForwardIterator __i = __first;
> ++__i;
> - while (__i != __last && __n != 1 && __unary_pred(__i))
> + while (__i != __last && __n != 1 && __unary_pred(*__i))
> {
> ++__i;
> --__n;
> @@ -201,7 +201,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> // __first here is always pointing to one past the last element
> of
> // next possible match.
> _RandomAccessIter __backTrack = __first;
> - while (__unary_pred(--__backTrack))
> + while (__unary_pred(*--__backTrack))
> {
> if (--__remainder == 0)
> return __first - _DistanceType(__count); // Success
> @@ -339,7 +339,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> return std::__find_end(__first1, __last1, __first2, __last2,
> std::__iterator_category(__first1),
> std::__iterator_category(__first2),
> - __gnu_cxx::__ops::__iter_equal_to_iter());
> + __gnu_cxx::__ops::equal_to());
> }
>
> /**
> @@ -390,7 +390,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> return std::__find_end(__first1, __last1, __first2, __last2,
> std::__iterator_category(__first1),
> std::__iterator_category(__first2),
> - __gnu_cxx::__ops::__iter_comp_iter(__comp));
> + __comp);
> }
>
> #if __cplusplus >= 201103L
> @@ -470,8 +470,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
> typename iterator_traits<_InputIterator>::value_type>)
> __glibcxx_requires_valid_range(__first, __last);
> - return std::__find_if_not(__first, __last,
> - __gnu_cxx::__ops::__pred_iter(__pred));
> + return std::__find_if_not(__first, __last, __pred);
> }
>
> /**
> @@ -551,7 +550,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> _OutputIterator __result, _Predicate __pred)
> {
> for (; __first != __last; ++__first)
> - if (!__pred(__first))
> + if (!__pred(*__first))
> {
> *__result = *__first;
> ++__result;
> @@ -588,7 +587,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> __glibcxx_requires_valid_range(__first, __last);
>
> return std::__remove_copy_if(__first, __last, __result,
> - __gnu_cxx::__ops::__iter_equals_val(__value));
> + __gnu_cxx::__ops::__equal_to(__value));
> }
>
> /**
> @@ -621,8 +620,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> typename iterator_traits<_InputIterator>::value_type>)
> __glibcxx_requires_valid_range(__first, __last);
>
> - return std::__remove_copy_if(__first, __last, __result,
> - __gnu_cxx::__ops::__pred_iter(__pred));
> + return std::__remove_copy_if(__first, __last, __result, __pred);
> }
>
> #if __cplusplus >= 201103L
> @@ -780,7 +778,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> __glibcxx_requires_valid_range(__first, __last);
>
> return std::__remove_if(__first, __last,
> - __gnu_cxx::__ops::__iter_equals_val(__value));
> + __gnu_cxx::__ops::__equal_to(__value));
> }
>
> /**
> @@ -813,8 +811,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> typename iterator_traits<_ForwardIterator>::value_type>)
> __glibcxx_requires_valid_range(__first, __last);
>
> - return std::__remove_if(__first, __last,
> - __gnu_cxx::__ops::__pred_iter(__pred));
> + return std::__remove_if(__first, __last, __pred);
> }
>
> template<typename _ForwardIterator, typename _BinaryPredicate>
> @@ -828,7 +825,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> _ForwardIterator __next = __first;
> while (++__next != __last)
> {
> - if (__binary_pred(__first, __next))
> + if (__binary_pred(*__first, *__next))
> return __first;
> __first = __next;
> }
> @@ -850,7 +847,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> _ForwardIterator __dest = __first;
> ++__first;
> while (++__first != __last)
> - if (!__binary_pred(__dest, __first))
> + if (!__binary_pred(*__dest, *__first))
> *++__dest = _GLIBCXX_MOVE(*__first);
> return ++__dest;
> }
> @@ -881,8 +878,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> typename
> iterator_traits<_ForwardIterator>::value_type>)
> __glibcxx_requires_valid_range(__first, __last);
>
> - return std::__unique(__first, __last,
> - __gnu_cxx::__ops::__iter_equal_to_iter());
> + return std::__unique(__first, __last, __gnu_cxx::__ops::equal_to());
> }
>
> /**
> @@ -914,8 +910,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> typename iterator_traits<_ForwardIterator>::value_type>)
> __glibcxx_requires_valid_range(__first, __last);
>
> - return std::__unique(__first, __last,
> -
> __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
> + return std::__unique(__first, __last, __binary_pred);
> }
>
> // _GLIBCXX_RESOLVE_LIB_DEFECTS
> @@ -934,7 +929,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> _ForwardIterator __prev = __first;
> *__result = *__first;
> while (++__first != __last)
> - if (!__binary_pred(__prev, __first))
> + if (!__binary_pred(*__prev, *__first))
> {
> *++__result = *__first;
> __prev = __first;
> @@ -956,7 +951,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> _Val __value = *__first;
> *__result = __value;
> while (++__first != __last)
> - if (!__binary_pred(std::__addressof(__value), __first))
> + if (!__binary_pred(__value, *__first))
> {
> __value = *__first;
> *++__result = __value;
> @@ -975,7 +970,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> {
> *__result = *__first;
> while (++__first != __last)
> - if (!__binary_pred(__result, __first))
> + if (!__binary_pred(*__result, *__first))
> *++__result = *__first;
> return ++__result;
> }
> @@ -1445,10 +1440,10 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> // partition
>
> /// This is a helper function...
> - /// Requires __first != __last and !__pred(__first)
> + /// Requires __first != __last and !__pred(*__first)
> /// and __len == distance(__first, __last).
> ///
> - /// !__pred(__first) allows us to guarantee that we don't
> + /// !__pred(*__first) allows us to guarantee that we don't
> /// move-assign an element onto itself.
> template<typename _ForwardIterator, typename _Pointer, typename
> _Predicate,
> typename _Distance>
> @@ -1468,14 +1463,14 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> _ForwardIterator __result1 = __first;
> _Pointer __result2 = __buffer;
>
> - // The precondition guarantees that !__pred(__first), so
> + // The precondition guarantees that !__pred(*__first), so
> // move that element to the buffer before starting the loop.
> // This ensures that we only call __pred once per element.
> *__result2 = _GLIBCXX_MOVE(*__first);
> ++__result2;
> ++__first;
> for (; __first != __last; ++__first)
> - if (__pred(__first))
> + if (__pred(*__first))
> {
> *__result1 = _GLIBCXX_MOVE(*__first);
> ++__result1;
> @@ -1581,8 +1576,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> typename iterator_traits<_ForwardIterator>::value_type>)
> __glibcxx_requires_valid_range(__first, __last);
>
> - return std::__stable_partition(__first, __last,
> -
> __gnu_cxx::__ops::__pred_iter(__pred));
> + return std::__stable_partition(__first, __last, __pred);
> }
> #endif // HOSTED
>
> @@ -1598,7 +1592,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> {
> std::__make_heap(__first, __middle, __comp);
> for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
> - if (__comp(__i, __first))
> + if (__comp(*__i, *__first))
> std::__pop_heap(__first, __middle, __i, __comp);
> }
>
> @@ -1631,7 +1625,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> std::__make_heap(__result_first, __result_real_last, __comp);
> while (__first != __last)
> {
> - if (__comp(__first, __result_first))
> + if (__comp(*__first, *__result_first))
> std::__adjust_heap(__result_first, _DistanceType(0),
> _DistanceType(__result_real_last
> - __result_first),
> @@ -1689,7 +1683,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
>
> return std::__partial_sort_copy(__first, __last,
> __result_first, __result_last,
> -
> __gnu_cxx::__ops::__iter_less_iter());
> + __gnu_cxx::__ops::less());
> }
>
> /**
> @@ -1744,7 +1738,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
>
> return std::__partial_sort_copy(__first, __last,
> __result_first, __result_last,
> -
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> + __comp);
> }
>
> /// @cond undocumented
> @@ -1760,7 +1754,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __val = _GLIBCXX_MOVE(*__last);
> _RandomAccessIterator __next = __last;
> --__next;
> - while (__comp(__val, __next))
> + while (__comp(__val, *__next))
> {
> *__last = _GLIBCXX_MOVE(*__next);
> __last = __next;
> @@ -1784,15 +1778,14 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
>
> for (_RandomAccessIterator __i = __first + _Dist(1); __i != __last;
> ++__i)
> {
> - if (__comp(__i, __first))
> + if (__comp(*__i, *__first))
> {
> typename _IterTraits::value_type __val = _GLIBCXX_MOVE(*__i);
> _GLIBCXX_MOVE_BACKWARD3(__first, __i, __i + _Dist(1));
> *__first = _GLIBCXX_MOVE(__val);
> }
> else
> - std::__unguarded_linear_insert(__i,
> - __gnu_cxx::__ops::__val_comp_iter(__comp));
> + std::__unguarded_linear_insert(__i, __comp);
> }
> }
>
> @@ -1804,8 +1797,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> _RandomAccessIterator __last, _Compare
> __comp)
> {
> for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
> - std::__unguarded_linear_insert(__i,
> - __gnu_cxx::__ops::__val_comp_iter(__comp));
> + std::__unguarded_linear_insert(__i, __comp);
> }
>
> /**
> @@ -1844,10 +1836,10 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> {
> while (true)
> {
> - while (__comp(__first, __pivot))
> + while (__comp(*__first, *__pivot))
> ++__first;
> --__last;
> - while (__comp(__pivot, __last))
> + while (__comp(*__pivot, *__last))
> --__last;
> if (!(__first < __last))
> return __first;
> @@ -1989,8 +1981,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __glibcxx_requires_partitioned_lower_pred(__first, __last,
> __val, __comp);
>
> - return std::__lower_bound(__first, __last, __val,
> - __gnu_cxx::__ops::__iter_comp_val(__comp));
> + return std::__lower_bound(__first, __last, __val, __comp);
> }
>
> template<typename _ForwardIterator, typename _Tp, typename _Compare>
> @@ -2009,7 +2000,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> _DistanceType __half = __len >> 1;
> _ForwardIterator __middle = __first;
> std::advance(__middle, __half);
> - if (__comp(__val, __middle))
> + if (__comp(__val, *__middle))
> __len = __half;
> else
> {
> @@ -2045,7 +2036,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __glibcxx_requires_partitioned_upper(__first, __last, __val);
>
> return std::__upper_bound(__first, __last, __val,
> - __gnu_cxx::__ops::__val_less_iter());
> + __gnu_cxx::__ops::less());
> }
>
> /**
> @@ -2076,17 +2067,14 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __glibcxx_requires_partitioned_upper_pred(__first, __last,
> __val, __comp);
>
> - return std::__upper_bound(__first, __last, __val,
> - __gnu_cxx::__ops::__val_comp_iter(__comp));
> + return std::__upper_bound(__first, __last, __val, __comp);
> }
>
> - template<typename _ForwardIterator, typename _Tp,
> - typename _CompareItTp, typename _CompareTpIt>
> + template<typename _ForwardIterator, typename _Tp, typename _Compare>
> _GLIBCXX20_CONSTEXPR
> pair<_ForwardIterator, _ForwardIterator>
> __equal_range(_ForwardIterator __first, _ForwardIterator __last,
> - const _Tp& __val,
> - _CompareItTp __comp_it_val, _CompareTpIt __comp_val_it)
> + const _Tp& __val, _Compare __comp)
> {
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
> @@ -2098,21 +2086,21 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> _DistanceType __half = __len >> 1;
> _ForwardIterator __middle = __first;
> std::advance(__middle, __half);
> - if (__comp_it_val(__middle, __val))
> + if (__comp(*__middle, __val))
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> - else if (__comp_val_it(__val, __middle))
> + else if (__comp(__val, *__middle))
> __len = __half;
> else
> {
> _ForwardIterator __left
> - = std::__lower_bound(__first, __middle, __val,
> __comp_it_val);
> + = std::__lower_bound(__first, __middle, __val, __comp);
> std::advance(__first, __len);
> _ForwardIterator __right
> - = std::__upper_bound(++__middle, __first, __val,
> __comp_val_it);
> + = std::__upper_bound(++__middle, __first, __val, __comp);
> return pair<_ForwardIterator, _ForwardIterator>(__left,
> __right);
> }
> }
> @@ -2152,8 +2140,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __glibcxx_requires_partitioned_upper(__first, __last, __val);
>
> return std::__equal_range(__first, __last, __val,
> - __gnu_cxx::__ops::__iter_less_val(),
> - __gnu_cxx::__ops::__val_less_iter());
> + __gnu_cxx::__ops::less());
> }
>
> /**
> @@ -2190,9 +2177,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __glibcxx_requires_partitioned_upper_pred(__first, __last,
> __val, __comp);
>
> - return std::__equal_range(__first, __last, __val,
> - __gnu_cxx::__ops::__iter_comp_val(__comp),
> - __gnu_cxx::__ops::__val_comp_iter(__comp));
> + return std::__equal_range(__first, __last, __val, __comp);
> }
>
> /**
> @@ -2221,8 +2206,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __glibcxx_requires_partitioned_upper(__first, __last, __val);
>
> _ForwardIterator __i
> - = std::__lower_bound(__first, __last, __val,
> - __gnu_cxx::__ops::__iter_less_val());
> + = std::__lower_bound(__first, __last, __val,
> __gnu_cxx::__ops::less());
> return __i != __last && !(__val < *__i);
> }
>
> @@ -2257,8 +2241,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __val, __comp);
>
> _ForwardIterator __i
> - = std::__lower_bound(__first, __last, __val,
> - __gnu_cxx::__ops::__iter_comp_val(__comp));
> + = std::__lower_bound(__first, __last, __val, __comp);
> return __i != __last && !bool(__comp(__val, *__i));
> }
>
> @@ -2274,7 +2257,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> {
> while (__first1 != __last1 && __first2 != __last2)
> {
> - if (__comp(__first2, __first1))
> + if (__comp(*__first2, *__first1))
> {
> *__result = _GLIBCXX_MOVE(*__first2);
> ++__first2;
> @@ -2313,7 +2296,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> --__last2;
> while (true)
> {
> - if (__comp(__last2, __last1))
> + if (__comp(*__last2, *__last1))
> {
> *--__result = _GLIBCXX_MOVE(*__last1);
> if (__first1 == __last1)
> @@ -2419,8 +2402,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __len11 = __len1 / 2;
> std::advance(__first_cut, __len11);
> __second_cut
> - = std::__lower_bound(__middle, __last, *__first_cut,
> -
> __gnu_cxx::__ops::__iter_comp_val(__comp));
> + = std::__lower_bound(__middle, __last, *__first_cut,
> __comp);
> __len22 = std::distance(__middle, __second_cut);
> }
> else
> @@ -2428,8 +2410,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __len22 = __len2 / 2;
> std::advance(__second_cut, __len22);
> __first_cut
> - = std::__upper_bound(__first, __middle, *__second_cut,
> -
> __gnu_cxx::__ops::__val_comp_iter(__comp));
> + = std::__upper_bound(__first, __middle, *__second_cut,
> __comp);
> __len11 = std::distance(__first, __first_cut);
> }
>
> @@ -2463,7 +2444,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
>
> if (__len1 + __len2 == 2)
> {
> - if (__comp(__middle, __first))
> + if (__comp(*__middle, *__first))
> std::iter_swap(__first, __middle);
> return;
> }
> @@ -2477,8 +2458,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __len11 = __len1 / 2;
> std::advance(__first_cut, __len11);
> __second_cut
> - = std::__lower_bound(__middle, __last, *__first_cut,
> -
> __gnu_cxx::__ops::__iter_comp_val(__comp));
> + = std::__lower_bound(__middle, __last, *__first_cut, __comp);
> __len22 = std::distance(__middle, __second_cut);
> }
> else
> @@ -2486,8 +2466,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __len22 = __len2 / 2;
> std::advance(__second_cut, __len22);
> __first_cut
> - = std::__upper_bound(__first, __middle, *__second_cut,
> -
> __gnu_cxx::__ops::__val_comp_iter(__comp));
> + = std::__upper_bound(__first, __middle, *__second_cut, __comp);
> __len11 = std::distance(__first, __first_cut);
> }
>
> @@ -2581,7 +2560,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __glibcxx_requires_irreflexive(__first, __last);
>
> std::__inplace_merge(__first, __middle, __last,
> - __gnu_cxx::__ops::__iter_less_iter());
> + __gnu_cxx::__ops::less());
> }
>
> /**
> @@ -2624,8 +2603,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __glibcxx_requires_sorted_pred(__middle, __last, __comp);
> __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
>
> - std::__inplace_merge(__first, __middle, __last,
> - __gnu_cxx::__ops::__iter_comp_iter(__comp));
> + std::__inplace_merge(__first, __middle, __last, __comp);
> }
>
>
> @@ -2639,7 +2617,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> {
> while (__first1 != __last1 && __first2 != __last2)
> {
> - if (__comp(__first2, __first1))
> + if (__comp(*__first2, *__first1))
> {
> *__result = _GLIBCXX_MOVE(*__first2);
> ++__first2;
> @@ -2804,9 +2782,9 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> {
> while (__first1 != __last1 && __first2 != __last2)
> {
> - if (__comp(__first2, __first1))
> + if (__comp(*__first2, *__first1))
> return false;
> - if (!__comp(__first1, __first2))
> + if (!__comp(*__first1, *__first2))
> ++__first2;
> ++__first1;
> }
> @@ -2853,7 +2831,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __glibcxx_requires_irreflexive2(__first2, __last2);
>
> return std::__includes(__first1, __last1, __first2, __last2,
> - __gnu_cxx::__ops::__iter_less_iter());
> + __gnu_cxx::__ops::less());
> }
>
> /**
> @@ -2899,8 +2877,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
> __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);
>
> - return std::__includes(__first1, __last1, __first2, __last2,
> - __gnu_cxx::__ops::__iter_comp_iter(__comp));
> + return std::__includes(__first1, __last1, __first2, __last2,
> __comp);
> }
>
> // nth_element
> @@ -2932,10 +2909,10 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> {
> _BidirectionalIterator __ii = __i;
> --__i;
> - if (__comp(__i, __ii))
> + if (__comp(*__i, *__ii))
> {
> _BidirectionalIterator __j = __last;
> - while (!__comp(__i, --__j))
> + while (!__comp(*__i, *--__j))
> {}
> std::iter_swap(__i, __j);
> std::__reverse(__ii, __last,
> @@ -2977,8 +2954,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __glibcxx_requires_valid_range(__first, __last);
> __glibcxx_requires_irreflexive(__first, __last);
>
> - return std::__next_permutation
> - (__first, __last, __gnu_cxx::__ops::__iter_less_iter());
> + return std::__next_permutation(__first, __last,
> __gnu_cxx::__ops::less());
> }
>
> /**
> @@ -3011,8 +2987,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __glibcxx_requires_valid_range(__first, __last);
> __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
>
> - return std::__next_permutation
> - (__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
> + return std::__next_permutation(__first, __last, __comp);
> }
>
> template<typename _BidirectionalIterator, typename _Compare>
> @@ -3034,10 +3009,10 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> {
> _BidirectionalIterator __ii = __i;
> --__i;
> - if (__comp(__ii, __i))
> + if (__comp(*__ii, *__i))
> {
> _BidirectionalIterator __j = __last;
> - while (!__comp(--__j, __i))
> + while (!__comp(*--__j, *__i))
> {}
> std::iter_swap(__i, __j);
> std::__reverse(__ii, __last,
> @@ -3080,8 +3055,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __glibcxx_requires_valid_range(__first, __last);
> __glibcxx_requires_irreflexive(__first, __last);
>
> - return std::__prev_permutation(__first, __last,
> - __gnu_cxx::__ops::__iter_less_iter());
> + return std::__prev_permutation(__first, __last,
> __gnu_cxx::__ops::less());
> }
>
> /**
> @@ -3114,8 +3088,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __glibcxx_requires_valid_range(__first, __last);
> __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
>
> - return std::__prev_permutation(__first, __last,
> -
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> + return std::__prev_permutation(__first, __last, __comp);
> }
>
> // replace
> @@ -3130,7 +3103,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> _Predicate __pred, const _Tp& __new_value)
> {
> for (; __first != __last; ++__first, (void)++__result)
> - if (__pred(__first))
> + if (__pred(*__first))
> *__result = __new_value;
> else
> *__result = *__first;
> @@ -3167,8 +3140,8 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __glibcxx_requires_valid_range(__first, __last);
>
> return std::__replace_copy_if(__first, __last, __result,
> - __gnu_cxx::__ops::__iter_equals_val(__old_value),
> - __new_value);
> +
> __gnu_cxx::__ops::__equal_to(__old_value),
> + __new_value);
> }
>
> /**
> @@ -3202,9 +3175,8 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> typename iterator_traits<_InputIterator>::value_type>)
> __glibcxx_requires_valid_range(__first, __last);
>
> - return std::__replace_copy_if(__first, __last, __result,
> - __gnu_cxx::__ops::__pred_iter(__pred),
> - __new_value);
> + return std::__replace_copy_if(__first, __last, __result, __pred,
> + __new_value);
> }
>
> #if __cplusplus >= 201103L
> @@ -3248,7 +3220,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
>
> _ForwardIterator __next = __first;
> for (++__next; __next != __last; __first = __next, (void)++__next)
> - if (__comp(__next, __first))
> + if (__comp(*__next, *__first))
> return __next;
> return __next;
> }
> @@ -3274,7 +3246,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __glibcxx_requires_irreflexive(__first, __last);
>
> return std::__is_sorted_until(__first, __last,
> - __gnu_cxx::__ops::__iter_less_iter());
> + __gnu_cxx::__ops::less());
> }
>
> /**
> @@ -3300,8 +3272,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __glibcxx_requires_valid_range(__first, __last);
> __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
>
> - return std::__is_sorted_until(__first, __last,
> -
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> + return std::__is_sorted_until(__first, __last, __comp);
> }
>
> /**
> @@ -3354,7 +3325,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> return std::make_pair(__first, __first);
>
> _ForwardIterator __min{}, __max{};
> - if (__comp(__next, __first))
> + if (__comp(*__next, *__first))
> {
> __min = __next;
> __max = __first;
> @@ -3373,25 +3344,25 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __next = __first;
> if (++__next == __last)
> {
> - if (__comp(__first, __min))
> + if (__comp(*__first, *__min))
> __min = __first;
> - else if (!__comp(__first, __max))
> + else if (!__comp(*__first, *__max))
> __max = __first;
> break;
> }
>
> - if (__comp(__next, __first))
> + if (__comp(*__next, *__first))
> {
> - if (__comp(__next, __min))
> + if (__comp(*__next, *__min))
> __min = __next;
> - if (!__comp(__first, __max))
> + if (!__comp(*__first, *__max))
> __max = __first;
> }
> else
> {
> - if (__comp(__first, __min))
> + if (__comp(*__first, *__min))
> __min = __first;
> - if (!__comp(__next, __max))
> + if (!__comp(*__next, *__max))
> __max = __next;
> }
>
> @@ -3425,8 +3396,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __glibcxx_requires_valid_range(__first, __last);
> __glibcxx_requires_irreflexive(__first, __last);
>
> - return std::__minmax_element(__first, __last,
> - __gnu_cxx::__ops::__iter_less_iter());
> + return std::__minmax_element(__first, __last,
> __gnu_cxx::__ops::less());
> }
>
> /**
> @@ -3455,8 +3425,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __glibcxx_requires_valid_range(__first, __last);
> __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
>
> - return std::__minmax_element(__first, __last,
> -
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> + return std::__minmax_element(__first, __last, __comp);
> }
>
> template<typename _Tp>
> @@ -3467,7 +3436,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __glibcxx_requires_irreflexive(__l.begin(), __l.end());
> pair<const _Tp*, const _Tp*> __p =
> std::__minmax_element(__l.begin(), __l.end(),
> - __gnu_cxx::__ops::__iter_less_iter());
> + __gnu_cxx::__ops::less());
> return std::make_pair(*__p.first, *__p.second);
> }
>
> @@ -3478,8 +3447,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> {
> __glibcxx_requires_irreflexive_pred(__l.begin(), __l.end(), __comp);
> pair<const _Tp*, const _Tp*> __p =
> - std::__minmax_element(__l.begin(), __l.end(),
> - __gnu_cxx::__ops::__iter_comp_iter(__comp));
> + std::__minmax_element(__l.begin(), __l.end(), __comp);
> return std::make_pair(*__p.first, *__p.second);
> }
>
> @@ -3512,8 +3480,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> typename iterator_traits<_ForwardIterator2>::value_type>)
> __glibcxx_requires_valid_range(__first1, __last1);
>
> - return std::__is_permutation(__first1, __last1, __first2,
> -
> __gnu_cxx::__ops::__iter_comp_iter(__pred));
> + return std::__is_permutation(__first1, __last1, __first2, __pred);
> }
>
> #if __glibcxx_robust_nonmodifying_seq_ops // C++ >= 14
> @@ -3544,7 +3511,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> // have the same elements in the same order.
> for (; __first1 != __last1 && __first2 != __last2;
> ++__first1, (void)++__first2)
> - if (!__pred(__first1, __first2))
> + if (!__pred(*__first1, *__first2))
> break;
>
> if constexpr (__ra_iters)
> @@ -3565,14 +3532,16 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> for (_ForwardIterator1 __scan = __first1; __scan != __last1;
> ++__scan)
> {
> if (__scan != std::__find_if(__first1, __scan,
> - __gnu_cxx::__ops::__iter_comp_iter(__pred,
> __scan)))
> + __gnu_cxx::__ops::bind1st(__pred,
> + *__scan)))
> continue; // We've seen this one before.
>
> auto __matches = std::__count_if(__first2, __last2,
> - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
> +
> __gnu_cxx::__ops::bind1st(__pred,
> +
> *__scan));
> if (0 == __matches
> || std::__count_if(__scan, __last1,
> - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
> + __gnu_cxx::__ops::bind1st(__pred,
> *__scan))
> != __matches)
> return false;
> }
> @@ -3602,9 +3571,8 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __glibcxx_requires_valid_range(__first1, __last1);
> __glibcxx_requires_valid_range(__first2, __last2);
>
> - return
> - std::__is_permutation(__first1, __last1, __first2, __last2,
> - __gnu_cxx::__ops::__iter_equal_to_iter());
> + return std::__is_permutation(__first1, __last1, __first2, __last2,
> + __gnu_cxx::__ops::equal_to());
> }
>
> /**
> @@ -3633,7 +3601,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
> __glibcxx_requires_valid_range(__first2, __last2);
>
> return std::__is_permutation(__first1, __last1, __first2, __last2,
> -
> __gnu_cxx::__ops::__iter_comp_iter(__pred));
> + __pred);
> }
> #endif // __glibcxx_robust_nonmodifying_seq_ops
>
> @@ -3912,7 +3880,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> #endif
>
> return std::__find_if(__first, __last,
> - __gnu_cxx::__ops::__iter_equals_val(__val));
> + __gnu_cxx::__ops::__equal_to(__val));
> }
>
> /**
> @@ -3937,8 +3905,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> typename iterator_traits<_InputIterator>::value_type>)
> __glibcxx_requires_valid_range(__first, __last);
>
> - return std::__find_if(__first, __last,
> - __gnu_cxx::__ops::__pred_iter(__pred));
> + return std::__find_if(__first, __last, __pred);
> }
>
> /**
> @@ -4043,7 +4010,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_valid_range(__first, __last);
>
> return std::__adjacent_find(__first, __last,
> -
> __gnu_cxx::__ops::__iter_equal_to_iter());
> + __gnu_cxx::__ops::equal_to());
> }
>
> /**
> @@ -4070,8 +4037,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> typename iterator_traits<_ForwardIterator>::value_type>)
> __glibcxx_requires_valid_range(__first, __last);
>
> - return std::__adjacent_find(__first, __last,
> - __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
> + return std::__adjacent_find(__first, __last, __binary_pred);
> }
>
> /**
> @@ -4095,7 +4061,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_valid_range(__first, __last);
>
> return std::__count_if(__first, __last,
> - __gnu_cxx::__ops::__iter_equals_val(__value));
> + __gnu_cxx::__ops::__equal_to(__value));
> }
>
> /**
> @@ -4118,8 +4084,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> typename iterator_traits<_InputIterator>::value_type>)
> __glibcxx_requires_valid_range(__first, __last);
>
> - return std::__count_if(__first, __last,
> - __gnu_cxx::__ops::__pred_iter(__pred));
> + return std::__count_if(__first, __last, __pred);
> }
>
> /**
> @@ -4164,7 +4129,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_valid_range(__first2, __last2);
>
> return std::__search(__first1, __last1, __first2, __last2,
> - __gnu_cxx::__ops::__iter_equal_to_iter());
> + __gnu_cxx::__ops::equal_to());
> }
>
> /**
> @@ -4195,7 +4160,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_valid_range(__first, __last);
>
> return std::__search_n(__first, __last, __count,
> - __gnu_cxx::__ops::__iter_equals_val(__val));
> + __gnu_cxx::__ops::__equal_to(__val));
> }
>
>
> @@ -4231,7 +4196,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_valid_range(__first, __last);
>
> return std::__search_n(__first, __last, __count,
> - __gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val));
> + __gnu_cxx::__ops::bind2nd(__binary_pred,
> __val));
> }
>
> #if __cplusplus >= 201703L
> @@ -4488,7 +4453,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> if (__first == __last)
> return __result;
> return std::__unique_copy(__first, __last, __result,
> - __gnu_cxx::__ops::__iter_equal_to_iter(),
> + __gnu_cxx::__ops::equal_to(),
> std::__iterator_category(__first));
> }
>
> @@ -4529,8 +4494,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
>
> if (__first == __last)
> return __result;
> - return std::__unique_copy(__first, __last, __result,
> - __gnu_cxx::__ops::__iter_comp_iter(__binary_pred),
> + return std::__unique_copy(__first, __last, __result, __binary_pred,
> std::__iterator_category(__first));
> }
>
> @@ -4717,7 +4681,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_irreflexive(__first, __last);
>
> std::__partial_sort(__first, __middle, __last,
> - __gnu_cxx::__ops::__iter_less_iter());
> + __gnu_cxx::__ops::less());
> }
>
> /**
> @@ -4757,8 +4721,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_valid_range(__middle, __last);
> __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
>
> - std::__partial_sort(__first, __middle, __last,
> - __gnu_cxx::__ops::__iter_comp_iter(__comp));
> + std::__partial_sort(__first, __middle, __last, __comp);
> }
>
> /**
> @@ -4796,7 +4759,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
>
> std::__introselect(__first, __nth, __last,
> std::__lg(__last - __first) * 2,
> - __gnu_cxx::__ops::__iter_less_iter());
> + __gnu_cxx::__ops::less());
> }
>
> /**
> @@ -4837,7 +4800,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
>
> std::__introselect(__first, __nth, __last,
> std::__lg(__last - __first) * 2,
> - __gnu_cxx::__ops::__iter_comp_iter(__comp));
> + __comp);
> }
>
> /**
> @@ -4867,7 +4830,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_valid_range(__first, __last);
> __glibcxx_requires_irreflexive(__first, __last);
>
> - std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
> + std::__sort(__first, __last, __gnu_cxx::__ops::less());
> }
>
> /**
> @@ -4900,7 +4863,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_valid_range(__first, __last);
> __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
>
> - std::__sort(__first, __last,
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> + std::__sort(__first, __last, __comp);
> }
>
> template<typename _InputIterator1, typename _InputIterator2,
> @@ -4913,7 +4876,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> {
> while (__first1 != __last1 && __first2 != __last2)
> {
> - if (__comp(__first2, __first1))
> + if (__comp(*__first2, *__first1))
> {
> *__result = *__first2;
> ++__first2;
> @@ -4971,9 +4934,8 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_irreflexive2(__first1, __last1);
> __glibcxx_requires_irreflexive2(__first2, __last2);
>
> - return _GLIBCXX_STD_A::__merge(__first1, __last1,
> - __first2, __last2, __result,
> - __gnu_cxx::__ops::__iter_less_iter());
> + return _GLIBCXX_STD_A::__merge(__first1, __last1, __first2, __last2,
> + __result, __gnu_cxx::__ops::less());
> }
>
> /**
> @@ -5022,9 +4984,8 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
> __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);
>
> - return _GLIBCXX_STD_A::__merge(__first1, __last1,
> - __first2, __last2, __result,
> -
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> + return _GLIBCXX_STD_A::__merge(__first1, __last1, __first2, __last2,
> + __result, __comp);
> }
>
> template<typename _RandomAccessIterator, typename _Compare>
> @@ -5098,7 +5059,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_irreflexive(__first, __last);
>
> _GLIBCXX_STD_A::__stable_sort(__first, __last,
> - __gnu_cxx::__ops::__iter_less_iter());
> + __gnu_cxx::__ops::less());
> }
>
> /**
> @@ -5134,13 +5095,11 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_valid_range(__first, __last);
> __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
>
> - _GLIBCXX_STD_A::__stable_sort(__first, __last,
> -
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> + _GLIBCXX_STD_A::__stable_sort(__first, __last, __comp);
> }
>
> template<typename _InputIterator1, typename _InputIterator2,
> - typename _OutputIterator,
> - typename _Compare>
> + typename _OutputIterator, typename _Compare>
> _GLIBCXX20_CONSTEXPR
> _OutputIterator
> __set_union(_InputIterator1 __first1, _InputIterator1 __last1,
> @@ -5149,12 +5108,12 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> {
> while (__first1 != __last1 && __first2 != __last2)
> {
> - if (__comp(__first1, __first2))
> + if (__comp(*__first1, *__first2))
> {
> *__result = *__first1;
> ++__first1;
> }
> - else if (__comp(__first2, __first1))
> + else if (__comp(*__first2, *__first1))
> {
> *__result = *__first2;
> ++__first2;
> @@ -5216,9 +5175,8 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_irreflexive2(__first1, __last1);
> __glibcxx_requires_irreflexive2(__first2, __last2);
>
> - return _GLIBCXX_STD_A::__set_union(__first1, __last1,
> - __first2, __last2, __result,
> - __gnu_cxx::__ops::__iter_less_iter());
> + return _GLIBCXX_STD_A::__set_union(__first1, __last1, __first2,
> __last2,
> + __result,
> __gnu_cxx::__ops::less());
> }
>
> /**
> @@ -5267,14 +5225,12 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
> __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);
>
> - return _GLIBCXX_STD_A::__set_union(__first1, __last1,
> - __first2, __last2, __result,
> -
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> + return _GLIBCXX_STD_A::__set_union(__first1, __last1, __first2,
> __last2,
> + __result, __comp);
> }
>
> template<typename _InputIterator1, typename _InputIterator2,
> - typename _OutputIterator,
> - typename _Compare>
> + typename _OutputIterator, typename _Compare>
> _GLIBCXX20_CONSTEXPR
> _OutputIterator
> __set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
> @@ -5282,9 +5238,9 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> _OutputIterator __result, _Compare __comp)
> {
> while (__first1 != __last1 && __first2 != __last2)
> - if (__comp(__first1, __first2))
> + if (__comp(*__first1, *__first2))
> ++__first1;
> - else if (__comp(__first2, __first1))
> + else if (__comp(*__first2, *__first1))
> ++__first2;
> else
> {
> @@ -5338,9 +5294,9 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_irreflexive2(__first1, __last1);
> __glibcxx_requires_irreflexive2(__first2, __last2);
>
> - return _GLIBCXX_STD_A::__set_intersection(__first1, __last1,
> - __first2, __last2, __result,
> - __gnu_cxx::__ops::__iter_less_iter());
> + return _GLIBCXX_STD_A::
> + __set_intersection(__first1, __last1, __first2, __last2,
> + __result, __gnu_cxx::__ops::less());
> }
>
> /**
> @@ -5388,14 +5344,13 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
> __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);
>
> - return _GLIBCXX_STD_A::__set_intersection(__first1, __last1,
> - __first2, __last2, __result,
> -
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> + return _GLIBCXX_STD_A::
> + __set_intersection(__first1, __last1, __first2, __last2,
> + __result, __comp);
> }
>
> template<typename _InputIterator1, typename _InputIterator2,
> - typename _OutputIterator,
> - typename _Compare>
> + typename _OutputIterator, typename _Compare>
> _GLIBCXX20_CONSTEXPR
> _OutputIterator
> __set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
> @@ -5403,13 +5358,13 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> _OutputIterator __result, _Compare __comp)
> {
> while (__first1 != __last1 && __first2 != __last2)
> - if (__comp(__first1, __first2))
> + if (__comp(*__first1, *__first2))
> {
> *__result = *__first1;
> ++__first1;
> ++__result;
> }
> - else if (__comp(__first2, __first1))
> + else if (__comp(*__first2, *__first1))
> ++__first2;
> else
> {
> @@ -5463,9 +5418,9 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_irreflexive2(__first1, __last1);
> __glibcxx_requires_irreflexive2(__first2, __last2);
>
> - return _GLIBCXX_STD_A::__set_difference(__first1, __last1,
> - __first2, __last2, __result,
> - __gnu_cxx::__ops::__iter_less_iter());
> + return _GLIBCXX_STD_A::
> + __set_difference(__first1, __last1, __first2, __last2,
> __result,
> + __gnu_cxx::__ops::less());
> }
>
> /**
> @@ -5515,9 +5470,9 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
> __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);
>
> - return _GLIBCXX_STD_A::__set_difference(__first1, __last1,
> - __first2, __last2, __result,
> -
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> + return _GLIBCXX_STD_A::
> + __set_difference(__first1, __last1, __first2, __last2,
> __result,
> + __comp);
> }
>
> template<typename _InputIterator1, typename _InputIterator2,
> @@ -5533,13 +5488,13 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> _Compare __comp)
> {
> while (__first1 != __last1 && __first2 != __last2)
> - if (__comp(__first1, __first2))
> + if (__comp(*__first1, *__first2))
> {
> *__result = *__first1;
> ++__first1;
> ++__result;
> }
> - else if (__comp(__first2, __first1))
> + else if (__comp(*__first2, *__first1))
> {
> *__result = *__first2;
> ++__first2;
> @@ -5598,9 +5553,9 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_irreflexive2(__first1, __last1);
> __glibcxx_requires_irreflexive2(__first2, __last2);
>
> - return _GLIBCXX_STD_A::__set_symmetric_difference(__first1, __last1,
> - __first2, __last2, __result,
> -
> __gnu_cxx::__ops::__iter_less_iter());
> + return _GLIBCXX_STD_A::
> + __set_symmetric_difference(__first1, __last1, __first2,
> __last2,
> + __result,
> __gnu_cxx::__ops::less());
> }
>
> /**
> @@ -5651,9 +5606,9 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
> __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);
>
> - return _GLIBCXX_STD_A::__set_symmetric_difference(__first1, __last1,
> - __first2, __last2, __result,
> -
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> + return _GLIBCXX_STD_A::
> + __set_symmetric_difference(__first1, __last1, __first2,
> __last2,
> + __result, __comp);
> }
>
> template<typename _ForwardIterator, typename _Compare>
> @@ -5666,7 +5621,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> return __first;
> _ForwardIterator __result = __first;
> while (++__first != __last)
> - if (__comp(__first, __result))
> + if (__comp(*__first, *__result))
> __result = __first;
> return __result;
> }
> @@ -5680,8 +5635,8 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> */
> template<typename _ForwardIterator>
> _GLIBCXX_NODISCARD _GLIBCXX14_CONSTEXPR
> - _ForwardIterator
> - inline min_element(_ForwardIterator __first, _ForwardIterator __last)
> + inline _ForwardIterator
> + min_element(_ForwardIterator __first, _ForwardIterator __last)
> {
> // concept requirements
>
> __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
> @@ -5691,7 +5646,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_irreflexive(__first, __last);
>
> return _GLIBCXX_STD_A::__min_element(__first, __last,
> - __gnu_cxx::__ops::__iter_less_iter());
> + __gnu_cxx::__ops::less());
> }
>
> /**
> @@ -5717,8 +5672,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_valid_range(__first, __last);
> __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
>
> - return _GLIBCXX_STD_A::__min_element(__first, __last,
> -
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> + return _GLIBCXX_STD_A::__min_element(__first, __last, __comp);
> }
>
> template<typename _ForwardIterator, typename _Compare>
> @@ -5730,7 +5684,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> if (__first == __last) return __first;
> _ForwardIterator __result = __first;
> while (++__first != __last)
> - if (__comp(__result, __first))
> + if (__comp(*__result, *__first))
> __result = __first;
> return __result;
> }
> @@ -5755,7 +5709,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_irreflexive(__first, __last);
>
> return _GLIBCXX_STD_A::__max_element(__first, __last,
> - __gnu_cxx::__ops::__iter_less_iter());
> + __gnu_cxx::__ops::less());
> }
>
> /**
> @@ -5781,8 +5735,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_valid_range(__first, __last);
> __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
>
> - return _GLIBCXX_STD_A::__max_element(__first, __last,
> -
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> + return _GLIBCXX_STD_A::__max_element(__first, __last, __comp);
> }
>
> #if __cplusplus >= 201103L
> @@ -5794,7 +5747,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> {
> __glibcxx_requires_irreflexive(__l.begin(), __l.end());
> return *_GLIBCXX_STD_A::__min_element(__l.begin(), __l.end(),
> - __gnu_cxx::__ops::__iter_less_iter());
> + __gnu_cxx::__ops::less());
> }
>
> template<typename _Tp, typename _Compare>
> @@ -5803,8 +5756,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> min(initializer_list<_Tp> __l, _Compare __comp)
> {
> __glibcxx_requires_irreflexive_pred(__l.begin(), __l.end(), __comp);
> - return *_GLIBCXX_STD_A::__min_element(__l.begin(), __l.end(),
> - __gnu_cxx::__ops::__iter_comp_iter(__comp));
> + return *_GLIBCXX_STD_A::__min_element(__l.begin(), __l.end(),
> __comp);
> }
>
> template<typename _Tp>
> @@ -5814,7 +5766,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> {
> __glibcxx_requires_irreflexive(__l.begin(), __l.end());
> return *_GLIBCXX_STD_A::__max_element(__l.begin(), __l.end(),
> - __gnu_cxx::__ops::__iter_less_iter());
> + __gnu_cxx::__ops::less());
> }
>
> template<typename _Tp, typename _Compare>
> @@ -5823,8 +5775,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> max(initializer_list<_Tp> __l, _Compare __comp)
> {
> __glibcxx_requires_irreflexive_pred(__l.begin(), __l.end(), __comp);
> - return *_GLIBCXX_STD_A::__max_element(__l.begin(), __l.end(),
> - __gnu_cxx::__ops::__iter_comp_iter(__comp));
> + return *_GLIBCXX_STD_A::__max_element(__l.begin(), __l.end(),
> __comp);
> }
> #endif // C++11
>
> diff --git a/libstdc++-v3/include/bits/stl_algobase.h
> b/libstdc++-v3/include/bits/stl_algobase.h
> index 022668076138..03f64fb3e6c3 100644
> --- a/libstdc++-v3/include/bits/stl_algobase.h
> +++ b/libstdc++-v3/include/bits/stl_algobase.h
> @@ -1340,9 +1340,9 @@ _GLIBCXX_END_NAMESPACE_CONTAINER
> for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
> ++__first1, (void)++__first2)
> {
> - if (__comp(__first1, __first2))
> + if (__comp(*__first1, *__first2))
> return true;
> - if (__comp(__first2, __first1))
> + if (__comp(*__first2, *__first1))
> return false;
> }
> return __first1 == __last1 && __first2 != __last2;
> @@ -1356,10 +1356,10 @@ _GLIBCXX_END_NAMESPACE_CONTAINER
> static bool
> __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
> {
> - using __gnu_cxx::__ops::__iter_less_iter;
> + using __gnu_cxx::__ops::less;
> return std::__lexicographical_compare_impl(__first1, __last1,
> __first2, __last2,
> - __iter_less_iter());
> + less());
> }
>
> template<typename _II1, typename _II2>
> @@ -1515,7 +1515,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER
> _DistanceType __half = __len >> 1;
> _ForwardIterator __middle = __first;
> std::advance(__middle, __half);
> - if (__comp(__middle, __val))
> + if (__comp(*__middle, __val))
> {
> __first = __middle;
> ++__first;
> @@ -1551,7 +1551,7 @@ _GLIBCXX_END_NAMESPACE_CONTAINER
> __glibcxx_requires_partitioned_lower(__first, __last, __val);
>
> return std::__lower_bound(__first, __last, __val,
> - __gnu_cxx::__ops::__iter_less_val());
> + __gnu_cxx::__ops::less());
> }
>
> /// This is a helper function for the sort routines and for random.tcc.
> @@ -1825,8 +1825,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_valid_range(__first2, __last2);
>
> return std::__lexicographical_compare_impl
> - (__first1, __last1, __first2, __last2,
> - __gnu_cxx::__ops::__iter_comp_iter(__comp));
> + (__first1, __last1, __first2, __last2, __comp);
> }
>
> #if __cpp_lib_three_way_comparison
> @@ -1934,7 +1933,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _BinaryPredicate __binary_pred)
> {
> - while (__first1 != __last1 && __binary_pred(__first1, __first2))
> + while (__first1 != __last1 && __binary_pred(*__first1, *__first2))
> {
> ++__first1;
> ++__first2;
> @@ -1970,7 +1969,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_valid_range(__first1, __last1);
>
> return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2,
> - __gnu_cxx::__ops::__iter_equal_to_iter());
> + __gnu_cxx::__ops::equal_to());
> }
>
> /**
> @@ -2002,7 +2001,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_valid_range(__first1, __last1);
>
> return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2,
> - __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
> + __binary_pred);
> }
>
> #if __glibcxx_robust_nonmodifying_seq_ops // C++ >= 14
> @@ -2015,7 +2014,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> _BinaryPredicate __binary_pred)
> {
> while (__first1 != __last1 && __first2 != __last2
> - && __binary_pred(__first1, __first2))
> + && __binary_pred(*__first1, *__first2))
> {
> ++__first1;
> ++__first2;
> @@ -2053,7 +2052,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_valid_range(__first2, __last2);
>
> return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2,
> __last2,
> - __gnu_cxx::__ops::__iter_equal_to_iter());
> + __gnu_cxx::__ops::equal_to());
> }
>
> /**
> @@ -2088,7 +2087,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_valid_range(__first2, __last2);
>
> return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2,
> __last2,
> -
> __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
> + __binary_pred);
> }
> #endif // __glibcxx_robust_nonmodifying_seq_ops
>
> @@ -2101,7 +2100,7 @@ _GLIBCXX_END_NAMESPACE_ALGO
> __find_if(_Iterator __first, _Iterator __last, _Predicate __pred)
> {
> #pragma GCC unroll 4
> - while (__first != __last && !__pred(__first))
> + while (__first != __last && !__pred(*__first))
> ++__first;
> return __first;
> }
> @@ -2113,7 +2112,7 @@ _GLIBCXX_END_NAMESPACE_ALGO
> {
> typename iterator_traits<_InputIterator>::difference_type __n = 0;
> for (; __first != __last; ++__first)
> - if (__pred(__first))
> + if (__pred(*__first))
> ++__n;
> return __n;
> }
> @@ -2130,7 +2129,7 @@ _GLIBCXX_END_NAMESPACE_ALGO
> _ForwardIterator __result = __first;
> ++__first;
> for (; __first != __last; ++__first)
> - if (!__pred(__first))
> + if (!__pred(*__first))
> {
> *__result = _GLIBCXX_MOVE(*__first);
> ++__result;
> @@ -2154,7 +2153,8 @@ _GLIBCXX_END_NAMESPACE_ALGO
> _ForwardIterator2 __p1(__first2);
> if (++__p1 == __last2)
> return std::__find_if(__first1, __last1,
> - __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
> + __gnu_cxx::__ops::bind2nd(__predicate,
> + *__first2));
>
> // General case.
> _ForwardIterator1 __current = __first1;
> @@ -2163,7 +2163,7 @@ _GLIBCXX_END_NAMESPACE_ALGO
> {
> __first1 =
> std::__find_if(__first1, __last1,
> - __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
> + __gnu_cxx::__ops::bind2nd(__predicate,
> *__first2));
>
> if (__first1 == __last1)
> return __last1;
> @@ -2173,7 +2173,7 @@ _GLIBCXX_END_NAMESPACE_ALGO
> if (++__current == __last1)
> return __last1;
>
> - while (__predicate(__current, __p))
> + while (__predicate(*__current, *__p))
> {
> if (++__p == __last2)
> return __first1;
> @@ -2196,7 +2196,7 @@ _GLIBCXX_END_NAMESPACE_ALGO
> // Efficiently compare identical prefixes: O(N) if sequences
> // have the same elements in the same order.
> for (; __first1 != __last1; ++__first1, (void)++__first2)
> - if (!__pred(__first1, __first2))
> + if (!__pred(*__first1, *__first2))
> break;
>
> if (__first1 == __last1)
> @@ -2209,15 +2209,16 @@ _GLIBCXX_END_NAMESPACE_ALGO
> for (_ForwardIterator1 __scan = __first1; __scan != __last1;
> ++__scan)
> {
> if (__scan != std::__find_if(__first1, __scan,
> - __gnu_cxx::__ops::__iter_comp_iter(__pred,
> __scan)))
> + __gnu_cxx::__ops::bind1st(__pred,
> + *__scan)))
> continue; // We've seen this one before.
>
> auto __matches
> = std::__count_if(__first2, __last2,
> - __gnu_cxx::__ops::__iter_comp_iter(__pred,
> __scan));
> + __gnu_cxx::__ops::bind1st(__pred, *__scan));
> if (0 == __matches ||
> std::__count_if(__scan, __last1,
> - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
> + __gnu_cxx::__ops::bind1st(__pred, *__scan))
> != __matches)
> return false;
> }
> @@ -2251,7 +2252,7 @@ _GLIBCXX_END_NAMESPACE_ALGO
> __glibcxx_requires_valid_range(__first1, __last1);
>
> return std::__is_permutation(__first1, __last1, __first2,
> -
> __gnu_cxx::__ops::__iter_equal_to_iter());
> + __gnu_cxx::__ops::equal_to());
> }
> #endif // C++11
>
> @@ -2295,8 +2296,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
> __glibcxx_requires_valid_range(__first1, __last1);
> __glibcxx_requires_valid_range(__first2, __last2);
>
> - return std::__search(__first1, __last1, __first2, __last2,
> -
> __gnu_cxx::__ops::__iter_comp_iter(__predicate));
> + return std::__search(__first1, __last1, __first2, __last2,
> __predicate);
> }
>
> _GLIBCXX_END_NAMESPACE_ALGO
> diff --git a/libstdc++-v3/include/bits/stl_function.h
> b/libstdc++-v3/include/bits/stl_function.h
> index 136fd01c9847..ff3f8f4c6e79 100644
> --- a/libstdc++-v3/include/bits/stl_function.h
> +++ b/libstdc++-v3/include/bits/stl_function.h
> @@ -762,6 +762,58 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> is_convertible<_Tp, const volatile void*>,
> is_convertible<_Up, const volatile void*>>;
> };
> +#else // < C++14
> +
> + // We need less<void> and equal_to<void> for <bits/predefined_ops.h>
> +
> + template<>
> + struct equal_to<void>
> + {
> +#ifdef __cpp_rvalue_references
> + template<typename _Tp, typename _Up>
> + bool
> + operator()(_Tp&& __t, _Up&& __u) const
> + { return __t == __u; }
> +#else // C++98
> + template<typename _Tp, typename _Up>
> + bool
> + operator()(_Tp& __t, _Up& __u) const { return __t == __u; }
> + template<typename _Tp, typename _Up>
> + bool
> + operator()(const _Tp& __t, _Up& __u) const { return __t == __u; }
> + template<typename _Tp, typename _Up>
> + bool
> + operator()(_Tp& __t, const _Up& __u) const { return __t == __u; }
> + template<typename _Tp, typename _Up>
> + bool
> + operator()(const _Tp& __t, const _Up& __u) const { return __t ==
> __u; }
> +#endif
> + };
> +
> + template<>
> + struct less<void>
> + {
> +#ifdef __cpp_rvalue_references
> + template<typename _Tp, typename _Up>
> + bool
> + operator()(_Tp&& __t, _Up&& __u) const
> + { return __t < __u; }
> +#else // C++98
> + template<typename _Tp, typename _Up>
> + bool
> + operator()(_Tp& __t, _Up& __u) const { return __t < __u; }
> + template<typename _Tp, typename _Up>
> + bool
> + operator()(const _Tp& __t, _Up& __u) const { return __t < __u; }
> + template<typename _Tp, typename _Up>
> + bool
> + operator()(_Tp& __t, const _Up& __u) const { return __t < __u; }
> + template<typename _Tp, typename _Up>
> + bool
> + operator()(const _Tp& __t, const _Up& __u) const { return __t <
> __u; }
> +#endif
> + };
> +
> #endif // __glibcxx_transparent_operators
> /** @} */
>
> diff --git a/libstdc++-v3/include/bits/stl_heap.h
> b/libstdc++-v3/include/bits/stl_heap.h
> index f2b1e87e42a8..b10495bc8052 100644
> --- a/libstdc++-v3/include/bits/stl_heap.h
> +++ b/libstdc++-v3/include/bits/stl_heap.h
> @@ -85,7 +85,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> _Distance __parent = 0;
> for (_Distance __child = 1; __child < __n; ++__child)
> {
> - if (__comp(__first + __parent, __first + __child))
> + if (__comp(__first[__parent], __first[__child]))
> return __child;
> if ((__child & 1) == 0)
> ++__parent;
> @@ -101,7 +101,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> __is_heap(_RandomAccessIterator __first, _Distance __n)
> {
> typename iterator_traits<_RandomAccessIterator>::difference_type
> __d(__n);
> - __gnu_cxx::__ops::_Iter_less_iter __comp;
> + __gnu_cxx::__ops::less __comp;
> return std::__is_heap_until(__first, __d, __comp) == __n;
> }
>
> @@ -112,9 +112,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance
> __n)
> {
> typename iterator_traits<_RandomAccessIterator>::difference_type
> __d(__n);
> - typedef __decltype(__comp) _Cmp;
> - __gnu_cxx::__ops::_Iter_comp_iter<_Cmp>
> __cmp(_GLIBCXX_MOVE(__comp));
> - return std::__is_heap_until(__first, __d, __cmp) == __n;
> + return std::__is_heap_until(__first, __d, __comp) == __n;
> }
>
> template<typename _RandomAccessIterator>
> @@ -145,7 +143,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> _Compare& __comp)
> {
> _Distance __parent = (__holeIndex - 1) / 2;
> - while (__holeIndex > __topIndex && __comp(__first + __parent,
> __value))
> + while (__holeIndex > __topIndex && __comp(__first[__parent],
> __value))
> {
> *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __parent));
> __holeIndex = __parent;
> @@ -182,7 +180,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> __glibcxx_requires_irreflexive(__first, __last);
> __glibcxx_requires_heap(__first, __last - _DistanceType(1));
>
> - __gnu_cxx::__ops::_Iter_less_val __comp;
> + __gnu_cxx::__ops::less __comp;
> _ValueType __value = _GLIBCXX_MOVE(*(__last - _DistanceType(1)));
> std::__push_heap(__first, _DistanceType((__last - __first) - 1),
> _DistanceType(0), _GLIBCXX_MOVE(__value), __comp);
> @@ -218,11 +216,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
> __glibcxx_requires_heap_pred(__first, __last - _DistanceType(1),
> __comp);
>
> - __decltype(__gnu_cxx::__ops::__iter_comp_val(_GLIBCXX_MOVE(__comp)))
> - __cmp(_GLIBCXX_MOVE(__comp));
> _ValueType __value = _GLIBCXX_MOVE(*(__last - _DistanceType(1)));
> std::__push_heap(__first, _DistanceType((__last - __first) - 1),
> - _DistanceType(0), _GLIBCXX_MOVE(__value), __cmp);
> + _DistanceType(0), _GLIBCXX_MOVE(__value), __comp);
> }
>
> template<typename _RandomAccessIterator, typename _Distance,
> @@ -237,8 +233,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> while (__secondChild < (__len - 1) / 2)
> {
> __secondChild = 2 * (__secondChild + 1);
> - if (__comp(__first + __secondChild,
> - __first + (__secondChild - 1)))
> + if (__comp(__first[__secondChild],
> + __first[__secondChild - 1]))
> __secondChild--;
> *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first +
> __secondChild));
> __holeIndex = __secondChild;
> @@ -250,10 +246,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> + (__secondChild -
> 1)));
> __holeIndex = __secondChild - 1;
> }
> - __decltype(__gnu_cxx::__ops::__iter_comp_val(_GLIBCXX_MOVE(__comp)))
> - __cmp(_GLIBCXX_MOVE(__comp));
> std::__push_heap(__first, __holeIndex, __topIndex,
> - _GLIBCXX_MOVE(__value), __cmp);
> + _GLIBCXX_MOVE(__value), __comp);
> }
>
> template<typename _RandomAccessIterator, typename _Compare>
> @@ -303,7 +297,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> if (__last - __first > 1)
> {
> --__last;
> - __gnu_cxx::__ops::_Iter_less_iter __comp;
> + __gnu_cxx::__ops::less __comp;
> std::__pop_heap(__first, __last, __last, __comp);
> }
> }
> @@ -335,10 +329,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
>
> if (__last - __first > 1)
> {
> - typedef __decltype(__comp) _Cmp;
> - __gnu_cxx::__ops::_Iter_comp_iter<_Cmp>
> __cmp(_GLIBCXX_MOVE(__comp));
> --__last;
> - std::__pop_heap(__first, __last, __last, __cmp);
> + std::__pop_heap(__first, __last, __last, __comp);
> }
> }
>
> @@ -390,7 +382,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> __glibcxx_requires_valid_range(__first, __last);
> __glibcxx_requires_irreflexive(__first, __last);
>
> - __gnu_cxx::__ops::_Iter_less_iter __comp;
> + __gnu_cxx::__ops::less __comp;
> std::__make_heap(__first, __last, __comp);
> }
>
> @@ -416,9 +408,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> __glibcxx_requires_valid_range(__first, __last);
> __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
>
> - typedef __decltype(__comp) _Cmp;
> - __gnu_cxx::__ops::_Iter_comp_iter<_Cmp>
> __cmp(_GLIBCXX_MOVE(__comp));
> - std::__make_heap(__first, __last, __cmp);
> + std::__make_heap(__first, __last, __comp);
> }
>
> template<typename _RandomAccessIterator, typename _Compare>
> @@ -456,7 +446,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> __glibcxx_requires_irreflexive(__first, __last);
> __glibcxx_requires_heap(__first, __last);
>
> - __gnu_cxx::__ops::_Iter_less_iter __comp;
> + __gnu_cxx::__ops::less __comp;
> std::__sort_heap(__first, __last, __comp);
> }
>
> @@ -483,9 +473,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
> __glibcxx_requires_heap_pred(__first, __last, __comp);
>
> - typedef __decltype(__comp) _Cmp;
> - __gnu_cxx::__ops::_Iter_comp_iter<_Cmp>
> __cmp(_GLIBCXX_MOVE(__comp));
> - std::__sort_heap(__first, __last, __cmp);
> + std::__sort_heap(__first, __last, __comp);
> }
>
> #if __cplusplus >= 201103L
> @@ -512,7 +500,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> __glibcxx_requires_valid_range(__first, __last);
> __glibcxx_requires_irreflexive(__first, __last);
>
> - __gnu_cxx::__ops::_Iter_less_iter __comp;
> + __gnu_cxx::__ops::less __comp;
> return __first +
> std::__is_heap_until(__first, std::distance(__first, __last),
> __comp);
> }
> @@ -540,10 +528,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> __glibcxx_requires_valid_range(__first, __last);
> __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
>
> - typedef __decltype(__comp) _Cmp;
> - __gnu_cxx::__ops::_Iter_comp_iter<_Cmp>
> __cmp(_GLIBCXX_MOVE(__comp));
> return __first
> - + std::__is_heap_until(__first, std::distance(__first, __last),
> __cmp);
> + + std::__is_heap_until(__first, std::distance(__first, __last),
> + __comp);
> }
>
> /**
> @@ -580,9 +567,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
>
> const auto __dist = std::distance(__first, __last);
> - typedef __decltype(__comp) _Cmp;
> - __gnu_cxx::__ops::_Iter_comp_iter<_Cmp>
> __cmp(_GLIBCXX_MOVE(__comp));
> - return std::__is_heap_until(__first, __dist, __cmp) == __dist;
> + return std::__is_heap_until(__first, __dist, __comp) == __dist;
> }
> #endif
>
> diff --git a/libstdc++-v3/include/std/deque
> b/libstdc++-v3/include/std/deque
> index 2badab80a6dc..3b1a7dea2b10 100644
> --- a/libstdc++-v3/include/std/deque
> +++ b/libstdc++-v3/include/std/deque
> @@ -109,7 +109,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> const auto __osz = __cont.size();
> const auto __end = __ucont.end();
> auto __removed = std::__remove_if(__ucont.begin(), __end,
> -
> __ops::__pred_iter(std::ref(__pred)));
> + std::ref(__pred));
> if (__removed != __end)
> {
> __cont.erase(__niter_wrap(__cont.begin(), __removed),
> @@ -130,7 +130,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> const auto __osz = __cont.size();
> const auto __end = __ucont.end();
> auto __removed = std::__remove_if(__ucont.begin(), __end,
> - __ops::__iter_equals_val(__value));
> + __ops::__equal_to(__value));
> if (__removed != __end)
> {
> __cont.erase(__niter_wrap(__cont.begin(), __removed),
> diff --git a/libstdc++-v3/include/std/inplace_vector
> b/libstdc++-v3/include/std/inplace_vector
> index b5a81bed3c98..b32aa4f3708c 100644
> --- a/libstdc++-v3/include/std/inplace_vector
> +++ b/libstdc++-v3/include/std/inplace_vector
> @@ -1343,7 +1343,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> const auto __osz = __cont.size();
> const auto __end = __cont.end();
> auto __removed = std::__remove_if(__cont.begin(), __end,
> -
> __ops::__pred_iter(std::ref(__pred)));
> + std::ref(__pred));
> if (__removed != __end)
> {
> __cont.erase(__niter_wrap(__cont.begin(), __removed),
> @@ -1362,7 +1362,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> const auto __osz = __cont.size();
> const auto __end = __cont.end();
> auto __removed = std::__remove_if(__cont.begin(), __end,
> - __ops::__iter_equals_val(__value));
> + __ops::__equal_to(__value));
> if (__removed != __end)
> {
> __cont.erase(__niter_wrap(__cont.begin(), __removed),
> diff --git a/libstdc++-v3/include/std/string
> b/libstdc++-v3/include/std/string
> index 71864715ff75..74e0c7f2be58 100644
> --- a/libstdc++-v3/include/std/string
> +++ b/libstdc++-v3/include/std/string
> @@ -104,7 +104,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> const auto __osz = __cont.size();
> const auto __end = __cont.end();
> auto __removed = std::__remove_if(__cont.begin(), __end,
> -
> __ops::__pred_iter(std::ref(__pred)));
> + std::ref(__pred));
> __cont.erase(__removed, __end);
> return __osz - __cont.size();
> }
> @@ -119,7 +119,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> const auto __osz = __cont.size();
> const auto __end = __cont.end();
> auto __removed = std::__remove_if(__cont.begin(), __end,
> - __ops::__iter_equals_val(__value));
> + __ops::__equal_to(__value));
> __cont.erase(__removed, __end);
> return __osz - __cont.size();
> }
> diff --git a/libstdc++-v3/include/std/vector
> b/libstdc++-v3/include/std/vector
> index a98ffb179ec0..47105210bc0c 100644
> --- a/libstdc++-v3/include/std/vector
> +++ b/libstdc++-v3/include/std/vector
> @@ -122,7 +122,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> const auto __osz = __cont.size();
> const auto __end = __ucont.end();
> auto __removed = std::__remove_if(__ucont.begin(), __end,
> -
> __ops::__pred_iter(std::ref(__pred)));
> + std::ref(__pred));
> if (__removed != __end)
> {
> __cont.erase(__niter_wrap(__cont.begin(), __removed),
> @@ -144,7 +144,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> const auto __osz = __cont.size();
> const auto __end = __ucont.end();
> auto __removed = std::__remove_if(__ucont.begin(), __end,
> - __ops::__iter_equals_val(__value));
> + __ops::__equal_to(__value));
> if (__removed != __end)
> {
> __cont.erase(__niter_wrap(__cont.begin(), __removed),
> --
> 2.51.0
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://gcc.gnu.org/pipermail/libstdc++/attachments/20250925/d66df214/attachment-0001.htm>
More information about the Libstdc++
mailing list