[libc++] Avoid `result_type` and `unary/binary_function` in <valarray>

[• Quuxplusone]

Summary

Give each of the relevant functional operators a __result_type instead, so that we can keep using those typedefs in <valarray> even when the public binder typedefs are removed in C++20.

This is a bit of a hacky lazy way to eliminate valarray's dependency on {unary,binary}_function, but it kinda seems like all of valarray is a hack and so maybe this fits right in? ;)
I would be willing to spend some time trying to recast all this metaprogramming in terms of decltype, but the first thing I tried didn't immediately work, so I went with the safe route.

The main point of this patch is to clear the way for _LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS (and incidentally _LIBCPP_ABI_NO_BINDER_BASES), which I have already got in a local patch on top of this one.

[• Quuxplusone]

libcxx/include/functional

1005–1007

Btw, we could eliminate 9 lines of custom __bit_not<T> code from <valarray> if we made std::bit_not<T> here available in C++03 mode as an extension. Thoughts?

[• Quuxplusone]

libcxx/include/valarray

446

Btw, I was surprised to find value_type here instead of result_type. But changing it (or even trying to produce a test case where the difference was observable) seemed like a rabbit hole, so I avoided it.

[• Quuxplusone]

Buildkite is happy with this: https://buildkite.com/llvm-project/libcxx-ci/builds/3467

libcxx/include/valarray

446

Today I think I've convinced myself that it doesn't matter: _Op::__result_type is always either _Tp or bool, and we only ever use _BinaryOp in type-expressions like __val_expr<_BinaryOp<...>>, and __val_expr::operator[](size_t) does correctly return __result_type; so at worst we're taking a bool, accidentally casting it up to _Tp here in _BinaryOp::operator[], and then casting it back down to bool in __val_expr::operator[]. I don't think this is ever observable.

So I could "fix" this, or leave it as-is; either way it wouldn't be observable.

[ldionne]

libcxx/include/functional

1005–1007

I'd rather not do that. We'll waste more than that in complexity for testing the extension.

libcxx/include/__functional_base

 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
 struct _LIBCPP_TEMPLATE_VIS less : binary_function<_Tp, _Tp, bool>
 {
+    typedef bool __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x < __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS less<void>

libcxx/include/functional

 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
 struct _LIBCPP_TEMPLATE_VIS plus : binary_function<_Tp, _Tp, _Tp>
 {
+    typedef _Tp __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x + __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS plus<void>

 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
 struct _LIBCPP_TEMPLATE_VIS minus : binary_function<_Tp, _Tp, _Tp>
 {
+    typedef _Tp __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x - __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS minus<void>

 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
 struct _LIBCPP_TEMPLATE_VIS multiplies : binary_function<_Tp, _Tp, _Tp>
 {
+    typedef _Tp __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x * __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS multiplies<void>

 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
 struct _LIBCPP_TEMPLATE_VIS divides : binary_function<_Tp, _Tp, _Tp>
 {
+    typedef _Tp __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x / __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS divides<void>

 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
 struct _LIBCPP_TEMPLATE_VIS modulus : binary_function<_Tp, _Tp, _Tp>
 {
+    typedef _Tp __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x % __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS modulus<void>

 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
 struct _LIBCPP_TEMPLATE_VIS negate : unary_function<_Tp, _Tp>
 {
+    typedef _Tp __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
         {return -__x;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS negate<void>

 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
 struct _LIBCPP_TEMPLATE_VIS equal_to : binary_function<_Tp, _Tp, bool>
 {
+    typedef bool __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x == __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS equal_to<void>

 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
 struct _LIBCPP_TEMPLATE_VIS not_equal_to : binary_function<_Tp, _Tp, bool>
 {
+    typedef bool __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x != __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS not_equal_to<void>

 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
 struct _LIBCPP_TEMPLATE_VIS greater : binary_function<_Tp, _Tp, bool>
 {
+    typedef bool __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x > __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS greater<void>

 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
 struct _LIBCPP_TEMPLATE_VIS greater_equal : binary_function<_Tp, _Tp, bool>
 {
+    typedef bool __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x >= __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS greater_equal<void>

 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
 struct _LIBCPP_TEMPLATE_VIS less_equal : binary_function<_Tp, _Tp, bool>
 {
+    typedef bool __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x <= __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS less_equal<void>

 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
 struct _LIBCPP_TEMPLATE_VIS logical_and : binary_function<_Tp, _Tp, bool>
 {
+    typedef bool __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x && __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS logical_and<void>

 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
 struct _LIBCPP_TEMPLATE_VIS logical_or : binary_function<_Tp, _Tp, bool>
 {
+    typedef bool __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x || __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS logical_or<void>

 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
 struct _LIBCPP_TEMPLATE_VIS logical_not : unary_function<_Tp, bool>
 {
+    typedef bool __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x) const
         {return !__x;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS logical_not<void>

 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
 struct _LIBCPP_TEMPLATE_VIS bit_and : binary_function<_Tp, _Tp, _Tp>
 {
+    typedef _Tp __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x & __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS bit_and<void>

 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
 struct _LIBCPP_TEMPLATE_VIS bit_or : binary_function<_Tp, _Tp, _Tp>
 {
+    typedef _Tp __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x | __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS bit_or<void>

 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
 struct _LIBCPP_TEMPLATE_VIS bit_xor : binary_function<_Tp, _Tp, _Tp>
 {
+    typedef _Tp __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x ^ __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS bit_xor<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const
     _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u)))
     -> decltype        (_VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u))
         { return        _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u); }
     typedef void is_transparent;
 };
 #endif
 
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
 struct _LIBCPP_TEMPLATE_VIS bit_not : unary_function<_Tp, _Tp>
 {
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
         {return ~__x;}
 };
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS bit_not<void>

libcxx/include/valarray

 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 const _Tp*
 end(const valarray<_Tp>& __v);
 
 template <class _Op, class _A0>
 struct _UnaryOp
 {
-    typedef typename _Op::result_type result_type;
+    typedef typename _Op::__result_type __result_type;
     typedef typename _A0::value_type value_type;
 
     _Op __op_;
     _A0 __a0_;
 
     _LIBCPP_INLINE_VISIBILITY
     _UnaryOp(const _Op& __op, const _A0& __a0) : __op_(__op), __a0_(__a0) {}
 
     _LIBCPP_INLINE_VISIBILITY
-    result_type operator[](size_t __i) const {return __op_(__a0_[__i]);}
+    __result_type operator[](size_t __i) const {return __op_(__a0_[__i]);}
 
     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return __a0_.size();}
 };
 
 template <class _Op, class _A0, class _A1>
 struct _BinaryOp
 {
-    typedef typename _Op::result_type result_type;
+    typedef typename _Op::__result_type __result_type;
     typedef typename _A0::value_type value_type;
 
     _Op __op_;
     _A0 __a0_;
     _A1 __a1_;
 
     _LIBCPP_INLINE_VISIBILITY
     _BinaryOp(const _Op& __op, const _A0& __a0, const _A1& __a1)
         : __op_(__op), __a0_(__a0), __a1_(__a1) {}
 
     _LIBCPP_INLINE_VISIBILITY
     value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
 
     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return __a0_.size();}
 };
 
 template <class _Tp>
 class __scalar_expr
 {
 public:
     typedef _Tp        value_type;
-    typedef const _Tp& result_type;
+    typedef const _Tp& __result_type;
 private:
     const value_type& __t_;
     size_t __s_;
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit __scalar_expr(const value_type& __t, size_t __s) : __t_(__t), __s_(__s) {}
 
     _LIBCPP_INLINE_VISIBILITY
-    result_type operator[](size_t) const {return __t_;}
+    __result_type operator[](size_t) const {return __t_;}
 
     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return __s_;}
 };
 
 template <class _Tp>
-struct __unary_plus : unary_function<_Tp, _Tp>
+struct __unary_plus
 {
+    typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
         {return +__x;}
 };
 
 template <class _Tp>
-struct __bit_not  : unary_function<_Tp, _Tp>
+struct __bit_not
 {
+    typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
         {return ~__x;}
 };
 
 template <class _Tp>
-struct __bit_shift_left : binary_function<_Tp, _Tp, _Tp>
+struct __bit_shift_left
 {
+    typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x << __y;}
 };
 
 template <class _Tp>
-struct __bit_shift_right : binary_function<_Tp, _Tp, _Tp>
+struct __bit_shift_right
 {
+    typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x >> __y;}
 };
 
 template <class _Tp, class _Fp>
-struct __apply_expr   : unary_function<_Tp, _Tp>
+struct __apply_expr
 {
 private:
     _Fp __f_;
 public:
+    typedef _Tp __result_type;
+
     _LIBCPP_INLINE_VISIBILITY
     explicit __apply_expr(_Fp __f) : __f_(__f) {}
 
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
         {return __f_(__x);}
 };
 
 template <class _Tp>
-struct __abs_expr : unary_function<_Tp, _Tp>
+struct __abs_expr
 {
+    typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
         {return abs(__x);}
 };
 
 template <class _Tp>
-struct __acos_expr : unary_function<_Tp, _Tp>
+struct __acos_expr
 {
+    typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
         {return acos(__x);}
 };
 
 template <class _Tp>
-struct __asin_expr : unary_function<_Tp, _Tp>
+struct __asin_expr
 {
+    typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
         {return asin(__x);}
 };
 
 template <class _Tp>
-struct __atan_expr : unary_function<_Tp, _Tp>
+struct __atan_expr
 {
+    typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
         {return atan(__x);}
 };
 
 template <class _Tp>
-struct __atan2_expr : binary_function<_Tp, _Tp, _Tp>
+struct __atan2_expr
 {
+    typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return atan2(__x, __y);}
 };
 
 template <class _Tp>
-struct __cos_expr : unary_function<_Tp, _Tp>
+struct __cos_expr
 {
+    typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
         {return cos(__x);}
 };
 
 template <class _Tp>
-struct __cosh_expr : unary_function<_Tp, _Tp>
+struct __cosh_expr
 {
+    typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
         {return cosh(__x);}
 };
 
 template <class _Tp>
-struct __exp_expr : unary_function<_Tp, _Tp>
+struct __exp_expr
 {
+    typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
         {return exp(__x);}
 };
 
 template <class _Tp>
-struct __log_expr : unary_function<_Tp, _Tp>
+struct __log_expr
 {
+    typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
         {return log(__x);}
 };
 
 template <class _Tp>
-struct __log10_expr : unary_function<_Tp, _Tp>
+struct __log10_expr
 {
+    typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
         {return log10(__x);}
 };
 
 template <class _Tp>
-struct __pow_expr : binary_function<_Tp, _Tp, _Tp>
+struct __pow_expr
 {
+    typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return pow(__x, __y);}
 };
 
 template <class _Tp>
-struct __sin_expr : unary_function<_Tp, _Tp>
+struct __sin_expr
 {
+    typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
         {return sin(__x);}
 };
 
 template <class _Tp>
-struct __sinh_expr : unary_function<_Tp, _Tp>
+struct __sinh_expr
 {
+    typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
         {return sinh(__x);}
 };
 
 template <class _Tp>
-struct __sqrt_expr : unary_function<_Tp, _Tp>
+struct __sqrt_expr
 {
+    typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
         {return sqrt(__x);}
 };
 
 template <class _Tp>
-struct __tan_expr : unary_function<_Tp, _Tp>
+struct __tan_expr
 {
+    typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
         {return tan(__x);}
 };
 
 template <class _Tp>
-struct __tanh_expr : unary_function<_Tp, _Tp>
+struct __tanh_expr
 {
+    typedef _Tp __result_type;
     _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
         {return tanh(__x);}
 };
 
 template <class _ValExpr>
 class __slice_expr
 {
     typedef typename remove_reference<_ValExpr>::type  _RmExpr;
 public:
     typedef typename _RmExpr::value_type value_type;
-    typedef value_type result_type;
+    typedef value_type __result_type;
 
 private:
     _ValExpr __expr_;
     size_t __start_;
     size_t __size_;
     size_t __stride_;
 
     _LIBCPP_INLINE_VISIBILITY
     __slice_expr(const slice& __sl, const _RmExpr& __e)
         : __expr_(__e),
           __start_(__sl.start()),
           __size_(__sl.size()),
           __stride_(__sl.stride())
         {}
 public:
 
     _LIBCPP_INLINE_VISIBILITY
-    result_type operator[](size_t __i) const
+    __result_type operator[](size_t __i) const
         {return __expr_[__start_ + __i * __stride_];}
 
     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return __size_;}
 
     template <class> friend class __val_expr;
     template <class> friend class _LIBCPP_TEMPLATE_VIS valarray;
 };
 
 template <class _ValExpr>
 class __mask_expr;
 
 template <class _ValExpr>
 class __indirect_expr;
 
 template <class _ValExpr>
 class __shift_expr
 {
     typedef typename remove_reference<_ValExpr>::type  _RmExpr;
 public:
     typedef typename _RmExpr::value_type value_type;
-    typedef value_type result_type;
+    typedef value_type __result_type;
 
 private:
     _ValExpr __expr_;
     size_t __size_;
     ptrdiff_t __ul_;
     ptrdiff_t __sn_;
     ptrdiff_t __n_;
     static const ptrdiff_t _Np = static_cast<ptrdiff_t>(
                                     sizeof(ptrdiff_t) * __CHAR_BIT__ - 1);
 
     _LIBCPP_INLINE_VISIBILITY
     __shift_expr(int __n, const _RmExpr& __e)
         : __expr_(__e),
           __size_(__e.size()),
           __n_(__n)
         {
             ptrdiff_t __neg_n = static_cast<ptrdiff_t>(__n_ >> _Np);
             __sn_ = __neg_n | static_cast<ptrdiff_t>(static_cast<size_t>(-__n_) >> _Np);
             __ul_ = ((__size_ - __n_) & ~__neg_n) | ((__n_ + 1) & __neg_n);
         }
 public:
 
     _LIBCPP_INLINE_VISIBILITY
-    result_type operator[](size_t __j) const
+    __result_type operator[](size_t __j) const
         {
             ptrdiff_t __i = static_cast<ptrdiff_t>(__j);
             ptrdiff_t __m = (__sn_ * __i - __ul_) >> _Np;
             return (__expr_[(__i + __n_) & __m] & __m) | (value_type() & ~__m);
         }
 
     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return __size_;}
 
     template <class> friend class __val_expr;
 };
 
 template <class _ValExpr>
 class __cshift_expr
 {
     typedef typename remove_reference<_ValExpr>::type  _RmExpr;
 public:
     typedef typename _RmExpr::value_type value_type;
-    typedef value_type result_type;
+    typedef value_type __result_type;
 
 private:
     _ValExpr __expr_;
     size_t __size_;
     size_t __m_;
     size_t __o1_;
     size_t __o2_;
 
__cshift_expr(int __n, const _RmExpr& __e)
                 __m_ = -__n;
                 __o1_ = __n + __size_;
                 __o2_ = __n;
             }
         }
 public:
 
     _LIBCPP_INLINE_VISIBILITY
-    result_type operator[](size_t __i) const
+    __result_type operator[](size_t __i) const
         {
             if (__i < __m_)
                 return __expr_[__i + __o1_];
             return __expr_[__i + __o2_];
         }
 
     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return __size_;}

 template<class _Tp>
 struct __is_val_expr<valarray<_Tp> > : true_type {};
 
 template<class _Tp>
 class _LIBCPP_TEMPLATE_VIS valarray
 {
 public:
     typedef _Tp value_type;
-    typedef _Tp result_type;
+    typedef _Tp __result_type;
 
 private:
     value_type* __begin_;
     value_type* __end_;
 
 public:
     // construct/destroy:
     _LIBCPP_INLINE_VISIBILITY
private:
     valarray& __assign_range(const value_type* __f, const value_type* __l);
 };
 
 _LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void valarray<size_t>::resize(size_t, size_t))
 
 template <class _Op, class _Tp>
 struct _UnaryOp<_Op, valarray<_Tp> >
 {
-    typedef typename _Op::result_type result_type;
+    typedef typename _Op::__result_type __result_type;
     typedef _Tp value_type;
 
     _Op __op_;
     const valarray<_Tp>& __a0_;
 
     _LIBCPP_INLINE_VISIBILITY
     _UnaryOp(const _Op& __op, const valarray<_Tp>& __a0) : __op_(__op), __a0_(__a0) {}
 
     _LIBCPP_INLINE_VISIBILITY
-    result_type operator[](size_t __i) const {return __op_(__a0_[__i]);}
+    __result_type operator[](size_t __i) const {return __op_(__a0_[__i]);}
 
     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return __a0_.size();}
 };
 
 template <class _Op, class _Tp, class _A1>
 struct _BinaryOp<_Op, valarray<_Tp>, _A1>
 {
-    typedef typename _Op::result_type result_type;
+    typedef typename _Op::__result_type __result_type;
     typedef _Tp value_type;
 
     _Op __op_;
     const valarray<_Tp>& __a0_;
     _A1 __a1_;
 
     _LIBCPP_INLINE_VISIBILITY
     _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const _A1& __a1)
         : __op_(__op), __a0_(__a0), __a1_(__a1) {}
 
     _LIBCPP_INLINE_VISIBILITY
     value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
 
     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return __a0_.size();}
 };
 
 template <class _Op, class _A0, class _Tp>
 struct _BinaryOp<_Op, _A0, valarray<_Tp> >
 {
-    typedef typename _Op::result_type result_type;
+    typedef typename _Op::__result_type __result_type;
     typedef _Tp value_type;
 
     _Op __op_;
     _A0 __a0_;
     const valarray<_Tp>& __a1_;
 
     _LIBCPP_INLINE_VISIBILITY
     _BinaryOp(const _Op& __op, const _A0& __a0, const valarray<_Tp>& __a1)
         : __op_(__op), __a0_(__a0), __a1_(__a1) {}
 
     _LIBCPP_INLINE_VISIBILITY
     value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
 
     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return __a0_.size();}
 };
 
 template <class _Op, class _Tp>
 struct _BinaryOp<_Op, valarray<_Tp>, valarray<_Tp> >
 {
-    typedef typename _Op::result_type result_type;
+    typedef typename _Op::__result_type __result_type;
     typedef _Tp value_type;
 
     _Op __op_;
     const valarray<_Tp>& __a0_;
     const valarray<_Tp>& __a1_;
 
     _LIBCPP_INLINE_VISIBILITY
     _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const valarray<_Tp>& __a1)

 }
 
 template <class _ValExpr>
 class __mask_expr
 {
     typedef typename remove_reference<_ValExpr>::type  _RmExpr;
 public:
     typedef typename _RmExpr::value_type value_type;
-    typedef value_type result_type;
+    typedef value_type __result_type;
 
 private:
     _ValExpr __expr_;
     valarray<size_t> __1d_;
 
     _LIBCPP_INLINE_VISIBILITY
     __mask_expr(const valarray<bool>& __vb, const _RmExpr& __e)
         : __expr_(__e),
           __1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true)))
           {
               size_t __j = 0;
               for (size_t __i = 0; __i < __vb.size(); ++__i)
                   if (__vb[__i])
                       __1d_[__j++] = __i;
           }
 
 public:
     _LIBCPP_INLINE_VISIBILITY
-    result_type operator[](size_t __i) const
+    __result_type operator[](size_t __i) const
         {return __expr_[__1d_[__i]];}
 
     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return __1d_.size();}
 
     template <class> friend class __val_expr;
     template <class> friend class valarray;
 };

 }
 
 template <class _ValExpr>
 class __indirect_expr
 {
     typedef typename remove_reference<_ValExpr>::type  _RmExpr;
 public:
     typedef typename _RmExpr::value_type value_type;
-    typedef value_type result_type;
+    typedef value_type __result_type;
 
 private:
     _ValExpr __expr_;
     valarray<size_t> __1d_;
 
     _LIBCPP_INLINE_VISIBILITY
     __indirect_expr(const valarray<size_t>& __ia, const _RmExpr& __e)
         : __expr_(__e),
           __1d_(__ia)
           {}
 
 #ifndef _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY
     __indirect_expr(valarray<size_t>&& __ia, const _RmExpr& __e)
         : __expr_(__e),
           __1d_(move(__ia))
           {}
 
 #endif // _LIBCPP_CXX03_LANG
 
 public:
     _LIBCPP_INLINE_VISIBILITY
-    result_type operator[](size_t __i) const
+    __result_type operator[](size_t __i) const
         {return __expr_[__1d_[__i]];}
 
     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return __1d_.size();}
 
     template <class> friend class __val_expr;
     template <class> friend class _LIBCPP_TEMPLATE_VIS valarray;
 };
 
 template<class _ValExpr>
 class __val_expr
 {
     typedef typename remove_reference<_ValExpr>::type  _RmExpr;
 
     _ValExpr __expr_;
 public:
     typedef typename _RmExpr::value_type value_type;
-    typedef typename _RmExpr::result_type result_type;
+    typedef typename _RmExpr::__result_type __result_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __val_expr(const _RmExpr& __e) : __expr_(__e) {}
 
     _LIBCPP_INLINE_VISIBILITY
-    result_type operator[](size_t __i) const
+    __result_type operator[](size_t __i) const
         {return __expr_[__i];}
 
     _LIBCPP_INLINE_VISIBILITY
     __val_expr<__slice_expr<_ValExpr> > operator[](slice __s) const
     {
         typedef __slice_expr<_ValExpr> _NewExpr;
         return __val_expr< _NewExpr >(_NewExpr(__s, __expr_));
     }
public:
     _LIBCPP_INLINE_VISIBILITY
     __val_expr<_UnaryOp<logical_not<value_type>, _ValExpr> >
     operator!() const
     {
         typedef _UnaryOp<logical_not<value_type>, _ValExpr> _NewExpr;
         return __val_expr<_NewExpr>(_NewExpr(logical_not<value_type>(), __expr_));
     }
 
-    operator valarray<result_type>() const;
+    operator valarray<__result_type>() const;
 
     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return __expr_.size();}
 
     _LIBCPP_INLINE_VISIBILITY
-    result_type sum() const
+    __result_type sum() const
     {
         size_t __n = __expr_.size();
-        result_type __r = __n ? __expr_[0] : result_type();
+        __result_type __r = __n ? __expr_[0] : __result_type();
         for (size_t __i = 1; __i < __n; ++__i)
             __r += __expr_[__i];
         return __r;
     }
 
     _LIBCPP_INLINE_VISIBILITY
-    result_type min() const
+    __result_type min() const
     {
         size_t __n = size();
-        result_type __r = __n ? (*this)[0] : result_type();
+        __result_type __r = __n ? (*this)[0] : __result_type();
         for (size_t __i = 1; __i < __n; ++__i)
         {
-            result_type __x = __expr_[__i];
+            __result_type __x = __expr_[__i];
             if (__x < __r)
                 __r = __x;
         }
         return __r;
     }
 
     _LIBCPP_INLINE_VISIBILITY
-    result_type max() const
+    __result_type max() const
     {
         size_t __n = size();
-        result_type __r = __n ? (*this)[0] : result_type();
+        __result_type __r = __n ? (*this)[0] : __result_type();
         for (size_t __i = 1; __i < __n; ++__i)
         {
-            result_type __x = __expr_[__i];
+            __result_type __x = __expr_[__i];
             if (__r < __x)
                 __r = __x;
         }
         return __r;
     }
 
     _LIBCPP_INLINE_VISIBILITY
     __val_expr<__shift_expr<_ValExpr> > shift (int __i) const
public:
     {
         typedef __apply_expr<value_type, value_type(*)(const value_type&)> _Op;
         typedef _UnaryOp<_Op, _ValExpr> _NewExpr;
         return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_));
     }
 };
 
 template<class _ValExpr>
-__val_expr<_ValExpr>::operator valarray<__val_expr::result_type>() const
+__val_expr<_ValExpr>::operator valarray<__val_expr::__result_type>() const
 {
-    valarray<result_type> __r;
+    valarray<__result_type> __r;
     size_t __n = __expr_.size();
     if (__n)
     {
         __r.__begin_ =
-            __r.__end_ = allocator<result_type>().allocate(__n);
+            __r.__end_ = allocator<__result_type>().allocate(__n);
         for (size_t __i = 0; __i != __n; ++__r.__end_, ++__i)
-            ::new ((void*)__r.__end_) result_type(__expr_[__i]);
+            ::new ((void*)__r.__end_) __result_type(__expr_[__i]);
     }
     return __r;
 }
 
 // valarray
 
 template <class _Tp>
 inline

 valarray<_Tp>&
 valarray<_Tp>::operator=(const __val_expr<_ValExpr>& __v)
 {
     size_t __n = __v.size();
     if (size() != __n)
         resize(__n);
     value_type* __t = __begin_;
     for (size_t __i = 0; __i != __n; ++__t, ++__i)
-        *__t = result_type(__v[__i]);
+        *__t = __result_type(__v[__i]);
     return *this;
 }
 
 template <class _Tp>
 inline
 __val_expr<__slice_expr<const valarray<_Tp>&> >
 valarray<_Tp>::operator[](slice __s) const
 {