libcxx/include/__functional/operations.h

   1 // -*- C++ -*-
   2 //===----------------------------------------------------------------------===//
   3 //
   4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef _LIBCPP___FUNCTIONAL_OPERATIONS_H
  11 #define _LIBCPP___FUNCTIONAL_OPERATIONS_H
  12
  13 #include <__config>
  14 #include <__functional/binary_function.h>
  15 #include <__functional/unary_function.h>
  16 #include <__type_traits/integral_constant.h>
  17 #include <__type_traits/operation_traits.h>
  18 #include <__type_traits/predicate_traits.h>
  19 #include <__utility/forward.h>
  20
  21 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
  22 #  pragma GCC system_header
  23 #endif
  24
  25 _LIBCPP_BEGIN_NAMESPACE_STD
  26
  27 // Arithmetic operations
  28
  29 #if _LIBCPP_STD_VER >= 14
  30 template <class _Tp = void>
  31 #else
  32 template <class _Tp>
  33 #endif
  34 struct _LIBCPP_TEMPLATE_VIS plus
  35     : __binary_function<_Tp, _Tp, _Tp>
  36 {
  37     typedef _Tp __result_type;  // used by valarray
  38     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
  39     _Tp operator()(const _Tp& __x, const _Tp& __y) const
  40         {return __x + __y;}
  41 };
  42 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(plus);
  43
  44 template <class _Tp>
  45 struct __is_trivial_plus_operation<plus<_Tp>, _Tp, _Tp> : true_type {};
  46
  47 #if _LIBCPP_STD_VER >= 14
  48 template <class _Tp, class _Up>
  49 struct __is_trivial_plus_operation<plus<>, _Tp, _Up> : true_type {};
  50 #endif
  51
  52 #if _LIBCPP_STD_VER >= 14
  53 template <>
  54 struct _LIBCPP_TEMPLATE_VIS plus<void>
  55 {
  56     template <class _T1, class _T2>
  57     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
  58     auto operator()(_T1&& __t, _T2&& __u) const
  59         noexcept(noexcept(_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u)))
  60         -> decltype(      _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u))
  61         { return          _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u); }
  62     typedef void is_transparent;
  63 };
  64 #endif
  65
  66 #if _LIBCPP_STD_VER >= 14
  67 template <class _Tp = void>
  68 #else
  69 template <class _Tp>
  70 #endif
  71 struct _LIBCPP_TEMPLATE_VIS minus
  72     : __binary_function<_Tp, _Tp, _Tp>
  73 {
  74     typedef _Tp __result_type;  // used by valarray
  75     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
  76     _Tp operator()(const _Tp& __x, const _Tp& __y) const
  77         {return __x - __y;}
  78 };
  79 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(minus);
  80
  81 #if _LIBCPP_STD_VER >= 14
  82 template <>
  83 struct _LIBCPP_TEMPLATE_VIS minus<void>
  84 {
  85     template <class _T1, class _T2>
  86     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
  87     auto operator()(_T1&& __t, _T2&& __u) const
  88         noexcept(noexcept(_VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u)))
  89         -> decltype(      _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u))
  90         { return          _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u); }
  91     typedef void is_transparent;
  92 };
  93 #endif
  94
  95 #if _LIBCPP_STD_VER >= 14
  96 template <class _Tp = void>
  97 #else
  98 template <class _Tp>
  99 #endif
 100 struct _LIBCPP_TEMPLATE_VIS multiplies
 101     : __binary_function<_Tp, _Tp, _Tp>
 102 {
 103     typedef _Tp __result_type;  // used by valarray
 104     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 105     _Tp operator()(const _Tp& __x, const _Tp& __y) const
 106         {return __x * __y;}
 107 };
 108 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(multiplies);
 109
 110 #if _LIBCPP_STD_VER >= 14
 111 template <>
 112 struct _LIBCPP_TEMPLATE_VIS multiplies<void>
 113 {
 114     template <class _T1, class _T2>
 115     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 116     auto operator()(_T1&& __t, _T2&& __u) const
 117         noexcept(noexcept(_VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u)))
 118         -> decltype(      _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u))
 119         { return          _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u); }
 120     typedef void is_transparent;
 121 };
 122 #endif
 123
 124 #if _LIBCPP_STD_VER >= 14
 125 template <class _Tp = void>
 126 #else
 127 template <class _Tp>
 128 #endif
 129 struct _LIBCPP_TEMPLATE_VIS divides
 130     : __binary_function<_Tp, _Tp, _Tp>
 131 {
 132     typedef _Tp __result_type;  // used by valarray
 133     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 134     _Tp operator()(const _Tp& __x, const _Tp& __y) const
 135         {return __x / __y;}
 136 };
 137 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(divides);
 138
 139 #if _LIBCPP_STD_VER >= 14
 140 template <>
 141 struct _LIBCPP_TEMPLATE_VIS divides<void>
 142 {
 143     template <class _T1, class _T2>
 144     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 145     auto operator()(_T1&& __t, _T2&& __u) const
 146         noexcept(noexcept(_VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u)))
 147         -> decltype(      _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u))
 148         { return          _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u); }
 149     typedef void is_transparent;
 150 };
 151 #endif
 152
 153 #if _LIBCPP_STD_VER >= 14
 154 template <class _Tp = void>
 155 #else
 156 template <class _Tp>
 157 #endif
 158 struct _LIBCPP_TEMPLATE_VIS modulus
 159     : __binary_function<_Tp, _Tp, _Tp>
 160 {
 161     typedef _Tp __result_type;  // used by valarray
 162     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 163     _Tp operator()(const _Tp& __x, const _Tp& __y) const
 164         {return __x % __y;}
 165 };
 166 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(modulus);
 167
 168 #if _LIBCPP_STD_VER >= 14
 169 template <>
 170 struct _LIBCPP_TEMPLATE_VIS modulus<void>
 171 {
 172     template <class _T1, class _T2>
 173     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 174     auto operator()(_T1&& __t, _T2&& __u) const
 175         noexcept(noexcept(_VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u)))
 176         -> decltype(      _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u))
 177         { return          _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u); }
 178     typedef void is_transparent;
 179 };
 180 #endif
 181
 182 #if _LIBCPP_STD_VER >= 14
 183 template <class _Tp = void>
 184 #else
 185 template <class _Tp>
 186 #endif
 187 struct _LIBCPP_TEMPLATE_VIS negate
 188     : __unary_function<_Tp, _Tp>
 189 {
 190     typedef _Tp __result_type;  // used by valarray
 191     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 192     _Tp operator()(const _Tp& __x) const
 193         {return -__x;}
 194 };
 195 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(negate);
 196
 197 #if _LIBCPP_STD_VER >= 14
 198 template <>
 199 struct _LIBCPP_TEMPLATE_VIS negate<void>
 200 {
 201     template <class _Tp>
 202     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 203     auto operator()(_Tp&& __x) const
 204         noexcept(noexcept(- _VSTD::forward<_Tp>(__x)))
 205         -> decltype(      - _VSTD::forward<_Tp>(__x))
 206         { return          - _VSTD::forward<_Tp>(__x); }
 207     typedef void is_transparent;
 208 };
 209 #endif
 210
 211 // Bitwise operations
 212
 213 #if _LIBCPP_STD_VER >= 14
 214 template <class _Tp = void>
 215 #else
 216 template <class _Tp>
 217 #endif
 218 struct _LIBCPP_TEMPLATE_VIS bit_and
 219     : __binary_function<_Tp, _Tp, _Tp>
 220 {
 221     typedef _Tp __result_type;  // used by valarray
 222     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 223     _Tp operator()(const _Tp& __x, const _Tp& __y) const
 224         {return __x & __y;}
 225 };
 226 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_and);
 227
 228 #if _LIBCPP_STD_VER >= 14
 229 template <>
 230 struct _LIBCPP_TEMPLATE_VIS bit_and<void>
 231 {
 232     template <class _T1, class _T2>
 233     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 234     auto operator()(_T1&& __t, _T2&& __u) const
 235         noexcept(noexcept(_VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u)))
 236         -> decltype(      _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u))
 237         { return          _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u); }
 238     typedef void is_transparent;
 239 };
 240 #endif
 241
 242 #if _LIBCPP_STD_VER >= 14
 243 template <class _Tp = void>
 244 struct _LIBCPP_TEMPLATE_VIS bit_not
 245     : __unary_function<_Tp, _Tp>
 246 {
 247     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 248     _Tp operator()(const _Tp& __x) const
 249         {return ~__x;}
 250 };
 251 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_not);
 252
 253 template <>
 254 struct _LIBCPP_TEMPLATE_VIS bit_not<void>
 255 {
 256     template <class _Tp>
 257     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 258     auto operator()(_Tp&& __x) const
 259         noexcept(noexcept(~_VSTD::forward<_Tp>(__x)))
 260         -> decltype(      ~_VSTD::forward<_Tp>(__x))
 261         { return          ~_VSTD::forward<_Tp>(__x); }
 262     typedef void is_transparent;
 263 };
 264 #endif
 265
 266 #if _LIBCPP_STD_VER >= 14
 267 template <class _Tp = void>
 268 #else
 269 template <class _Tp>
 270 #endif
 271 struct _LIBCPP_TEMPLATE_VIS bit_or
 272     : __binary_function<_Tp, _Tp, _Tp>
 273 {
 274     typedef _Tp __result_type;  // used by valarray
 275     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 276     _Tp operator()(const _Tp& __x, const _Tp& __y) const
 277         {return __x | __y;}
 278 };
 279 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_or);
 280
 281 #if _LIBCPP_STD_VER >= 14
 282 template <>
 283 struct _LIBCPP_TEMPLATE_VIS bit_or<void>
 284 {
 285     template <class _T1, class _T2>
 286     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 287     auto operator()(_T1&& __t, _T2&& __u) const
 288         noexcept(noexcept(_VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u)))
 289         -> decltype(      _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u))
 290         { return          _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u); }
 291     typedef void is_transparent;
 292 };
 293 #endif
 294
 295 #if _LIBCPP_STD_VER >= 14
 296 template <class _Tp = void>
 297 #else
 298 template <class _Tp>
 299 #endif
 300 struct _LIBCPP_TEMPLATE_VIS bit_xor
 301     : __binary_function<_Tp, _Tp, _Tp>
 302 {
 303     typedef _Tp __result_type;  // used by valarray
 304     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 305     _Tp operator()(const _Tp& __x, const _Tp& __y) const
 306         {return __x ^ __y;}
 307 };
 308 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_xor);
 309
 310 #if _LIBCPP_STD_VER >= 14
 311 template <>
 312 struct _LIBCPP_TEMPLATE_VIS bit_xor<void>
 313 {
 314     template <class _T1, class _T2>
 315     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 316     auto operator()(_T1&& __t, _T2&& __u) const
 317         noexcept(noexcept(_VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u)))
 318         -> decltype(      _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u))
 319         { return          _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u); }
 320     typedef void is_transparent;
 321 };
 322 #endif
 323
 324 // Comparison operations
 325
 326 #if _LIBCPP_STD_VER >= 14
 327 template <class _Tp = void>
 328 #else
 329 template <class _Tp>
 330 #endif
 331 struct _LIBCPP_TEMPLATE_VIS equal_to
 332     : __binary_function<_Tp, _Tp, bool>
 333 {
 334     typedef bool __result_type;  // used by valarray
 335     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 336     bool operator()(const _Tp& __x, const _Tp& __y) const
 337         {return __x == __y;}
 338 };
 339 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(equal_to);
 340
 341 #if _LIBCPP_STD_VER >= 14
 342 template <>
 343 struct _LIBCPP_TEMPLATE_VIS equal_to<void>
 344 {
 345     template <class _T1, class _T2>
 346     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 347     auto operator()(_T1&& __t, _T2&& __u) const
 348         noexcept(noexcept(_VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u)))
 349         -> decltype(      _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u))
 350         { return          _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u); }
 351     typedef void is_transparent;
 352 };
 353 #endif
 354
 355 template <class _Tp>
 356 struct __is_trivial_equality_predicate<equal_to<_Tp>, _Tp, _Tp> : true_type {};
 357
 358 #if _LIBCPP_STD_VER >= 14
 359 template <class _Tp>
 360 struct __is_trivial_equality_predicate<equal_to<>, _Tp, _Tp> : true_type {};
 361 #endif
 362
 363 #if _LIBCPP_STD_VER >= 14
 364 template <class _Tp = void>
 365 #else
 366 template <class _Tp>
 367 #endif
 368 struct _LIBCPP_TEMPLATE_VIS not_equal_to
 369     : __binary_function<_Tp, _Tp, bool>
 370 {
 371     typedef bool __result_type;  // used by valarray
 372     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 373     bool operator()(const _Tp& __x, const _Tp& __y) const
 374         {return __x != __y;}
 375 };
 376 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(not_equal_to);
 377
 378 #if _LIBCPP_STD_VER >= 14
 379 template <>
 380 struct _LIBCPP_TEMPLATE_VIS not_equal_to<void>
 381 {
 382     template <class _T1, class _T2>
 383     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 384     auto operator()(_T1&& __t, _T2&& __u) const
 385         noexcept(noexcept(_VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u)))
 386         -> decltype(      _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u))
 387         { return          _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u); }
 388     typedef void is_transparent;
 389 };
 390 #endif
 391
 392 #if _LIBCPP_STD_VER >= 14
 393 template <class _Tp = void>
 394 #else
 395 template <class _Tp>
 396 #endif
 397 struct _LIBCPP_TEMPLATE_VIS less
 398     : __binary_function<_Tp, _Tp, bool>
 399 {
 400     typedef bool __result_type;  // used by valarray
 401     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 402     bool operator()(const _Tp& __x, const _Tp& __y) const
 403         {return __x < __y;}
 404 };
 405 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(less);
 406
 407 #if _LIBCPP_STD_VER >= 14
 408 template <>
 409 struct _LIBCPP_TEMPLATE_VIS less<void>
 410 {
 411     template <class _T1, class _T2>
 412     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 413     auto operator()(_T1&& __t, _T2&& __u) const
 414         noexcept(noexcept(_VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u)))
 415         -> decltype(      _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u))
 416         { return          _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u); }
 417     typedef void is_transparent;
 418 };
 419 #endif
 420
 421 #if _LIBCPP_STD_VER >= 14
 422 template <class _Tp = void>
 423 #else
 424 template <class _Tp>
 425 #endif
 426 struct _LIBCPP_TEMPLATE_VIS less_equal
 427     : __binary_function<_Tp, _Tp, bool>
 428 {
 429     typedef bool __result_type;  // used by valarray
 430     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 431     bool operator()(const _Tp& __x, const _Tp& __y) const
 432         {return __x <= __y;}
 433 };
 434 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(less_equal);
 435
 436 #if _LIBCPP_STD_VER >= 14
 437 template <>
 438 struct _LIBCPP_TEMPLATE_VIS less_equal<void>
 439 {
 440     template <class _T1, class _T2>
 441     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 442     auto operator()(_T1&& __t, _T2&& __u) const
 443         noexcept(noexcept(_VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u)))
 444         -> decltype(      _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u))
 445         { return          _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u); }
 446     typedef void is_transparent;
 447 };
 448 #endif
 449
 450 #if _LIBCPP_STD_VER >= 14
 451 template <class _Tp = void>
 452 #else
 453 template <class _Tp>
 454 #endif
 455 struct _LIBCPP_TEMPLATE_VIS greater_equal
 456     : __binary_function<_Tp, _Tp, bool>
 457 {
 458     typedef bool __result_type;  // used by valarray
 459     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 460     bool operator()(const _Tp& __x, const _Tp& __y) const
 461         {return __x >= __y;}
 462 };
 463 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(greater_equal);
 464
 465 #if _LIBCPP_STD_VER >= 14
 466 template <>
 467 struct _LIBCPP_TEMPLATE_VIS greater_equal<void>
 468 {
 469     template <class _T1, class _T2>
 470     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 471     auto operator()(_T1&& __t, _T2&& __u) const
 472         noexcept(noexcept(_VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u)))
 473         -> decltype(      _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u))
 474         { return          _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u); }
 475     typedef void is_transparent;
 476 };
 477 #endif
 478
 479 #if _LIBCPP_STD_VER >= 14
 480 template <class _Tp = void>
 481 #else
 482 template <class _Tp>
 483 #endif
 484 struct _LIBCPP_TEMPLATE_VIS greater
 485     : __binary_function<_Tp, _Tp, bool>
 486 {
 487     typedef bool __result_type;  // used by valarray
 488     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 489     bool operator()(const _Tp& __x, const _Tp& __y) const
 490         {return __x > __y;}
 491 };
 492 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(greater);
 493
 494 #if _LIBCPP_STD_VER >= 14
 495 template <>
 496 struct _LIBCPP_TEMPLATE_VIS greater<void>
 497 {
 498     template <class _T1, class _T2>
 499     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 500     auto operator()(_T1&& __t, _T2&& __u) const
 501         noexcept(noexcept(_VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u)))
 502         -> decltype(      _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u))
 503         { return          _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u); }
 504     typedef void is_transparent;
 505 };
 506 #endif
 507
 508 // Logical operations
 509
 510 #if _LIBCPP_STD_VER >= 14
 511 template <class _Tp = void>
 512 #else
 513 template <class _Tp>
 514 #endif
 515 struct _LIBCPP_TEMPLATE_VIS logical_and
 516     : __binary_function<_Tp, _Tp, bool>
 517 {
 518     typedef bool __result_type;  // used by valarray
 519     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 520     bool operator()(const _Tp& __x, const _Tp& __y) const
 521         {return __x && __y;}
 522 };
 523 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_and);
 524
 525 #if _LIBCPP_STD_VER >= 14
 526 template <>
 527 struct _LIBCPP_TEMPLATE_VIS logical_and<void>
 528 {
 529     template <class _T1, class _T2>
 530     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 531     auto operator()(_T1&& __t, _T2&& __u) const
 532         noexcept(noexcept(_VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u)))
 533         -> decltype(      _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u))
 534         { return          _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u); }
 535     typedef void is_transparent;
 536 };
 537 #endif
 538
 539 #if _LIBCPP_STD_VER >= 14
 540 template <class _Tp = void>
 541 #else
 542 template <class _Tp>
 543 #endif
 544 struct _LIBCPP_TEMPLATE_VIS logical_not
 545     : __unary_function<_Tp, bool>
 546 {
 547     typedef bool __result_type;  // used by valarray
 548     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 549     bool operator()(const _Tp& __x) const
 550         {return !__x;}
 551 };
 552 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_not);
 553
 554 #if _LIBCPP_STD_VER >= 14
 555 template <>
 556 struct _LIBCPP_TEMPLATE_VIS logical_not<void>
 557 {
 558     template <class _Tp>
 559     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 560     auto operator()(_Tp&& __x) const
 561         noexcept(noexcept(!_VSTD::forward<_Tp>(__x)))
 562         -> decltype(      !_VSTD::forward<_Tp>(__x))
 563         { return          !_VSTD::forward<_Tp>(__x); }
 564     typedef void is_transparent;
 565 };
 566 #endif
 567
 568 #if _LIBCPP_STD_VER >= 14
 569 template <class _Tp = void>
 570 #else
 571 template <class _Tp>
 572 #endif
 573 struct _LIBCPP_TEMPLATE_VIS logical_or
 574     : __binary_function<_Tp, _Tp, bool>
 575 {
 576     typedef bool __result_type;  // used by valarray
 577     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 578     bool operator()(const _Tp& __x, const _Tp& __y) const
 579         {return __x || __y;}
 580 };
 581 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_or);
 582
 583 #if _LIBCPP_STD_VER >= 14
 584 template <>
 585 struct _LIBCPP_TEMPLATE_VIS logical_or<void>
 586 {
 587     template <class _T1, class _T2>
 588     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
 589     auto operator()(_T1&& __t, _T2&& __u) const
 590         noexcept(noexcept(_VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u)))
 591         -> decltype(      _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u))
 592         { return          _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u); }
 593     typedef void is_transparent;
 594 };
 595 #endif
 596
 597 _LIBCPP_END_NAMESPACE_STD
 598
 599 #endif // _LIBCPP___FUNCTIONAL_OPERATIONS_H