contrib/libc++/include/functional

   1 // -*- C++ -*-
   2 //===------------------------ functional ----------------------------------===//
   3 //
   4 //                     The LLVM Compiler Infrastructure
   5 //
   6 // This file is dual licensed under the MIT and the University of Illinois Open
   7 // Source Licenses. See LICENSE.TXT for details.
   8 //
   9 //===----------------------------------------------------------------------===//
  10
  11 #ifndef _LIBCPP_FUNCTIONAL
  12 #define _LIBCPP_FUNCTIONAL
  13
  14 /*
  15     functional synopsis
  16
  17 namespace std
  18 {
  19
  20 template <class Arg, class Result>
  21 struct unary_function
  22 {
  23     typedef Arg    argument_type;
  24     typedef Result result_type;
  25 };
  26
  27 template <class Arg1, class Arg2, class Result>
  28 struct binary_function
  29 {
  30     typedef Arg1   first_argument_type;
  31     typedef Arg2   second_argument_type;
  32     typedef Result result_type;
  33 };
  34
  35 template <class T>
  36 class reference_wrapper
  37     : public unary_function<T1, R> // if wrapping a unary functor
  38     : public binary_function<T1, T2, R> // if wraping a binary functor
  39 {
  40 public:
  41     // types
  42     typedef T type;
  43     typedef see below result_type; // Not always defined
  44
  45     // construct/copy/destroy
  46     reference_wrapper(T&) noexcept;
  47     reference_wrapper(T&&) = delete; // do not bind to temps
  48     reference_wrapper(const reference_wrapper<T>& x) noexcept;
  49
  50     // assignment
  51     reference_wrapper& operator=(const reference_wrapper<T>& x) noexcept;
  52
  53     // access
  54     operator T& () const noexcept;
  55     T& get() const noexcept;
  56
  57     // invoke
  58     template <class... ArgTypes>
  59       typename result_of<T(ArgTypes...)>::type
  60           operator() (ArgTypes&&...) const;
  61 };
  62
  63 template <class T> reference_wrapper<T> ref(T& t) noexcept;
  64 template <class T> void ref(const T&& t) = delete;
  65 template <class T> reference_wrapper<T> ref(reference_wrapper<T>t) noexcept;
  66
  67 template <class T> reference_wrapper<const T> cref(const T& t) noexcept;
  68 template <class T> void cref(const T&& t) = delete;
  69 template <class T> reference_wrapper<const T> cref(reference_wrapper<T> t) noexcept;
  70
  71 template <class T>
  72 struct plus : binary_function<T, T, T>
  73 {
  74     T operator()(const T& x, const T& y) const;
  75 };
  76
  77 template <class T>
  78 struct minus : binary_function<T, T, T>
  79 {
  80     T operator()(const T& x, const T& y) const;
  81 };
  82
  83 template <class T>
  84 struct multiplies : binary_function<T, T, T>
  85 {
  86     T operator()(const T& x, const T& y) const;
  87 };
  88
  89 template <class T>
  90 struct divides : binary_function<T, T, T>
  91 {
  92     T operator()(const T& x, const T& y) const;
  93 };
  94
  95 template <class T>
  96 struct modulus : binary_function<T, T, T>
  97 {
  98     T operator()(const T& x, const T& y) const;
  99 };
 100
 101 template <class T>
 102 struct negate : unary_function<T, T>
 103 {
 104     T operator()(const T& x) const;
 105 };
 106
 107 template <class T>
 108 struct equal_to : binary_function<T, T, bool>
 109 {
 110     bool operator()(const T& x, const T& y) const;
 111 };
 112
 113 template <class T>
 114 struct not_equal_to : binary_function<T, T, bool>
 115 {
 116     bool operator()(const T& x, const T& y) const;
 117 };
 118
 119 template <class T>
 120 struct greater : binary_function<T, T, bool>
 121 {
 122     bool operator()(const T& x, const T& y) const;
 123 };
 124
 125 template <class T>
 126 struct less : binary_function<T, T, bool>
 127 {
 128     bool operator()(const T& x, const T& y) const;
 129 };
 130
 131 template <class T>
 132 struct greater_equal : binary_function<T, T, bool>
 133 {
 134     bool operator()(const T& x, const T& y) const;
 135 };
 136
 137 template <class T>
 138 struct less_equal : binary_function<T, T, bool>
 139 {
 140     bool operator()(const T& x, const T& y) const;
 141 };
 142
 143 template <class T>
 144 struct logical_and : binary_function<T, T, bool>
 145 {
 146     bool operator()(const T& x, const T& y) const;
 147 };
 148
 149 template <class T>
 150 struct logical_or : binary_function<T, T, bool>
 151 {
 152     bool operator()(const T& x, const T& y) const;
 153 };
 154
 155 template <class T>
 156 struct logical_not : unary_function<T, bool>
 157 {
 158     bool operator()(const T& x) const;
 159 };
 160
 161 template <class Predicate>
 162 class unary_negate
 163     : public unary_function<typename Predicate::argument_type, bool>
 164 {
 165 public:
 166     explicit unary_negate(const Predicate& pred);
 167     bool operator()(const typename Predicate::argument_type& x) const;
 168 };
 169
 170 template <class Predicate> unary_negate<Predicate> not1(const Predicate& pred);
 171
 172 template <class Predicate>
 173 class binary_negate
 174     : public binary_function<typename Predicate::first_argument_type,
 175                              typename Predicate::second_argument_type,
 176                              bool>
 177 {
 178 public:
 179     explicit binary_negate(const Predicate& pred);
 180     bool operator()(const typename Predicate::first_argument_type& x,
 181                     const typename Predicate::second_argument_type& y) const;
 182 };
 183
 184 template <class Predicate> binary_negate<Predicate> not2(const Predicate& pred);
 185
 186 template<class T> struct is_bind_expression;
 187 template<class T> struct is_placeholder;
 188
 189 template<class Fn, class... BoundArgs>
 190   unspecified bind(Fn&&, BoundArgs&&...);
 191 template<class R, class Fn, class... BoundArgs>
 192   unspecified bind(Fn&&, BoundArgs&&...);
 193
 194 namespace placeholders {
 195   // M is the implementation-defined number of placeholders
 196   extern unspecified _1;
 197   extern unspecified _2;
 198   .
 199   .
 200   .
 201   extern unspecified _Mp;
 202 }
 203
 204 template <class Operation>
 205 class binder1st
 206     : public unary_function<typename Operation::second_argument_type,
 207                             typename Operation::result_type>
 208 {
 209 protected:
 210     Operation                               op;
 211     typename Operation::first_argument_type value;
 212 public:
 213     binder1st(const Operation& x, const typename Operation::first_argument_type y);
 214     typename Operation::result_type operator()(      typename Operation::second_argument_type& x) const;
 215     typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const;
 216 };
 217
 218 template <class Operation, class T>
 219 binder1st<Operation> bind1st(const Operation& op, const T& x);
 220
 221 template <class Operation>
 222 class binder2nd
 223     : public unary_function<typename Operation::first_argument_type,
 224                             typename Operation::result_type>
 225 {
 226 protected:
 227     Operation                                op;
 228     typename Operation::second_argument_type value;
 229 public:
 230     binder2nd(const Operation& x, const typename Operation::second_argument_type y);
 231     typename Operation::result_type operator()(      typename Operation::first_argument_type& x) const;
 232     typename Operation::result_type operator()(const typename Operation::first_argument_type& x) const;
 233 };
 234
 235 template <class Operation, class T>
 236 binder2nd<Operation> bind2nd(const Operation& op, const T& x);
 237
 238 template <class Arg, class Result>
 239 class pointer_to_unary_function : public unary_function<Arg, Result>
 240 {
 241 public:
 242     explicit pointer_to_unary_function(Result (*f)(Arg));
 243     Result operator()(Arg x) const;
 244 };
 245
 246 template <class Arg, class Result>
 247 pointer_to_unary_function<Arg,Result> ptr_fun(Result (*f)(Arg));
 248
 249 template <class Arg1, class Arg2, class Result>
 250 class pointer_to_binary_function : public binary_function<Arg1, Arg2, Result>
 251 {
 252 public:
 253     explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2));
 254     Result operator()(Arg1 x, Arg2 y) const;
 255 };
 256
 257 template <class Arg1, class Arg2, class Result>
 258 pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*f)(Arg1,Arg2));
 259
 260 template<class S, class T>
 261 class mem_fun_t : public unary_function<T*, S>
 262 {
 263 public:
 264     explicit mem_fun_t(S (T::*p)());
 265     S operator()(T* p) const;
 266 };
 267
 268 template<class S, class T, class A>
 269 class mem_fun1_t : public binary_function<T*, A, S>
 270 {
 271 public:
 272     explicit mem_fun1_t(S (T::*p)(A));
 273     S operator()(T* p, A x) const;
 274 };
 275
 276 template<class S, class T>          mem_fun_t<S,T>    mem_fun(S (T::*f)());
 277 template<class S, class T, class A> mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A));
 278
 279 template<class S, class T>
 280 class mem_fun_ref_t : public unary_function<T, S>
 281 {
 282 public:
 283     explicit mem_fun_ref_t(S (T::*p)());
 284     S operator()(T& p) const;
 285 };
 286
 287 template<class S, class T, class A>
 288 class mem_fun1_ref_t : public binary_function<T, A, S>
 289 {
 290 public:
 291     explicit mem_fun1_ref_t(S (T::*p)(A));
 292     S operator()(T& p, A x) const;
 293 };
 294
 295 template<class S, class T>          mem_fun_ref_t<S,T>    mem_fun_ref(S (T::*f)());
 296 template<class S, class T, class A> mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A));
 297
 298 template <class S, class T>
 299 class const_mem_fun_t : public unary_function<const T*, S>
 300 {
 301 public:
 302     explicit const_mem_fun_t(S (T::*p)() const);
 303     S operator()(const T* p) const;
 304 };
 305
 306 template <class S, class T, class A>
 307 class const_mem_fun1_t : public binary_function<const T*, A, S>
 308 {
 309 public:
 310     explicit const_mem_fun1_t(S (T::*p)(A) const);
 311     S operator()(const T* p, A x) const;
 312 };
 313
 314 template <class S, class T>          const_mem_fun_t<S,T>    mem_fun(S (T::*f)() const);
 315 template <class S, class T, class A> const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const);
 316
 317 template <class S, class T>
 318 class const_mem_fun_ref_t : public unary_function<T, S>
 319 {
 320 public:
 321     explicit const_mem_fun_ref_t(S (T::*p)() const);
 322     S operator()(const T& p) const;
 323 };
 324
 325 template <class S, class T, class A>
 326 class const_mem_fun1_ref_t : public binary_function<T, A, S>
 327 {
 328 public:
 329     explicit const_mem_fun1_ref_t(S (T::*p)(A) const);
 330     S operator()(const T& p, A x) const;
 331 };
 332
 333 template <class S, class T>          const_mem_fun_ref_t<S,T>    mem_fun_ref(S (T::*f)() const);
 334 template <class S, class T, class A> const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const);
 335
 336 template<class R, class T> unspecified mem_fn(R T::*);
 337 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...));
 338 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const);
 339 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) volatile);
 340 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const volatile);
 341 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) &);
 342 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const &);
 343 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) volatile &);
 344 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const volatile &);
 345 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) &&);
 346 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const &&);
 347 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) volatile &&);
 348 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const volatile &&);
 349
 350 class bad_function_call
 351     : public exception
 352 {
 353 };
 354
 355 template<class> class function; // undefined
 356
 357 template<class R, class... ArgTypes>
 358 class function<R(ArgTypes...)>
 359   : public unary_function<T1, R>      // iff sizeof...(ArgTypes) == 1 and
 360                                       // ArgTypes contains T1
 361   : public binary_function<T1, T2, R> // iff sizeof...(ArgTypes) == 2 and
 362                                       // ArgTypes contains T1 and T2
 363 {
 364 public:
 365     typedef R result_type;
 366
 367     // construct/copy/destroy:
 368     function() noexcept;
 369     function(nullptr_t) noexcept;
 370     function(const function&);
 371     function(function&&) noexcept;
 372     template<class F>
 373       function(F);
 374     template<Allocator Alloc>
 375       function(allocator_arg_t, const Alloc&) noexcept;
 376     template<Allocator Alloc>
 377       function(allocator_arg_t, const Alloc&, nullptr_t) noexcept;
 378     template<Allocator Alloc>
 379       function(allocator_arg_t, const Alloc&, const function&);
 380     template<Allocator Alloc>
 381       function(allocator_arg_t, const Alloc&, function&&);
 382     template<class F, Allocator Alloc>
 383       function(allocator_arg_t, const Alloc&, F);
 384
 385     function& operator=(const function&);
 386     function& operator=(function&&) noexcept;
 387     function& operator=(nullptr_t) noexcept;
 388     template<class F>
 389       function& operator=(F&&);
 390     template<class F>
 391       function& operator=(reference_wrapper<F>) noexcept;
 392
 393     ~function();
 394
 395     // function modifiers:
 396     void swap(function&) noexcept;
 397     template<class F, class Alloc>
 398       void assign(F&&, const Alloc&);
 399
 400     // function capacity:
 401     explicit operator bool() const noexcept;
 402
 403     // function invocation:
 404     R operator()(ArgTypes...) const;
 405
 406     // function target access:
 407     const std::type_info& target_type() const noexcept;
 408     template <typename T>       T* target() noexcept;
 409     template <typename T> const T* target() const noexcept;
 410 };
 411
 412 // Null pointer comparisons:
 413 template <class R, class ... ArgTypes>
 414   bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
 415
 416 template <class R, class ... ArgTypes>
 417   bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
 418
 419 template <class R, class ... ArgTypes>
 420   bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
 421
 422 template <class  R, class ... ArgTypes>
 423   bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
 424
 425 // specialized algorithms:
 426 template <class  R, class ... ArgTypes>
 427   void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;
 428
 429 template <class T> struct hash;
 430
 431 template <> struct hash<bool>;
 432 template <> struct hash<char>;
 433 template <> struct hash<signed char>;
 434 template <> struct hash<unsigned char>;
 435 template <> struct hash<char16_t>;
 436 template <> struct hash<char32_t>;
 437 template <> struct hash<wchar_t>;
 438 template <> struct hash<short>;
 439 template <> struct hash<unsigned short>;
 440 template <> struct hash<int>;
 441 template <> struct hash<unsigned int>;
 442 template <> struct hash<long>;
 443 template <> struct hash<long long>;
 444 template <> struct hash<unsigned long>;
 445 template <> struct hash<unsigned long long>;
 446
 447 template <> struct hash<float>;
 448 template <> struct hash<double>;
 449 template <> struct hash<long double>;
 450
 451 template<class T> struct hash<T*>;
 452
 453 }  // std
 454
 455 POLICY:  For non-variadic implementations, the number of arguments is limited
 456          to 3.  It is hoped that the need for non-variadic implementations
 457          will be minimal.
 458
 459 */
 460
 461 #include <__config>
 462 #include <type_traits>
 463 #include <typeinfo>
 464 #include <exception>
 465 #include <memory>
 466 #include <tuple>
 467
 468 #include <__functional_base>
 469
 470 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 471 #pragma GCC system_header
 472 #endif
 473
 474 _LIBCPP_BEGIN_NAMESPACE_STD
 475
 476 template <class _Tp>
 477 struct _LIBCPP_TYPE_VIS plus : binary_function<_Tp, _Tp, _Tp>
 478 {
 479     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 480         {return __x + __y;}
 481 };
 482
 483 template <class _Tp>
 484 struct _LIBCPP_TYPE_VIS minus : binary_function<_Tp, _Tp, _Tp>
 485 {
 486     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 487         {return __x - __y;}
 488 };
 489
 490 template <class _Tp>
 491 struct _LIBCPP_TYPE_VIS multiplies : binary_function<_Tp, _Tp, _Tp>
 492 {
 493     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 494         {return __x * __y;}
 495 };
 496
 497 template <class _Tp>
 498 struct _LIBCPP_TYPE_VIS divides : binary_function<_Tp, _Tp, _Tp>
 499 {
 500     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 501         {return __x / __y;}
 502 };
 503
 504 template <class _Tp>
 505 struct _LIBCPP_TYPE_VIS modulus : binary_function<_Tp, _Tp, _Tp>
 506 {
 507     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 508         {return __x % __y;}
 509 };
 510
 511 template <class _Tp>
 512 struct _LIBCPP_TYPE_VIS negate : unary_function<_Tp, _Tp>
 513 {
 514     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const
 515         {return -__x;}
 516 };
 517
 518 template <class _Tp>
 519 struct _LIBCPP_TYPE_VIS equal_to : binary_function<_Tp, _Tp, bool>
 520 {
 521     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
 522         {return __x == __y;}
 523 };
 524
 525 template <class _Tp>
 526 struct _LIBCPP_TYPE_VIS not_equal_to : binary_function<_Tp, _Tp, bool>
 527 {
 528     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
 529         {return __x != __y;}
 530 };
 531
 532 template <class _Tp>
 533 struct _LIBCPP_TYPE_VIS greater : binary_function<_Tp, _Tp, bool>
 534 {
 535     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
 536         {return __x > __y;}
 537 };
 538
 539 // less in <__functional_base>
 540
 541 template <class _Tp>
 542 struct _LIBCPP_TYPE_VIS greater_equal : binary_function<_Tp, _Tp, bool>
 543 {
 544     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
 545         {return __x >= __y;}
 546 };
 547
 548 template <class _Tp>
 549 struct _LIBCPP_TYPE_VIS less_equal : binary_function<_Tp, _Tp, bool>
 550 {
 551     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
 552         {return __x <= __y;}
 553 };
 554
 555 template <class _Tp>
 556 struct _LIBCPP_TYPE_VIS logical_and : binary_function<_Tp, _Tp, bool>
 557 {
 558     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
 559         {return __x && __y;}
 560 };
 561
 562 template <class _Tp>
 563 struct _LIBCPP_TYPE_VIS logical_or : binary_function<_Tp, _Tp, bool>
 564 {
 565     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
 566         {return __x || __y;}
 567 };
 568
 569 template <class _Tp>
 570 struct _LIBCPP_TYPE_VIS logical_not : unary_function<_Tp, bool>
 571 {
 572     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x) const
 573         {return !__x;}
 574 };
 575
 576 template <class _Tp>
 577 struct _LIBCPP_TYPE_VIS bit_and : binary_function<_Tp, _Tp, _Tp>
 578 {
 579     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 580         {return __x & __y;}
 581 };
 582
 583 template <class _Tp>
 584 struct _LIBCPP_TYPE_VIS bit_or : binary_function<_Tp, _Tp, _Tp>
 585 {
 586     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 587         {return __x | __y;}
 588 };
 589
 590 template <class _Tp>
 591 struct _LIBCPP_TYPE_VIS bit_xor : binary_function<_Tp, _Tp, _Tp>
 592 {
 593     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 594         {return __x ^ __y;}
 595 };
 596
 597 template <class _Predicate>
 598 class _LIBCPP_TYPE_VIS unary_negate
 599     : public unary_function<typename _Predicate::argument_type, bool>
 600 {
 601     _Predicate __pred_;
 602 public:
 603     _LIBCPP_INLINE_VISIBILITY explicit unary_negate(const _Predicate& __pred)
 604         : __pred_(__pred) {}
 605     _LIBCPP_INLINE_VISIBILITY bool operator()(const typename _Predicate::argument_type& __x) const
 606         {return !__pred_(__x);}
 607 };
 608
 609 template <class _Predicate>
 610 inline _LIBCPP_INLINE_VISIBILITY
 611 unary_negate<_Predicate>
 612 not1(const _Predicate& __pred) {return unary_negate<_Predicate>(__pred);}
 613
 614 template <class _Predicate>
 615 class _LIBCPP_TYPE_VIS binary_negate
 616     : public binary_function<typename _Predicate::first_argument_type,
 617                              typename _Predicate::second_argument_type,
 618                              bool>
 619 {
 620     _Predicate __pred_;
 621 public:
 622     _LIBCPP_INLINE_VISIBILITY explicit binary_negate(const _Predicate& __pred)
 623         : __pred_(__pred) {}
 624     _LIBCPP_INLINE_VISIBILITY bool operator()(const typename _Predicate::first_argument_type& __x,
 625                     const typename _Predicate::second_argument_type& __y) const
 626         {return !__pred_(__x, __y);}
 627 };
 628
 629 template <class _Predicate>
 630 inline _LIBCPP_INLINE_VISIBILITY
 631 binary_negate<_Predicate>
 632 not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);}
 633
 634 template <class __Operation>
 635 class _LIBCPP_TYPE_VIS binder1st
 636     : public unary_function<typename __Operation::second_argument_type,
 637                             typename __Operation::result_type>
 638 {
 639 protected:
 640     __Operation                               op;
 641     typename __Operation::first_argument_type value;
 642 public:
 643     _LIBCPP_INLINE_VISIBILITY binder1st(const __Operation& __x,
 644                                const typename __Operation::first_argument_type __y)
 645         : op(__x), value(__y) {}
 646     _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
 647         (typename __Operation::second_argument_type& __x) const
 648             {return op(value, __x);}
 649     _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
 650         (const typename __Operation::second_argument_type& __x) const
 651             {return op(value, __x);}
 652 };
 653
 654 template <class __Operation, class _Tp>
 655 inline _LIBCPP_INLINE_VISIBILITY
 656 binder1st<__Operation>
 657 bind1st(const __Operation& __op, const _Tp& __x)
 658     {return binder1st<__Operation>(__op, __x);}
 659
 660 template <class __Operation>
 661 class _LIBCPP_TYPE_VIS binder2nd
 662     : public unary_function<typename __Operation::first_argument_type,
 663                             typename __Operation::result_type>
 664 {
 665 protected:
 666     __Operation                                op;
 667     typename __Operation::second_argument_type value;
 668 public:
 669     _LIBCPP_INLINE_VISIBILITY
 670     binder2nd(const __Operation& __x, const typename __Operation::second_argument_type __y)
 671         : op(__x), value(__y) {}
 672     _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
 673         (      typename __Operation::first_argument_type& __x) const
 674             {return op(__x, value);}
 675     _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
 676         (const typename __Operation::first_argument_type& __x) const
 677             {return op(__x, value);}
 678 };
 679
 680 template <class __Operation, class _Tp>
 681 inline _LIBCPP_INLINE_VISIBILITY
 682 binder2nd<__Operation>
 683 bind2nd(const __Operation& __op, const _Tp& __x)
 684     {return binder2nd<__Operation>(__op, __x);}
 685
 686 template <class _Arg, class _Result>
 687 class _LIBCPP_TYPE_VIS pointer_to_unary_function
 688     : public unary_function<_Arg, _Result>
 689 {
 690     _Result (*__f_)(_Arg);
 691 public:
 692     _LIBCPP_INLINE_VISIBILITY explicit pointer_to_unary_function(_Result (*__f)(_Arg))
 693         : __f_(__f) {}
 694     _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg __x) const
 695         {return __f_(__x);}
 696 };
 697
 698 template <class _Arg, class _Result>
 699 inline _LIBCPP_INLINE_VISIBILITY
 700 pointer_to_unary_function<_Arg,_Result>
 701 ptr_fun(_Result (*__f)(_Arg))
 702     {return pointer_to_unary_function<_Arg,_Result>(__f);}
 703
 704 template <class _Arg1, class _Arg2, class _Result>
 705 class _LIBCPP_TYPE_VIS pointer_to_binary_function
 706     : public binary_function<_Arg1, _Arg2, _Result>
 707 {
 708     _Result (*__f_)(_Arg1, _Arg2);
 709 public:
 710     _LIBCPP_INLINE_VISIBILITY explicit pointer_to_binary_function(_Result (*__f)(_Arg1, _Arg2))
 711         : __f_(__f) {}
 712     _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg1 __x, _Arg2 __y) const
 713         {return __f_(__x, __y);}
 714 };
 715
 716 template <class _Arg1, class _Arg2, class _Result>
 717 inline _LIBCPP_INLINE_VISIBILITY
 718 pointer_to_binary_function<_Arg1,_Arg2,_Result>
 719 ptr_fun(_Result (*__f)(_Arg1,_Arg2))
 720     {return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__f);}
 721
 722 template<class _Sp, class _Tp>
 723 class _LIBCPP_TYPE_VIS mem_fun_t : public unary_function<_Tp*, _Sp>
 724 {
 725     _Sp (_Tp::*__p_)();
 726 public:
 727     _LIBCPP_INLINE_VISIBILITY explicit mem_fun_t(_Sp (_Tp::*__p)())
 728         : __p_(__p) {}
 729     _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p) const
 730         {return (__p->*__p_)();}
 731 };
 732
 733 template<class _Sp, class _Tp, class _Ap>
 734 class _LIBCPP_TYPE_VIS mem_fun1_t : public binary_function<_Tp*, _Ap, _Sp>
 735 {
 736     _Sp (_Tp::*__p_)(_Ap);
 737 public:
 738     _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_t(_Sp (_Tp::*__p)(_Ap))
 739         : __p_(__p) {}
 740     _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p, _Ap __x) const
 741         {return (__p->*__p_)(__x);}
 742 };
 743
 744 template<class _Sp, class _Tp>
 745 inline _LIBCPP_INLINE_VISIBILITY
 746 mem_fun_t<_Sp,_Tp>
 747 mem_fun(_Sp (_Tp::*__f)())
 748     {return mem_fun_t<_Sp,_Tp>(__f);}
 749
 750 template<class _Sp, class _Tp, class _Ap>
 751 inline _LIBCPP_INLINE_VISIBILITY
 752 mem_fun1_t<_Sp,_Tp,_Ap>
 753 mem_fun(_Sp (_Tp::*__f)(_Ap))
 754     {return mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
 755
 756 template<class _Sp, class _Tp>
 757 class _LIBCPP_TYPE_VIS mem_fun_ref_t : public unary_function<_Tp, _Sp>
 758 {
 759     _Sp (_Tp::*__p_)();
 760 public:
 761     _LIBCPP_INLINE_VISIBILITY explicit mem_fun_ref_t(_Sp (_Tp::*__p)())
 762         : __p_(__p) {}
 763     _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p) const
 764         {return (__p.*__p_)();}
 765 };
 766
 767 template<class _Sp, class _Tp, class _Ap>
 768 class _LIBCPP_TYPE_VIS mem_fun1_ref_t : public binary_function<_Tp, _Ap, _Sp>
 769 {
 770     _Sp (_Tp::*__p_)(_Ap);
 771 public:
 772     _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap))
 773         : __p_(__p) {}
 774     _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p, _Ap __x) const
 775         {return (__p.*__p_)(__x);}
 776 };
 777
 778 template<class _Sp, class _Tp>
 779 inline _LIBCPP_INLINE_VISIBILITY
 780 mem_fun_ref_t<_Sp,_Tp>
 781 mem_fun_ref(_Sp (_Tp::*__f)())
 782     {return mem_fun_ref_t<_Sp,_Tp>(__f);}
 783
 784 template<class _Sp, class _Tp, class _Ap>
 785 inline _LIBCPP_INLINE_VISIBILITY
 786 mem_fun1_ref_t<_Sp,_Tp,_Ap>
 787 mem_fun_ref(_Sp (_Tp::*__f)(_Ap))
 788     {return mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}
 789
 790 template <class _Sp, class _Tp>
 791 class _LIBCPP_TYPE_VIS const_mem_fun_t : public unary_function<const _Tp*, _Sp>
 792 {
 793     _Sp (_Tp::*__p_)() const;
 794 public:
 795     _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_t(_Sp (_Tp::*__p)() const)
 796         : __p_(__p) {}
 797     _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p) const
 798         {return (__p->*__p_)();}
 799 };
 800
 801 template <class _Sp, class _Tp, class _Ap>
 802 class _LIBCPP_TYPE_VIS const_mem_fun1_t : public binary_function<const _Tp*, _Ap, _Sp>
 803 {
 804     _Sp (_Tp::*__p_)(_Ap) const;
 805 public:
 806     _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_t(_Sp (_Tp::*__p)(_Ap) const)
 807         : __p_(__p) {}
 808     _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p, _Ap __x) const
 809         {return (__p->*__p_)(__x);}
 810 };
 811
 812 template <class _Sp, class _Tp>
 813 inline _LIBCPP_INLINE_VISIBILITY
 814 const_mem_fun_t<_Sp,_Tp>
 815 mem_fun(_Sp (_Tp::*__f)() const)
 816     {return const_mem_fun_t<_Sp,_Tp>(__f);}
 817
 818 template <class _Sp, class _Tp, class _Ap>
 819 inline _LIBCPP_INLINE_VISIBILITY
 820 const_mem_fun1_t<_Sp,_Tp,_Ap>
 821 mem_fun(_Sp (_Tp::*__f)(_Ap) const)
 822     {return const_mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
 823
 824 template <class _Sp, class _Tp>
 825 class _LIBCPP_TYPE_VIS const_mem_fun_ref_t : public unary_function<_Tp, _Sp>
 826 {
 827     _Sp (_Tp::*__p_)() const;
 828 public:
 829     _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_ref_t(_Sp (_Tp::*__p)() const)
 830         : __p_(__p) {}
 831     _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p) const
 832         {return (__p.*__p_)();}
 833 };
 834
 835 template <class _Sp, class _Tp, class _Ap>
 836 class _LIBCPP_TYPE_VIS const_mem_fun1_ref_t
 837     : public binary_function<_Tp, _Ap, _Sp>
 838 {
 839     _Sp (_Tp::*__p_)(_Ap) const;
 840 public:
 841     _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap) const)
 842         : __p_(__p) {}
 843     _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p, _Ap __x) const
 844         {return (__p.*__p_)(__x);}
 845 };
 846
 847 template <class _Sp, class _Tp>
 848 inline _LIBCPP_INLINE_VISIBILITY
 849 const_mem_fun_ref_t<_Sp,_Tp>
 850 mem_fun_ref(_Sp (_Tp::*__f)() const)
 851     {return const_mem_fun_ref_t<_Sp,_Tp>(__f);}
 852
 853 template <class _Sp, class _Tp, class _Ap>
 854 inline _LIBCPP_INLINE_VISIBILITY
 855 const_mem_fun1_ref_t<_Sp,_Tp,_Ap>
 856 mem_fun_ref(_Sp (_Tp::*__f)(_Ap) const)
 857     {return const_mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}
 858
 859 #ifdef _LIBCPP_HAS_NO_VARIADICS
 860
 861 #include <__functional_03>
 862
 863 #else  // _LIBCPP_HAS_NO_VARIADICS
 864
 865 template <class _Tp>
 866 class __mem_fn
 867     : public __weak_result_type<_Tp>
 868 {
 869 public:
 870     // types
 871     typedef _Tp type;
 872 private:
 873     type __f_;
 874
 875 public:
 876     _LIBCPP_INLINE_VISIBILITY __mem_fn(type __f) : __f_(__f) {}
 877
 878     // invoke
 879     template <class... _ArgTypes>
 880        _LIBCPP_INLINE_VISIBILITY
 881        typename __invoke_return<type, _ArgTypes...>::type
 882           operator() (_ArgTypes&&... __args)
 883           {
 884               return __invoke(__f_, _VSTD::forward<_ArgTypes>(__args)...);
 885           }
 886 };
 887
 888 template<class _Rp, class _Tp>
 889 inline _LIBCPP_INLINE_VISIBILITY
 890 __mem_fn<_Rp _Tp::*>
 891 mem_fn(_Rp _Tp::* __pm)
 892 {
 893     return __mem_fn<_Rp _Tp::*>(__pm);
 894 }
 895
 896 template<class _Rp, class _Tp, class ..._Args>
 897 inline _LIBCPP_INLINE_VISIBILITY
 898 __mem_fn<_Rp (_Tp::*)(_Args...)>
 899 mem_fn(_Rp (_Tp::* __pm)(_Args...))
 900 {
 901     return __mem_fn<_Rp (_Tp::*)(_Args...)>(__pm);
 902 }
 903
 904 template<class _Rp, class _Tp, class ..._Args>
 905 inline _LIBCPP_INLINE_VISIBILITY
 906 __mem_fn<_Rp (_Tp::*)(_Args...) const>
 907 mem_fn(_Rp (_Tp::* __pm)(_Args...) const)
 908 {
 909     return __mem_fn<_Rp (_Tp::*)(_Args...) const>(__pm);
 910 }
 911
 912 template<class _Rp, class _Tp, class ..._Args>
 913 inline _LIBCPP_INLINE_VISIBILITY
 914 __mem_fn<_Rp (_Tp::*)(_Args...) volatile>
 915 mem_fn(_Rp (_Tp::* __pm)(_Args...) volatile)
 916 {
 917     return __mem_fn<_Rp (_Tp::*)(_Args...) volatile>(__pm);
 918 }
 919
 920 template<class _Rp, class _Tp, class ..._Args>
 921 inline _LIBCPP_INLINE_VISIBILITY
 922 __mem_fn<_Rp (_Tp::*)(_Args...) const volatile>
 923 mem_fn(_Rp (_Tp::* __pm)(_Args...) const volatile)
 924 {
 925     return __mem_fn<_Rp (_Tp::*)(_Args...) const volatile>(__pm);
 926 }
 927
 928 // bad_function_call
 929
 930 class _LIBCPP_EXCEPTION_ABI bad_function_call
 931     : public exception
 932 {
 933 };
 934
 935 template<class _Fp> class _LIBCPP_TYPE_VIS function; // undefined
 936
 937 namespace __function
 938 {
 939
 940 template<class _Rp, class ..._ArgTypes>
 941 struct __maybe_derive_from_unary_function
 942 {
 943 };
 944
 945 template<class _Rp, class _A1>
 946 struct __maybe_derive_from_unary_function<_Rp(_A1)>
 947     : public unary_function<_A1, _Rp>
 948 {
 949 };
 950
 951 template<class _Rp, class ..._ArgTypes>
 952 struct __maybe_derive_from_binary_function
 953 {
 954 };
 955
 956 template<class _Rp, class _A1, class _A2>
 957 struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)>
 958     : public binary_function<_A1, _A2, _Rp>
 959 {
 960 };
 961
 962 template<class _Fp> class __base;
 963
 964 template<class _Rp, class ..._ArgTypes>
 965 class __base<_Rp(_ArgTypes...)>
 966 {
 967     __base(const __base&);
 968     __base& operator=(const __base&);
 969 public:
 970     _LIBCPP_INLINE_VISIBILITY __base() {}
 971     _LIBCPP_INLINE_VISIBILITY virtual ~__base() {}
 972     virtual __base* __clone() const = 0;
 973     virtual void __clone(__base*) const = 0;
 974     virtual void destroy() _NOEXCEPT = 0;
 975     virtual void destroy_deallocate() _NOEXCEPT = 0;
 976     virtual _Rp operator()(_ArgTypes&& ...) = 0;
 977 #ifndef _LIBCPP_NO_RTTI
 978     virtual const void* target(const type_info&) const _NOEXCEPT = 0;
 979     virtual const std::type_info& target_type() const _NOEXCEPT = 0;
 980 #endif  // _LIBCPP_NO_RTTI
 981 };
 982
 983 template<class _FD, class _Alloc, class _FB> class __func;
 984
 985 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
 986 class __func<_Fp, _Alloc, _Rp(_ArgTypes...)>
 987     : public  __base<_Rp(_ArgTypes...)>
 988 {
 989     __compressed_pair<_Fp, _Alloc> __f_;
 990 public:
 991     _LIBCPP_INLINE_VISIBILITY
 992     explicit __func(_Fp&& __f)
 993         : __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)),
 994                                     _VSTD::forward_as_tuple()) {}
 995     _LIBCPP_INLINE_VISIBILITY
 996     explicit __func(const _Fp& __f, const _Alloc& __a)
 997         : __f_(piecewise_construct, _VSTD::forward_as_tuple(__f),
 998                                     _VSTD::forward_as_tuple(__a)) {}
 999
1000     _LIBCPP_INLINE_VISIBILITY
1001     explicit __func(const _Fp& __f, _Alloc&& __a)
1002         : __f_(piecewise_construct, _VSTD::forward_as_tuple(__f),
1003                                     _VSTD::forward_as_tuple(_VSTD::move(__a))) {}
1004
1005     _LIBCPP_INLINE_VISIBILITY
1006     explicit __func(_Fp&& __f, _Alloc&& __a)
1007         : __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)),
1008                                     _VSTD::forward_as_tuple(_VSTD::move(__a))) {}
1009     virtual __base<_Rp(_ArgTypes...)>* __clone() const;
1010     virtual void __clone(__base<_Rp(_ArgTypes...)>*) const;
1011     virtual void destroy() _NOEXCEPT;
1012     virtual void destroy_deallocate() _NOEXCEPT;
1013     virtual _Rp operator()(_ArgTypes&& ... __arg);
1014 #ifndef _LIBCPP_NO_RTTI
1015     virtual const void* target(const type_info&) const _NOEXCEPT;
1016     virtual const std::type_info& target_type() const _NOEXCEPT;
1017 #endif  // _LIBCPP_NO_RTTI
1018 };
1019
1020 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1021 __base<_Rp(_ArgTypes...)>*
1022 __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone() const
1023 {
1024     typedef typename _Alloc::template rebind<__func>::other _Ap;
1025     _Ap __a(__f_.second());
1026     typedef __allocator_destructor<_Ap> _Dp;
1027     unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
1028     ::new (__hold.get()) __func(__f_.first(), _Alloc(__a));
1029     return __hold.release();
1030 }
1031
1032 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1033 void
1034 __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone(__base<_Rp(_ArgTypes...)>* __p) const
1035 {
1036     ::new (__p) __func(__f_.first(), __f_.second());
1037 }
1038
1039 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1040 void
1041 __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy() _NOEXCEPT
1042 {
1043     __f_.~__compressed_pair<_Fp, _Alloc>();
1044 }
1045
1046 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1047 void
1048 __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() _NOEXCEPT
1049 {
1050     typedef typename _Alloc::template rebind<__func>::other _Ap;
1051     _Ap __a(__f_.second());
1052     __f_.~__compressed_pair<_Fp, _Alloc>();
1053     __a.deallocate(this, 1);
1054 }
1055
1056 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1057 _Rp
1058 __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
1059 {
1060     return __invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...);
1061 }
1062
1063 #ifndef _LIBCPP_NO_RTTI
1064
1065 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1066 const void*
1067 __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target(const type_info& __ti) const _NOEXCEPT
1068 {
1069     if (__ti == typeid(_Fp))
1070         return &__f_.first();
1071     return (const void*)0;
1072 }
1073
1074 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1075 const std::type_info&
1076 __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target_type() const _NOEXCEPT
1077 {
1078     return typeid(_Fp);
1079 }
1080
1081 #endif  // _LIBCPP_NO_RTTI
1082
1083 }  // __function
1084
1085 template<class _Rp, class ..._ArgTypes>
1086 class _LIBCPP_TYPE_VIS function<_Rp(_ArgTypes...)>
1087     : public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>,
1088       public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)>
1089 {
1090     typedef __function::__base<_Rp(_ArgTypes...)> __base;
1091     typename aligned_storage<3*sizeof(void*)>::type __buf_;
1092     __base* __f_;
1093
1094     template <class _Fp>
1095         _LIBCPP_INLINE_VISIBILITY
1096         static bool __not_null(const _Fp&) {return true;}
1097     template <class _R2, class ..._Ap>
1098         _LIBCPP_INLINE_VISIBILITY
1099         static bool __not_null(_R2 (*__p)(_Ap...)) {return __p;}
1100     template <class _R2, class _Cp, class ..._Ap>
1101         _LIBCPP_INLINE_VISIBILITY
1102         static bool __not_null(_R2 (_Cp::*__p)(_Ap...)) {return __p;}
1103     template <class _R2, class _Cp, class ..._Ap>
1104         _LIBCPP_INLINE_VISIBILITY
1105         static bool __not_null(_R2 (_Cp::*__p)(_Ap...) const) {return __p;}
1106     template <class _R2, class _Cp, class ..._Ap>
1107         _LIBCPP_INLINE_VISIBILITY
1108         static bool __not_null(_R2 (_Cp::*__p)(_Ap...) volatile) {return __p;}
1109     template <class _R2, class _Cp, class ..._Ap>
1110         _LIBCPP_INLINE_VISIBILITY
1111         static bool __not_null(_R2 (_Cp::*__p)(_Ap...) const volatile) {return __p;}
1112     template <class _R2, class ..._Ap>
1113         _LIBCPP_INLINE_VISIBILITY
1114         static bool __not_null(const function<_Rp(_Ap...)>& __p) {return __p;}
1115
1116     template <class _Fp, bool = !is_same<_Fp, function>::value &&
1117                                 __invokable<_Fp&, _ArgTypes...>::value>
1118         struct __callable;
1119     template <class _Fp>
1120         struct __callable<_Fp, true>
1121         {
1122             static const bool value =
1123                 is_convertible<typename __invoke_of<_Fp&, _ArgTypes...>::type,
1124                                _Rp>::value;
1125         };
1126     template <class _Fp>
1127         struct __callable<_Fp, false>
1128         {
1129             static const bool value = false;
1130         };
1131 public:
1132     typedef _Rp result_type;
1133
1134     // construct/copy/destroy:
1135     _LIBCPP_INLINE_VISIBILITY
1136     function() _NOEXCEPT : __f_(0) {}
1137     _LIBCPP_INLINE_VISIBILITY
1138     function(nullptr_t) _NOEXCEPT : __f_(0) {}
1139     function(const function&);
1140     function(function&&) _NOEXCEPT;
1141     template<class _Fp>
1142       function(_Fp, typename enable_if
1143                                      <
1144                                         __callable<_Fp>::value &&
1145                                         !is_same<_Fp, function>::value
1146                                       >::type* = 0);
1147
1148     template<class _Alloc>
1149       _LIBCPP_INLINE_VISIBILITY
1150       function(allocator_arg_t, const _Alloc&) _NOEXCEPT : __f_(0) {}
1151     template<class _Alloc>
1152       _LIBCPP_INLINE_VISIBILITY
1153       function(allocator_arg_t, const _Alloc&, nullptr_t) _NOEXCEPT : __f_(0) {}
1154     template<class _Alloc>
1155       function(allocator_arg_t, const _Alloc&, const function&);
1156     template<class _Alloc>
1157       function(allocator_arg_t, const _Alloc&, function&&);
1158     template<class _Fp, class _Alloc>
1159       function(allocator_arg_t, const _Alloc& __a, _Fp __f,
1160                typename enable_if<__callable<_Fp>::value>::type* = 0);
1161
1162     function& operator=(const function&);
1163     function& operator=(function&&) _NOEXCEPT;
1164     function& operator=(nullptr_t) _NOEXCEPT;
1165     template<class _Fp>
1166       typename enable_if
1167       <
1168         __callable<typename decay<_Fp>::type>::value &&
1169         !is_same<typename remove_reference<_Fp>::type, function>::value,
1170         function&
1171       >::type
1172       operator=(_Fp&&);
1173
1174     ~function();
1175
1176     // function modifiers:
1177     void swap(function&) _NOEXCEPT;
1178     template<class _Fp, class _Alloc>
1179       _LIBCPP_INLINE_VISIBILITY
1180       void assign(_Fp&& __f, const _Alloc& __a)
1181         {function(allocator_arg, __a, _VSTD::forward<_Fp>(__f)).swap(*this);}
1182
1183     // function capacity:
1184     _LIBCPP_INLINE_VISIBILITY
1185         _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {return __f_;}
1186
1187     // deleted overloads close possible hole in the type system
1188     template<class _R2, class... _ArgTypes2>
1189       bool operator==(const function<_R2(_ArgTypes2...)>&) const = delete;
1190     template<class _R2, class... _ArgTypes2>
1191       bool operator!=(const function<_R2(_ArgTypes2...)>&) const = delete;
1192 public:
1193     // function invocation:
1194     _Rp operator()(_ArgTypes...) const;
1195
1196 #ifndef _LIBCPP_NO_RTTI
1197     // function target access:
1198     const std::type_info& target_type() const _NOEXCEPT;
1199     template <typename _Tp> _Tp* target() _NOEXCEPT;
1200     template <typename _Tp> const _Tp* target() const _NOEXCEPT;
1201 #endif  // _LIBCPP_NO_RTTI
1202 };
1203
1204 template<class _Rp, class ..._ArgTypes>
1205 function<_Rp(_ArgTypes...)>::function(const function& __f)
1206 {
1207     if (__f.__f_ == 0)
1208         __f_ = 0;
1209     else if (__f.__f_ == (const __base*)&__f.__buf_)
1210     {
1211         __f_ = (__base*)&__buf_;
1212         __f.__f_->__clone(__f_);
1213     }
1214     else
1215         __f_ = __f.__f_->__clone();
1216 }
1217
1218 template<class _Rp, class ..._ArgTypes>
1219 template <class _Alloc>
1220 function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
1221                                      const function& __f)
1222 {
1223     if (__f.__f_ == 0)
1224         __f_ = 0;
1225     else if (__f.__f_ == (const __base*)&__f.__buf_)
1226     {
1227         __f_ = (__base*)&__buf_;
1228         __f.__f_->__clone(__f_);
1229     }
1230     else
1231         __f_ = __f.__f_->__clone();
1232 }
1233
1234 template<class _Rp, class ..._ArgTypes>
1235 function<_Rp(_ArgTypes...)>::function(function&& __f) _NOEXCEPT
1236 {
1237     if (__f.__f_ == 0)
1238         __f_ = 0;
1239     else if (__f.__f_ == (__base*)&__f.__buf_)
1240     {
1241         __f_ = (__base*)&__buf_;
1242         __f.__f_->__clone(__f_);
1243     }
1244     else
1245     {
1246         __f_ = __f.__f_;
1247         __f.__f_ = 0;
1248     }
1249 }
1250
1251 template<class _Rp, class ..._ArgTypes>
1252 template <class _Alloc>
1253 function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
1254                                      function&& __f)
1255 {
1256     if (__f.__f_ == 0)
1257         __f_ = 0;
1258     else if (__f.__f_ == (__base*)&__f.__buf_)
1259     {
1260         __f_ = (__base*)&__buf_;
1261         __f.__f_->__clone(__f_);
1262     }
1263     else
1264     {
1265         __f_ = __f.__f_;
1266         __f.__f_ = 0;
1267     }
1268 }
1269
1270 template<class _Rp, class ..._ArgTypes>
1271 template <class _Fp>
1272 function<_Rp(_ArgTypes...)>::function(_Fp __f,
1273                                      typename enable_if
1274                                      <
1275                                         __callable<_Fp>::value &&
1276                                         !is_same<_Fp, function>::value
1277                                      >::type*)
1278     : __f_(0)
1279 {
1280     if (__not_null(__f))
1281     {
1282         typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_ArgTypes...)> _FF;
1283         if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value)
1284         {
1285             __f_ = (__base*)&__buf_;
1286             ::new (__f_) _FF(_VSTD::move(__f));
1287         }
1288         else
1289         {
1290             typedef allocator<_FF> _Ap;
1291             _Ap __a;
1292             typedef __allocator_destructor<_Ap> _Dp;
1293             unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
1294             ::new (__hold.get()) _FF(_VSTD::move(__f), allocator<_Fp>(__a));
1295             __f_ = __hold.release();
1296         }
1297     }
1298 }
1299
1300 template<class _Rp, class ..._ArgTypes>
1301 template <class _Fp, class _Alloc>
1302 function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f,
1303                                      typename enable_if<__callable<_Fp>::value>::type*)
1304     : __f_(0)
1305 {
1306     typedef allocator_traits<_Alloc> __alloc_traits;
1307     if (__not_null(__f))
1308     {
1309         typedef __function::__func<_Fp, _Alloc, _Rp(_ArgTypes...)> _FF;
1310         if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value)
1311         {
1312             __f_ = (__base*)&__buf_;
1313             ::new (__f_) _FF(_VSTD::move(__f));
1314         }
1315         else
1316         {
1317             typedef typename __alloc_traits::template
1318 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
1319                 rebind_alloc<_FF>
1320 #else
1321                 rebind_alloc<_FF>::other
1322 #endif
1323                                                          _Ap;
1324             _Ap __a(__a0);
1325             typedef __allocator_destructor<_Ap> _Dp;
1326             unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
1327             ::new (__hold.get()) _FF(_VSTD::move(__f), _Alloc(__a));
1328             __f_ = __hold.release();
1329         }
1330     }
1331 }
1332
1333 template<class _Rp, class ..._ArgTypes>
1334 function<_Rp(_ArgTypes...)>&
1335 function<_Rp(_ArgTypes...)>::operator=(const function& __f)
1336 {
1337     function(__f).swap(*this);
1338     return *this;
1339 }
1340
1341 template<class _Rp, class ..._ArgTypes>
1342 function<_Rp(_ArgTypes...)>&
1343 function<_Rp(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT
1344 {
1345     if (__f_ == (__base*)&__buf_)
1346         __f_->destroy();
1347     else if (__f_)
1348         __f_->destroy_deallocate();
1349     __f_ = 0;
1350     if (__f.__f_ == 0)
1351         __f_ = 0;
1352     else if (__f.__f_ == (__base*)&__f.__buf_)
1353     {
1354         __f_ = (__base*)&__buf_;
1355         __f.__f_->__clone(__f_);
1356     }
1357     else
1358     {
1359         __f_ = __f.__f_;
1360         __f.__f_ = 0;
1361     }
1362     return *this;
1363 }
1364
1365 template<class _Rp, class ..._ArgTypes>
1366 function<_Rp(_ArgTypes...)>&
1367 function<_Rp(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT
1368 {
1369     if (__f_ == (__base*)&__buf_)
1370         __f_->destroy();
1371     else if (__f_)
1372         __f_->destroy_deallocate();
1373     __f_ = 0;
1374     return *this;
1375 }
1376
1377 template<class _Rp, class ..._ArgTypes>
1378 template <class _Fp>
1379 typename enable_if
1380 <
1381     function<_Rp(_ArgTypes...)>::template __callable<typename decay<_Fp>::type>::value &&
1382     !is_same<typename remove_reference<_Fp>::type, function<_Rp(_ArgTypes...)>>::value,
1383     function<_Rp(_ArgTypes...)>&
1384 >::type
1385 function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f)
1386 {
1387     function(_VSTD::forward<_Fp>(__f)).swap(*this);
1388     return *this;
1389 }
1390
1391 template<class _Rp, class ..._ArgTypes>
1392 function<_Rp(_ArgTypes...)>::~function()
1393 {
1394     if (__f_ == (__base*)&__buf_)
1395         __f_->destroy();
1396     else if (__f_)
1397         __f_->destroy_deallocate();
1398 }
1399
1400 template<class _Rp, class ..._ArgTypes>
1401 void
1402 function<_Rp(_ArgTypes...)>::swap(function& __f) _NOEXCEPT
1403 {
1404     if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_)
1405     {
1406         typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
1407         __base* __t = (__base*)&__tempbuf;
1408         __f_->__clone(__t);
1409         __f_->destroy();
1410         __f_ = 0;
1411         __f.__f_->__clone((__base*)&__buf_);
1412         __f.__f_->destroy();
1413         __f.__f_ = 0;
1414         __f_ = (__base*)&__buf_;
1415         __t->__clone((__base*)&__f.__buf_);
1416         __t->destroy();
1417         __f.__f_ = (__base*)&__f.__buf_;
1418     }
1419     else if (__f_ == (__base*)&__buf_)
1420     {
1421         __f_->__clone((__base*)&__f.__buf_);
1422         __f_->destroy();
1423         __f_ = __f.__f_;
1424         __f.__f_ = (__base*)&__f.__buf_;
1425     }
1426     else if (__f.__f_ == (__base*)&__f.__buf_)
1427     {
1428         __f.__f_->__clone((__base*)&__buf_);
1429         __f.__f_->destroy();
1430         __f.__f_ = __f_;
1431         __f_ = (__base*)&__buf_;
1432     }
1433     else
1434         _VSTD::swap(__f_, __f.__f_);
1435 }
1436
1437 template<class _Rp, class ..._ArgTypes>
1438 _Rp
1439 function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
1440 {
1441 #ifndef _LIBCPP_NO_EXCEPTIONS
1442     if (__f_ == 0)
1443         throw bad_function_call();
1444 #endif  // _LIBCPP_NO_EXCEPTIONS
1445     return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...);
1446 }
1447
1448 #ifndef _LIBCPP_NO_RTTI
1449
1450 template<class _Rp, class ..._ArgTypes>
1451 const std::type_info&
1452 function<_Rp(_ArgTypes...)>::target_type() const _NOEXCEPT
1453 {
1454     if (__f_ == 0)
1455         return typeid(void);
1456     return __f_->target_type();
1457 }
1458
1459 template<class _Rp, class ..._ArgTypes>
1460 template <typename _Tp>
1461 _Tp*
1462 function<_Rp(_ArgTypes...)>::target() _NOEXCEPT
1463 {
1464     if (__f_ == 0)
1465         return (_Tp*)0;
1466     return (_Tp*)__f_->target(typeid(_Tp));
1467 }
1468
1469 template<class _Rp, class ..._ArgTypes>
1470 template <typename _Tp>
1471 const _Tp*
1472 function<_Rp(_ArgTypes...)>::target() const _NOEXCEPT
1473 {
1474     if (__f_ == 0)
1475         return (const _Tp*)0;
1476     return (const _Tp*)__f_->target(typeid(_Tp));
1477 }
1478
1479 #endif  // _LIBCPP_NO_RTTI
1480
1481 template <class _Rp, class... _ArgTypes>
1482 inline _LIBCPP_INLINE_VISIBILITY
1483 bool
1484 operator==(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return !__f;}
1485
1486 template <class _Rp, class... _ArgTypes>
1487 inline _LIBCPP_INLINE_VISIBILITY
1488 bool
1489 operator==(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return !__f;}
1490
1491 template <class _Rp, class... _ArgTypes>
1492 inline _LIBCPP_INLINE_VISIBILITY
1493 bool
1494 operator!=(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return (bool)__f;}
1495
1496 template <class _Rp, class... _ArgTypes>
1497 inline _LIBCPP_INLINE_VISIBILITY
1498 bool
1499 operator!=(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return (bool)__f;}
1500
1501 template <class _Rp, class... _ArgTypes>
1502 inline _LIBCPP_INLINE_VISIBILITY
1503 void
1504 swap(function<_Rp(_ArgTypes...)>& __x, function<_Rp(_ArgTypes...)>& __y) _NOEXCEPT
1505 {return __x.swap(__y);}
1506
1507 template<class _Tp> struct __is_bind_expression : public false_type {};
1508 template<class _Tp> struct _LIBCPP_TYPE_VIS is_bind_expression
1509     : public __is_bind_expression<typename remove_cv<_Tp>::type> {};
1510
1511 template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {};
1512 template<class _Tp> struct _LIBCPP_TYPE_VIS is_placeholder
1513     : public __is_placeholder<typename remove_cv<_Tp>::type> {};
1514
1515 namespace placeholders
1516 {
1517
1518 template <int _Np> struct __ph {};
1519
1520 extern __ph<1>   _1;
1521 extern __ph<2>   _2;
1522 extern __ph<3>   _3;
1523 extern __ph<4>   _4;
1524 extern __ph<5>   _5;
1525 extern __ph<6>   _6;
1526 extern __ph<7>   _7;
1527 extern __ph<8>   _8;
1528 extern __ph<9>   _9;
1529 extern __ph<10> _10;
1530
1531 }  // placeholders
1532
1533 template<int _Np>
1534 struct __is_placeholder<placeholders::__ph<_Np> >
1535     : public integral_constant<int, _Np> {};
1536
1537 template <class _Tp, class _Uj>
1538 inline _LIBCPP_INLINE_VISIBILITY
1539 _Tp&
1540 __mu(reference_wrapper<_Tp> __t, _Uj&)
1541 {
1542     return __t.get();
1543 }
1544
1545 template <class _Ti, class ..._Uj, size_t ..._Indx>
1546 inline _LIBCPP_INLINE_VISIBILITY
1547 typename __invoke_of<_Ti&, _Uj...>::type
1548 __mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>)
1549 {
1550     return __ti(_VSTD::forward<_Uj>(get<_Indx>(__uj))...);
1551 }
1552
1553 template <class _Ti, class ..._Uj>
1554 inline _LIBCPP_INLINE_VISIBILITY
1555 typename enable_if
1556 <
1557     is_bind_expression<_Ti>::value,
1558     typename __invoke_of<_Ti&, _Uj...>::type
1559 >::type
1560 __mu(_Ti& __ti, tuple<_Uj...>& __uj)
1561 {
1562     typedef typename __make_tuple_indices<sizeof...(_Uj)>::type __indices;
1563     return  __mu_expand(__ti, __uj, __indices());
1564 }
1565
1566 template <bool IsPh, class _Ti, class _Uj>
1567 struct __mu_return2 {};
1568
1569 template <class _Ti, class _Uj>
1570 struct __mu_return2<true, _Ti, _Uj>
1571 {
1572     typedef typename tuple_element<is_placeholder<_Ti>::value - 1, _Uj>::type type;
1573 };
1574
1575 template <class _Ti, class _Uj>
1576 inline _LIBCPP_INLINE_VISIBILITY
1577 typename enable_if
1578 <
1579     0 < is_placeholder<_Ti>::value,
1580     typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::type
1581 >::type
1582 __mu(_Ti&, _Uj& __uj)
1583 {
1584     const size_t _Indx = is_placeholder<_Ti>::value - 1;
1585     return _VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj));
1586 }
1587
1588 template <class _Ti, class _Uj>
1589 inline _LIBCPP_INLINE_VISIBILITY
1590 typename enable_if
1591 <
1592     !is_bind_expression<_Ti>::value &&
1593     is_placeholder<_Ti>::value == 0 &&
1594     !__is_reference_wrapper<_Ti>::value,
1595     _Ti&
1596 >::type
1597 __mu(_Ti& __ti, _Uj&)
1598 {
1599     return __ti;
1600 }
1601
1602 template <class _Ti, bool IsReferenceWrapper, bool IsBindEx, bool IsPh,
1603           class _TupleUj>
1604 struct ____mu_return;
1605
1606 template <bool _Invokable, class _Ti, class ..._Uj>
1607 struct ____mu_return_invokable  // false
1608 {
1609     typedef __nat type;
1610 };
1611
1612 template <class _Ti, class ..._Uj>
1613 struct ____mu_return_invokable<true, _Ti, _Uj...>
1614 {
1615     typedef typename __invoke_of<_Ti&, _Uj...>::type type;
1616 };
1617
1618 template <class _Ti, class ..._Uj>
1619 struct ____mu_return<_Ti, false, true, false, tuple<_Uj...> >
1620     : public ____mu_return_invokable<__invokable<_Ti&, _Uj...>::value, _Ti, _Uj...>
1621 {
1622 };
1623
1624 template <class _Ti, class _TupleUj>
1625 struct ____mu_return<_Ti, false, false, true, _TupleUj>
1626 {
1627     typedef typename tuple_element<is_placeholder<_Ti>::value - 1,
1628                                    _TupleUj>::type&& type;
1629 };
1630
1631 template <class _Ti, class _TupleUj>
1632 struct ____mu_return<_Ti, true, false, false, _TupleUj>
1633 {
1634     typedef typename _Ti::type& type;
1635 };
1636
1637 template <class _Ti, class _TupleUj>
1638 struct ____mu_return<_Ti, false, false, false, _TupleUj>
1639 {
1640     typedef _Ti& type;
1641 };
1642
1643 template <class _Ti, class _TupleUj>
1644 struct __mu_return
1645     : public ____mu_return<_Ti,
1646                            __is_reference_wrapper<_Ti>::value,
1647                            is_bind_expression<_Ti>::value,
1648                            0 < is_placeholder<_Ti>::value &&
1649                            is_placeholder<_Ti>::value <= tuple_size<_TupleUj>::value,
1650                            _TupleUj>
1651 {
1652 };
1653
1654 template <class _Fp, class _BoundArgs, class _TupleUj>
1655 struct _is_valid_bind_return
1656 {
1657     static const bool value = false;
1658 };
1659
1660 template <class _Fp, class ..._BoundArgs, class _TupleUj>
1661 struct _is_valid_bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj>
1662 {
1663     static const bool value = __invokable<_Fp,
1664                     typename __mu_return<_BoundArgs, _TupleUj>::type...>::value;
1665 };
1666
1667 template <class _Fp, class ..._BoundArgs, class _TupleUj>
1668 struct _is_valid_bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj>
1669 {
1670     static const bool value = __invokable<_Fp,
1671                     typename __mu_return<const _BoundArgs, _TupleUj>::type...>::value;
1672 };
1673
1674 template <class _Fp, class _BoundArgs, class _TupleUj,
1675           bool = _is_valid_bind_return<_Fp, _BoundArgs, _TupleUj>::value>
1676 struct __bind_return;
1677
1678 template <class _Fp, class ..._BoundArgs, class _TupleUj>
1679 struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj, true>
1680 {
1681     typedef typename __invoke_of
1682     <
1683         _Fp&,
1684         typename __mu_return
1685         <
1686             _BoundArgs,
1687             _TupleUj
1688         >::type...
1689     >::type type;
1690 };
1691
1692 template <class _Fp, class ..._BoundArgs, class _TupleUj>
1693 struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj, true>
1694 {
1695     typedef typename __invoke_of
1696     <
1697         _Fp&,
1698         typename __mu_return
1699         <
1700             const _BoundArgs,
1701             _TupleUj
1702         >::type...
1703     >::type type;
1704 };
1705
1706 template <class _Fp, class _BoundArgs, size_t ..._Indx, class _Args>
1707 inline _LIBCPP_INLINE_VISIBILITY
1708 typename __bind_return<_Fp, _BoundArgs, _Args>::type
1709 __apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>,
1710                 _Args&& __args)
1711 {
1712     return __invoke(__f, __mu(get<_Indx>(__bound_args), __args)...);
1713 }
1714
1715 template<class _Fp, class ..._BoundArgs>
1716 class __bind
1717     : public __weak_result_type<typename decay<_Fp>::type>
1718 {
1719 protected:
1720     typedef typename decay<_Fp>::type _Fd;
1721     typedef tuple<typename decay<_BoundArgs>::type...> _Td;
1722 private:
1723     _Fd __f_;
1724     _Td __bound_args_;
1725
1726     typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices;
1727 public:
1728 #ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
1729
1730     _LIBCPP_INLINE_VISIBILITY
1731     __bind(const __bind& __b)
1732         : __f_(__b.__f_),
1733           __bound_args_(__b.__bound_args_) {}
1734
1735     _LIBCPP_INLINE_VISIBILITY
1736     __bind& operator=(const __bind& __b)
1737     {
1738         __f_ = __b.__f_;
1739         __bound_args_ = __b.__bound_args_;
1740         return *this;
1741     }
1742
1743     _LIBCPP_INLINE_VISIBILITY
1744     __bind(__bind&& __b)
1745         : __f_(_VSTD::move(__b.__f_)),
1746           __bound_args_(_VSTD::move(__b.__bound_args_)) {}
1747
1748     _LIBCPP_INLINE_VISIBILITY
1749     __bind& operator=(__bind&& __b)
1750     {
1751         __f_ = _VSTD::move(__b.__f_);
1752         __bound_args_ = _VSTD::move(__b.__bound_args_);
1753         return *this;
1754     }
1755
1756 #endif  // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
1757
1758     template <class _Gp, class ..._BA,
1759               class = typename enable_if
1760                                <
1761                                   is_constructible<_Fd, _Gp>::value &&
1762                                   !is_same<typename remove_reference<_Gp>::type,
1763                                            __bind>::value
1764                                >::type>
1765       _LIBCPP_INLINE_VISIBILITY
1766       explicit __bind(_Gp&& __f, _BA&& ...__bound_args)
1767         : __f_(_VSTD::forward<_Gp>(__f)),
1768           __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {}
1769
1770     template <class ..._Args>
1771         _LIBCPP_INLINE_VISIBILITY
1772         typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type
1773         operator()(_Args&& ...__args)
1774         {
1775             return __apply_functor(__f_, __bound_args_, __indices(),
1776                                   tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
1777         }
1778
1779     template <class ..._Args>
1780         _LIBCPP_INLINE_VISIBILITY
1781         typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type
1782         operator()(_Args&& ...__args) const
1783         {
1784             return __apply_functor(__f_, __bound_args_, __indices(),
1785                                    tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
1786         }
1787 };
1788
1789 template<class _Fp, class ..._BoundArgs>
1790 struct __is_bind_expression<__bind<_Fp, _BoundArgs...> > : public true_type {};
1791
1792 template<class _Rp, class _Fp, class ..._BoundArgs>
1793 class __bind_r
1794     : public __bind<_Fp, _BoundArgs...>
1795 {
1796     typedef __bind<_Fp, _BoundArgs...> base;
1797     typedef typename base::_Fd _Fd;
1798     typedef typename base::_Td _Td;
1799 public:
1800     typedef _Rp result_type;
1801
1802 #ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
1803
1804     _LIBCPP_INLINE_VISIBILITY
1805     __bind_r(const __bind_r& __b)
1806         : base(_VSTD::forward<const base&>(__b)) {}
1807
1808     _LIBCPP_INLINE_VISIBILITY
1809     __bind_r& operator=(const __bind_r& __b)
1810     {
1811         base::operator=(_VSTD::forward<const base&>(__b));
1812         return *this;
1813     }
1814
1815     _LIBCPP_INLINE_VISIBILITY
1816     __bind_r(__bind_r&& __b)
1817         : base(_VSTD::forward<base>(__b)) {}
1818
1819     _LIBCPP_INLINE_VISIBILITY
1820     __bind_r& operator=(__bind_r&& __b)
1821     {
1822         base::operator=(_VSTD::forward<base>(__b));
1823         return *this;
1824     }
1825
1826 #endif  // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
1827
1828     template <class _Gp, class ..._BA,
1829               class = typename enable_if
1830                                <
1831                                   is_constructible<_Fd, _Gp>::value &&
1832                                   !is_same<typename remove_reference<_Gp>::type,
1833                                            __bind_r>::value
1834                                >::type>
1835       _LIBCPP_INLINE_VISIBILITY
1836       explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args)
1837         : base(_VSTD::forward<_Gp>(__f),
1838                _VSTD::forward<_BA>(__bound_args)...) {}
1839
1840     template <class ..._Args>
1841         _LIBCPP_INLINE_VISIBILITY
1842         typename enable_if
1843         <
1844             is_convertible<typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type,
1845                            result_type>::value,
1846             result_type
1847         >::type
1848         operator()(_Args&& ...__args)
1849         {
1850             return base::operator()(_VSTD::forward<_Args>(__args)...);
1851         }
1852
1853     template <class ..._Args>
1854         _LIBCPP_INLINE_VISIBILITY
1855         typename enable_if
1856         <
1857             is_convertible<typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type,
1858                            result_type>::value,
1859             result_type
1860         >::type
1861         operator()(_Args&& ...__args) const
1862         {
1863             return base::operator()(_VSTD::forward<_Args>(__args)...);
1864         }
1865 };
1866
1867 template<class _Rp, class _Fp, class ..._BoundArgs>
1868 struct __is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {};
1869
1870 template<class _Fp, class ..._BoundArgs>
1871 inline _LIBCPP_INLINE_VISIBILITY
1872 __bind<_Fp, _BoundArgs...>
1873 bind(_Fp&& __f, _BoundArgs&&... __bound_args)
1874 {
1875     typedef __bind<_Fp, _BoundArgs...> type;
1876     return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
1877 }
1878
1879 template<class _Rp, class _Fp, class ..._BoundArgs>
1880 inline _LIBCPP_INLINE_VISIBILITY
1881 __bind_r<_Rp, _Fp, _BoundArgs...>
1882 bind(_Fp&& __f, _BoundArgs&&... __bound_args)
1883 {
1884     typedef __bind_r<_Rp, _Fp, _BoundArgs...> type;
1885     return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
1886 }
1887
1888 #endif  // _LIBCPP_HAS_NO_VARIADICS
1889
1890 template <>
1891 struct _LIBCPP_TYPE_VIS hash<bool>
1892     : public unary_function<bool, size_t>
1893 {
1894     _LIBCPP_INLINE_VISIBILITY
1895     size_t operator()(bool __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1896 };
1897
1898 template <>
1899 struct _LIBCPP_TYPE_VIS hash<char>
1900     : public unary_function<char, size_t>
1901 {
1902     _LIBCPP_INLINE_VISIBILITY
1903     size_t operator()(char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1904 };
1905
1906 template <>
1907 struct _LIBCPP_TYPE_VIS hash<signed char>
1908     : public unary_function<signed char, size_t>
1909 {
1910     _LIBCPP_INLINE_VISIBILITY
1911     size_t operator()(signed char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1912 };
1913
1914 template <>
1915 struct _LIBCPP_TYPE_VIS hash<unsigned char>
1916     : public unary_function<unsigned char, size_t>
1917 {
1918     _LIBCPP_INLINE_VISIBILITY
1919     size_t operator()(unsigned char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1920 };
1921
1922 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
1923
1924 template <>
1925 struct _LIBCPP_TYPE_VIS hash<char16_t>
1926     : public unary_function<char16_t, size_t>
1927 {
1928     _LIBCPP_INLINE_VISIBILITY
1929     size_t operator()(char16_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1930 };
1931
1932 template <>
1933 struct _LIBCPP_TYPE_VIS hash<char32_t>
1934     : public unary_function<char32_t, size_t>
1935 {
1936     _LIBCPP_INLINE_VISIBILITY
1937     size_t operator()(char32_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1938 };
1939
1940 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
1941
1942 template <>
1943 struct _LIBCPP_TYPE_VIS hash<wchar_t>
1944     : public unary_function<wchar_t, size_t>
1945 {
1946     _LIBCPP_INLINE_VISIBILITY
1947     size_t operator()(wchar_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1948 };
1949
1950 template <>
1951 struct _LIBCPP_TYPE_VIS hash<short>
1952     : public unary_function<short, size_t>
1953 {
1954     _LIBCPP_INLINE_VISIBILITY
1955     size_t operator()(short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1956 };
1957
1958 template <>
1959 struct _LIBCPP_TYPE_VIS hash<unsigned short>
1960     : public unary_function<unsigned short, size_t>
1961 {
1962     _LIBCPP_INLINE_VISIBILITY
1963     size_t operator()(unsigned short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1964 };
1965
1966 template <>
1967 struct _LIBCPP_TYPE_VIS hash<int>
1968     : public unary_function<int, size_t>
1969 {
1970     _LIBCPP_INLINE_VISIBILITY
1971     size_t operator()(int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1972 };
1973
1974 template <>
1975 struct _LIBCPP_TYPE_VIS hash<unsigned int>
1976     : public unary_function<unsigned int, size_t>
1977 {
1978     _LIBCPP_INLINE_VISIBILITY
1979     size_t operator()(unsigned int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1980 };
1981
1982 template <>
1983 struct _LIBCPP_TYPE_VIS hash<long>
1984     : public unary_function<long, size_t>
1985 {
1986     _LIBCPP_INLINE_VISIBILITY
1987     size_t operator()(long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1988 };
1989
1990 template <>
1991 struct _LIBCPP_TYPE_VIS hash<unsigned long>
1992     : public unary_function<unsigned long, size_t>
1993 {
1994     _LIBCPP_INLINE_VISIBILITY
1995     size_t operator()(unsigned long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1996 };
1997
1998 template <>
1999 struct _LIBCPP_TYPE_VIS hash<long long>
2000     : public __scalar_hash<long long>
2001 {
2002 };
2003
2004 template <>
2005 struct _LIBCPP_TYPE_VIS hash<unsigned long long>
2006     : public __scalar_hash<unsigned long long>
2007 {
2008 };
2009
2010 template <>
2011 struct _LIBCPP_TYPE_VIS hash<float>
2012     : public __scalar_hash<float>
2013 {
2014     _LIBCPP_INLINE_VISIBILITY
2015     size_t operator()(float __v) const _NOEXCEPT
2016     {
2017         // -0.0 and 0.0 should return same hash
2018        if (__v == 0)
2019            return 0;
2020         return __scalar_hash<float>::operator()(__v);
2021     }
2022 };
2023
2024 template <>
2025 struct _LIBCPP_TYPE_VIS hash<double>
2026     : public __scalar_hash<double>
2027 {
2028     _LIBCPP_INLINE_VISIBILITY
2029     size_t operator()(double __v) const _NOEXCEPT
2030     {
2031         // -0.0 and 0.0 should return same hash
2032        if (__v == 0)
2033            return 0;
2034         return __scalar_hash<double>::operator()(__v);
2035     }
2036 };
2037
2038 template <>
2039 struct _LIBCPP_TYPE_VIS hash<long double>
2040     : public __scalar_hash<long double>
2041 {
2042     _LIBCPP_INLINE_VISIBILITY
2043     size_t operator()(long double __v) const _NOEXCEPT
2044     {
2045         // -0.0 and 0.0 should return same hash
2046         if (__v == 0)
2047             return 0;
2048 #if defined(__i386__)
2049         // Zero out padding bits
2050         union
2051         {
2052             long double __t;
2053             struct
2054             {
2055                 size_t __a;
2056                 size_t __b;
2057                 size_t __c;
2058                 size_t __d;
2059             };
2060         } __u;
2061         __u.__a = 0;
2062         __u.__b = 0;
2063         __u.__c = 0;
2064         __u.__d = 0;
2065         __u.__t = __v;
2066         return __u.__a ^ __u.__b ^ __u.__c ^ __u.__d;
2067 #elif defined(__x86_64__)
2068         // Zero out padding bits
2069         union
2070         {
2071             long double __t;
2072             struct
2073             {
2074                 size_t __a;
2075                 size_t __b;
2076             };
2077         } __u;
2078         __u.__a = 0;
2079         __u.__b = 0;
2080         __u.__t = __v;
2081         return __u.__a ^ __u.__b;
2082 #else
2083         return __scalar_hash<long double>::operator()(__v);
2084 #endif
2085     }
2086 };
2087
2088 // struct hash<T*> in <memory>
2089
2090 _LIBCPP_END_NAMESPACE_STD
2091
2092 #endif  // _LIBCPP_FUNCTIONAL