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 <__fwd/functional.h>
 17#include <__type_traits/desugars_to.h>
 18#include <__type_traits/is_integral.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
 30template <class _Tp = void>
 31#else
 32template <class _Tp>
 33#endif
 34struct plus : __binary_function<_Tp, _Tp, _Tp> {
 35  typedef _Tp __result_type; // used by valarray
 36  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const {
 37    return __x + __y;
 38  }
 39};
 40_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(plus);
 41
 42// The non-transparent std::plus specialization is only equivalent to a raw plus
 43// operator when we don't perform an implicit conversion when calling it.
 44template <class _Tp>
 45inline const bool __desugars_to_v<__plus_tag, plus<_Tp>, _Tp, _Tp> = true;
 46
 47template <class _Tp, class _Up>
 48inline const bool __desugars_to_v<__plus_tag, plus<void>, _Tp, _Up> = true;
 49
 50#if _LIBCPP_STD_VER >= 14
 51template <>
 52struct plus<void> {
 53  template <class _T1, class _T2>
 54  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
 55      noexcept(noexcept(std::forward<_T1>(__t) + std::forward<_T2>(__u))) //
 56      -> decltype(std::forward<_T1>(__t) + std::forward<_T2>(__u)) {
 57    return std::forward<_T1>(__t) + std::forward<_T2>(__u);
 58  }
 59  typedef void is_transparent;
 60};
 61#endif
 62
 63#if _LIBCPP_STD_VER >= 14
 64template <class _Tp = void>
 65#else
 66template <class _Tp>
 67#endif
 68struct minus : __binary_function<_Tp, _Tp, _Tp> {
 69  typedef _Tp __result_type; // used by valarray
 70  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const {
 71    return __x - __y;
 72  }
 73};
 74_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(minus);
 75
 76#if _LIBCPP_STD_VER >= 14
 77template <>
 78struct minus<void> {
 79  template <class _T1, class _T2>
 80  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
 81      noexcept(noexcept(std::forward<_T1>(__t) - std::forward<_T2>(__u))) //
 82      -> decltype(std::forward<_T1>(__t) - std::forward<_T2>(__u)) {
 83    return std::forward<_T1>(__t) - std::forward<_T2>(__u);
 84  }
 85  typedef void is_transparent;
 86};
 87#endif
 88
 89#if _LIBCPP_STD_VER >= 14
 90template <class _Tp = void>
 91#else
 92template <class _Tp>
 93#endif
 94struct multiplies : __binary_function<_Tp, _Tp, _Tp> {
 95  typedef _Tp __result_type; // used by valarray
 96  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const {
 97    return __x * __y;
 98  }
 99};
100_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(multiplies);
101
102#if _LIBCPP_STD_VER >= 14
103template <>
104struct multiplies<void> {
105  template <class _T1, class _T2>
106  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
107      noexcept(noexcept(std::forward<_T1>(__t) * std::forward<_T2>(__u))) //
108      -> decltype(std::forward<_T1>(__t) * std::forward<_T2>(__u)) {
109    return std::forward<_T1>(__t) * std::forward<_T2>(__u);
110  }
111  typedef void is_transparent;
112};
113#endif
114
115#if _LIBCPP_STD_VER >= 14
116template <class _Tp = void>
117#else
118template <class _Tp>
119#endif
120struct divides : __binary_function<_Tp, _Tp, _Tp> {
121  typedef _Tp __result_type; // used by valarray
122  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const {
123    return __x / __y;
124  }
125};
126_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(divides);
127
128#if _LIBCPP_STD_VER >= 14
129template <>
130struct divides<void> {
131  template <class _T1, class _T2>
132  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
133      noexcept(noexcept(std::forward<_T1>(__t) / std::forward<_T2>(__u))) //
134      -> decltype(std::forward<_T1>(__t) / std::forward<_T2>(__u)) {
135    return std::forward<_T1>(__t) / std::forward<_T2>(__u);
136  }
137  typedef void is_transparent;
138};
139#endif
140
141#if _LIBCPP_STD_VER >= 14
142template <class _Tp = void>
143#else
144template <class _Tp>
145#endif
146struct modulus : __binary_function<_Tp, _Tp, _Tp> {
147  typedef _Tp __result_type; // used by valarray
148  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const {
149    return __x % __y;
150  }
151};
152_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(modulus);
153
154#if _LIBCPP_STD_VER >= 14
155template <>
156struct modulus<void> {
157  template <class _T1, class _T2>
158  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
159      noexcept(noexcept(std::forward<_T1>(__t) % std::forward<_T2>(__u))) //
160      -> decltype(std::forward<_T1>(__t) % std::forward<_T2>(__u)) {
161    return std::forward<_T1>(__t) % std::forward<_T2>(__u);
162  }
163  typedef void is_transparent;
164};
165#endif
166
167#if _LIBCPP_STD_VER >= 14
168template <class _Tp = void>
169#else
170template <class _Tp>
171#endif
172struct negate : __unary_function<_Tp, _Tp> {
173  typedef _Tp __result_type; // used by valarray
174  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return -__x; }
175};
176_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(negate);
177
178#if _LIBCPP_STD_VER >= 14
179template <>
180struct negate<void> {
181  template <class _Tp>
182  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_Tp&& __x) const
183      noexcept(noexcept(-std::forward<_Tp>(__x))) //
184      -> decltype(-std::forward<_Tp>(__x)) {
185    return -std::forward<_Tp>(__x);
186  }
187  typedef void is_transparent;
188};
189#endif
190
191// Bitwise operations
192
193#if _LIBCPP_STD_VER >= 14
194template <class _Tp = void>
195#else
196template <class _Tp>
197#endif
198struct bit_and : __binary_function<_Tp, _Tp, _Tp> {
199  typedef _Tp __result_type; // used by valarray
200  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const {
201    return __x & __y;
202  }
203};
204_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_and);
205
206#if _LIBCPP_STD_VER >= 14
207template <>
208struct bit_and<void> {
209  template <class _T1, class _T2>
210  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
211      noexcept(noexcept(std::forward<_T1>(__t) &
212                        std::forward<_T2>(__u))) -> decltype(std::forward<_T1>(__t) & std::forward<_T2>(__u)) {
213    return std::forward<_T1>(__t) & std::forward<_T2>(__u);
214  }
215  typedef void is_transparent;
216};
217#endif
218
219#if _LIBCPP_STD_VER >= 14
220template <class _Tp = void>
221struct bit_not : __unary_function<_Tp, _Tp> {
222  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return ~__x; }
223};
224_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_not);
225
226template <>
227struct bit_not<void> {
228  template <class _Tp>
229  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_Tp&& __x) const
230      noexcept(noexcept(~std::forward<_Tp>(__x))) //
231      -> decltype(~std::forward<_Tp>(__x)) {
232    return ~std::forward<_Tp>(__x);
233  }
234  typedef void is_transparent;
235};
236#endif
237
238#if _LIBCPP_STD_VER >= 14
239template <class _Tp = void>
240#else
241template <class _Tp>
242#endif
243struct bit_or : __binary_function<_Tp, _Tp, _Tp> {
244  typedef _Tp __result_type; // used by valarray
245  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const {
246    return __x | __y;
247  }
248};
249_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_or);
250
251#if _LIBCPP_STD_VER >= 14
252template <>
253struct bit_or<void> {
254  template <class _T1, class _T2>
255  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
256      noexcept(noexcept(std::forward<_T1>(__t) | std::forward<_T2>(__u))) //
257      -> decltype(std::forward<_T1>(__t) | std::forward<_T2>(__u)) {
258    return std::forward<_T1>(__t) | std::forward<_T2>(__u);
259  }
260  typedef void is_transparent;
261};
262#endif
263
264#if _LIBCPP_STD_VER >= 14
265template <class _Tp = void>
266#else
267template <class _Tp>
268#endif
269struct bit_xor : __binary_function<_Tp, _Tp, _Tp> {
270  typedef _Tp __result_type; // used by valarray
271  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const {
272    return __x ^ __y;
273  }
274};
275_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_xor);
276
277#if _LIBCPP_STD_VER >= 14
278template <>
279struct bit_xor<void> {
280  template <class _T1, class _T2>
281  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
282      noexcept(noexcept(std::forward<_T1>(__t) ^ std::forward<_T2>(__u))) //
283      -> decltype(std::forward<_T1>(__t) ^ std::forward<_T2>(__u)) {
284    return std::forward<_T1>(__t) ^ std::forward<_T2>(__u);
285  }
286  typedef void is_transparent;
287};
288#endif
289
290// Comparison operations
291
292#if _LIBCPP_STD_VER >= 14
293template <class _Tp = void>
294#else
295template <class _Tp>
296#endif
297struct equal_to : __binary_function<_Tp, _Tp, bool> {
298  typedef bool __result_type; // used by valarray
299  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x, const _Tp& __y) const {
300    return __x == __y;
301  }
302};
303_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(equal_to);
304
305#if _LIBCPP_STD_VER >= 14
306template <>
307struct equal_to<void> {
308  template <class _T1, class _T2>
309  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
310      noexcept(noexcept(std::forward<_T1>(__t) == std::forward<_T2>(__u))) //
311      -> decltype(std::forward<_T1>(__t) == std::forward<_T2>(__u)) {
312    return std::forward<_T1>(__t) == std::forward<_T2>(__u);
313  }
314  typedef void is_transparent;
315};
316#endif
317
318// The non-transparent std::equal_to specialization is only equivalent to a raw equality
319// comparison when we don't perform an implicit conversion when calling it.
320template <class _Tp>
321inline const bool __desugars_to_v<__equal_tag, equal_to<_Tp>, _Tp, _Tp> = true;
322
323// In the transparent case, we do not enforce that
324template <class _Tp, class _Up>
325inline const bool __desugars_to_v<__equal_tag, equal_to<void>, _Tp, _Up> = true;
326
327#if _LIBCPP_STD_VER >= 14
328template <class _Tp = void>
329#else
330template <class _Tp>
331#endif
332struct not_equal_to : __binary_function<_Tp, _Tp, bool> {
333  typedef bool __result_type; // used by valarray
334  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x, const _Tp& __y) const {
335    return __x != __y;
336  }
337};
338_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(not_equal_to);
339
340#if _LIBCPP_STD_VER >= 14
341template <>
342struct not_equal_to<void> {
343  template <class _T1, class _T2>
344  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
345      noexcept(noexcept(std::forward<_T1>(__t) != std::forward<_T2>(__u))) //
346      -> decltype(std::forward<_T1>(__t) != std::forward<_T2>(__u)) {
347    return std::forward<_T1>(__t) != std::forward<_T2>(__u);
348  }
349  typedef void is_transparent;
350};
351#endif
352
353template <class _Tp>
354struct less : __binary_function<_Tp, _Tp, bool> {
355  typedef bool __result_type; // used by valarray
356  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x, const _Tp& __y) const {
357    return __x < __y;
358  }
359};
360_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(less);
361
362template <class _Tp>
363inline const bool __desugars_to_v<__less_tag, less<_Tp>, _Tp, _Tp> = true;
364
365template <class _Tp>
366inline const bool __desugars_to_v<__totally_ordered_less_tag, less<_Tp>, _Tp, _Tp> = is_integral<_Tp>::value;
367
368#if _LIBCPP_STD_VER >= 14
369template <>
370struct less<void> {
371  template <class _T1, class _T2>
372  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
373      noexcept(noexcept(std::forward<_T1>(__t) < std::forward<_T2>(__u))) //
374      -> decltype(std::forward<_T1>(__t) < std::forward<_T2>(__u)) {
375    return std::forward<_T1>(__t) < std::forward<_T2>(__u);
376  }
377  typedef void is_transparent;
378};
379
380template <class _Tp, class _Up>
381inline const bool __desugars_to_v<__less_tag, less<>, _Tp, _Up> = true;
382
383template <class _Tp>
384inline const bool __desugars_to_v<__totally_ordered_less_tag, less<>, _Tp, _Tp> = is_integral<_Tp>::value;
385#endif
386
387#if _LIBCPP_STD_VER >= 14
388template <class _Tp = void>
389#else
390template <class _Tp>
391#endif
392struct less_equal : __binary_function<_Tp, _Tp, bool> {
393  typedef bool __result_type; // used by valarray
394  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x, const _Tp& __y) const {
395    return __x <= __y;
396  }
397};
398_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(less_equal);
399
400#if _LIBCPP_STD_VER >= 14
401template <>
402struct less_equal<void> {
403  template <class _T1, class _T2>
404  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
405      noexcept(noexcept(std::forward<_T1>(__t) <= std::forward<_T2>(__u))) //
406      -> decltype(std::forward<_T1>(__t) <= std::forward<_T2>(__u)) {
407    return std::forward<_T1>(__t) <= std::forward<_T2>(__u);
408  }
409  typedef void is_transparent;
410};
411#endif
412
413#if _LIBCPP_STD_VER >= 14
414template <class _Tp = void>
415#else
416template <class _Tp>
417#endif
418struct greater_equal : __binary_function<_Tp, _Tp, bool> {
419  typedef bool __result_type; // used by valarray
420  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x, const _Tp& __y) const {
421    return __x >= __y;
422  }
423};
424_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(greater_equal);
425
426#if _LIBCPP_STD_VER >= 14
427template <>
428struct greater_equal<void> {
429  template <class _T1, class _T2>
430  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
431      noexcept(noexcept(std::forward<_T1>(__t) >=
432                        std::forward<_T2>(__u))) -> decltype(std::forward<_T1>(__t) >= std::forward<_T2>(__u)) {
433    return std::forward<_T1>(__t) >= std::forward<_T2>(__u);
434  }
435  typedef void is_transparent;
436};
437#endif
438
439#if _LIBCPP_STD_VER >= 14
440template <class _Tp = void>
441#else
442template <class _Tp>
443#endif
444struct greater : __binary_function<_Tp, _Tp, bool> {
445  typedef bool __result_type; // used by valarray
446  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x, const _Tp& __y) const {
447    return __x > __y;
448  }
449};
450_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(greater);
451
452template <class _Tp>
453inline const bool __desugars_to_v<__greater_tag, greater<_Tp>, _Tp, _Tp> = true;
454
455#if _LIBCPP_STD_VER >= 14
456template <>
457struct greater<void> {
458  template <class _T1, class _T2>
459  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
460      noexcept(noexcept(std::forward<_T1>(__t) > std::forward<_T2>(__u))) //
461      -> decltype(std::forward<_T1>(__t) > std::forward<_T2>(__u)) {
462    return std::forward<_T1>(__t) > std::forward<_T2>(__u);
463  }
464  typedef void is_transparent;
465};
466
467template <class _Tp, class _Up>
468inline const bool __desugars_to_v<__greater_tag, greater<>, _Tp, _Up> = true;
469#endif
470
471// Logical operations
472
473#if _LIBCPP_STD_VER >= 14
474template <class _Tp = void>
475#else
476template <class _Tp>
477#endif
478struct logical_and : __binary_function<_Tp, _Tp, bool> {
479  typedef bool __result_type; // used by valarray
480  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x, const _Tp& __y) const {
481    return __x && __y;
482  }
483};
484_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_and);
485
486#if _LIBCPP_STD_VER >= 14
487template <>
488struct logical_and<void> {
489  template <class _T1, class _T2>
490  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
491      noexcept(noexcept(std::forward<_T1>(__t) && std::forward<_T2>(__u))) //
492      -> decltype(std::forward<_T1>(__t) && std::forward<_T2>(__u)) {
493    return std::forward<_T1>(__t) && std::forward<_T2>(__u);
494  }
495  typedef void is_transparent;
496};
497#endif
498
499#if _LIBCPP_STD_VER >= 14
500template <class _Tp = void>
501#else
502template <class _Tp>
503#endif
504struct logical_not : __unary_function<_Tp, bool> {
505  typedef bool __result_type; // used by valarray
506  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x) const { return !__x; }
507};
508_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_not);
509
510#if _LIBCPP_STD_VER >= 14
511template <>
512struct logical_not<void> {
513  template <class _Tp>
514  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_Tp&& __x) const
515      noexcept(noexcept(!std::forward<_Tp>(__x))) //
516      -> decltype(!std::forward<_Tp>(__x)) {
517    return !std::forward<_Tp>(__x);
518  }
519  typedef void is_transparent;
520};
521#endif
522
523#if _LIBCPP_STD_VER >= 14
524template <class _Tp = void>
525#else
526template <class _Tp>
527#endif
528struct logical_or : __binary_function<_Tp, _Tp, bool> {
529  typedef bool __result_type; // used by valarray
530  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x, const _Tp& __y) const {
531    return __x || __y;
532  }
533};
534_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_or);
535
536#if _LIBCPP_STD_VER >= 14
537template <>
538struct logical_or<void> {
539  template <class _T1, class _T2>
540  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
541      noexcept(noexcept(std::forward<_T1>(__t) || std::forward<_T2>(__u))) //
542      -> decltype(std::forward<_T1>(__t) || std::forward<_T2>(__u)) {
543    return std::forward<_T1>(__t) || std::forward<_T2>(__u);
544  }
545  typedef void is_transparent;
546};
547#endif
548
549_LIBCPP_END_NAMESPACE_STD
550
551#endif // _LIBCPP___FUNCTIONAL_OPERATIONS_H