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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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_VISIBLE 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     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,
1143                typename enable_if<__callable<_Fp>::value>::type* = 0);
1144
1145     template<class _Alloc>
1146       _LIBCPP_INLINE_VISIBILITY
1147       function(allocator_arg_t, const _Alloc&) _NOEXCEPT : __f_(0) {}
1148     template<class _Alloc>
1149       _LIBCPP_INLINE_VISIBILITY
1150       function(allocator_arg_t, const _Alloc&, nullptr_t) _NOEXCEPT : __f_(0) {}
1151     template<class _Alloc>
1152       function(allocator_arg_t, const _Alloc&, const function&);
1153     template<class _Alloc>
1154       function(allocator_arg_t, const _Alloc&, function&&);
1155     template<class _Fp, class _Alloc>
1156       function(allocator_arg_t, const _Alloc& __a, _Fp __f,
1157                typename enable_if<__callable<_Fp>::value>::type* = 0);
1158
1159     function& operator=(const function&);
1160     function& operator=(function&&) _NOEXCEPT;
1161     function& operator=(nullptr_t) _NOEXCEPT;
1162     template<class _Fp>
1163       typename enable_if
1164       <
1165         __callable<typename decay<_Fp>::type>::value,
1166         function&
1167       >::type
1168       operator=(_Fp&&);
1169
1170     ~function();
1171
1172     // function modifiers:
1173     void swap(function&) _NOEXCEPT;
1174     template<class _Fp, class _Alloc>
1175       _LIBCPP_INLINE_VISIBILITY
1176       void assign(_Fp&& __f, const _Alloc& __a)
1177         {function(allocator_arg, __a, _VSTD::forward<_Fp>(__f)).swap(*this);}
1178
1179     // function capacity:
1180     _LIBCPP_INLINE_VISIBILITY
1181         _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {return __f_;}
1182
1183     // deleted overloads close possible hole in the type system
1184     template<class _R2, class... _ArgTypes2>
1185       bool operator==(const function<_R2(_ArgTypes2...)>&) const = delete;
1186     template<class _R2, class... _ArgTypes2>
1187       bool operator!=(const function<_R2(_ArgTypes2...)>&) const = delete;
1188 public:
1189     // function invocation:
1190     _Rp operator()(_ArgTypes...) const;
1191
1192 #ifndef _LIBCPP_NO_RTTI
1193     // function target access:
1194     const std::type_info& target_type() const _NOEXCEPT;
1195     template <typename _Tp> _Tp* target() _NOEXCEPT;
1196     template <typename _Tp> const _Tp* target() const _NOEXCEPT;
1197 #endif  // _LIBCPP_NO_RTTI
1198 };
1199
1200 template<class _Rp, class ..._ArgTypes>
1201 function<_Rp(_ArgTypes...)>::function(const function& __f)
1202 {
1203     if (__f.__f_ == 0)
1204         __f_ = 0;
1205     else if (__f.__f_ == (const __base*)&__f.__buf_)
1206     {
1207         __f_ = (__base*)&__buf_;
1208         __f.__f_->__clone(__f_);
1209     }
1210     else
1211         __f_ = __f.__f_->__clone();
1212 }
1213
1214 template<class _Rp, class ..._ArgTypes>
1215 template <class _Alloc>
1216 function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
1217                                      const function& __f)
1218 {
1219     if (__f.__f_ == 0)
1220         __f_ = 0;
1221     else if (__f.__f_ == (const __base*)&__f.__buf_)
1222     {
1223         __f_ = (__base*)&__buf_;
1224         __f.__f_->__clone(__f_);
1225     }
1226     else
1227         __f_ = __f.__f_->__clone();
1228 }
1229
1230 template<class _Rp, class ..._ArgTypes>
1231 function<_Rp(_ArgTypes...)>::function(function&& __f) _NOEXCEPT
1232 {
1233     if (__f.__f_ == 0)
1234         __f_ = 0;
1235     else if (__f.__f_ == (__base*)&__f.__buf_)
1236     {
1237         __f_ = (__base*)&__buf_;
1238         __f.__f_->__clone(__f_);
1239     }
1240     else
1241     {
1242         __f_ = __f.__f_;
1243         __f.__f_ = 0;
1244     }
1245 }
1246
1247 template<class _Rp, class ..._ArgTypes>
1248 template <class _Alloc>
1249 function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
1250                                      function&& __f)
1251 {
1252     if (__f.__f_ == 0)
1253         __f_ = 0;
1254     else if (__f.__f_ == (__base*)&__f.__buf_)
1255     {
1256         __f_ = (__base*)&__buf_;
1257         __f.__f_->__clone(__f_);
1258     }
1259     else
1260     {
1261         __f_ = __f.__f_;
1262         __f.__f_ = 0;
1263     }
1264 }
1265
1266 template<class _Rp, class ..._ArgTypes>
1267 template <class _Fp>
1268 function<_Rp(_ArgTypes...)>::function(_Fp __f,
1269                                      typename enable_if<__callable<_Fp>::value>::type*)
1270     : __f_(0)
1271 {
1272     if (__not_null(__f))
1273     {
1274         typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_ArgTypes...)> _FF;
1275         if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value)
1276         {
1277             __f_ = (__base*)&__buf_;
1278             ::new (__f_) _FF(_VSTD::move(__f));
1279         }
1280         else
1281         {
1282             typedef allocator<_FF> _Ap;
1283             _Ap __a;
1284             typedef __allocator_destructor<_Ap> _Dp;
1285             unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
1286             ::new (__hold.get()) _FF(_VSTD::move(__f), allocator<_Fp>(__a));
1287             __f_ = __hold.release();
1288         }
1289     }
1290 }
1291
1292 template<class _Rp, class ..._ArgTypes>
1293 template <class _Fp, class _Alloc>
1294 function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f,
1295                                      typename enable_if<__callable<_Fp>::value>::type*)
1296     : __f_(0)
1297 {
1298     typedef allocator_traits<_Alloc> __alloc_traits;
1299     if (__not_null(__f))
1300     {
1301         typedef __function::__func<_Fp, _Alloc, _Rp(_ArgTypes...)> _FF;
1302         if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value)
1303         {
1304             __f_ = (__base*)&__buf_;
1305             ::new (__f_) _FF(_VSTD::move(__f));
1306         }
1307         else
1308         {
1309             typedef typename __alloc_traits::template
1310 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
1311                 rebind_alloc<_FF>
1312 #else
1313                 rebind_alloc<_FF>::other
1314 #endif
1315                                                          _Ap;
1316             _Ap __a(__a0);
1317             typedef __allocator_destructor<_Ap> _Dp;
1318             unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
1319             ::new (__hold.get()) _FF(_VSTD::move(__f), _Alloc(__a));
1320             __f_ = __hold.release();
1321         }
1322     }
1323 }
1324
1325 template<class _Rp, class ..._ArgTypes>
1326 function<_Rp(_ArgTypes...)>&
1327 function<_Rp(_ArgTypes...)>::operator=(const function& __f)
1328 {
1329     function(__f).swap(*this);
1330     return *this;
1331 }
1332
1333 template<class _Rp, class ..._ArgTypes>
1334 function<_Rp(_ArgTypes...)>&
1335 function<_Rp(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT
1336 {
1337     if (__f_ == (__base*)&__buf_)
1338         __f_->destroy();
1339     else if (__f_)
1340         __f_->destroy_deallocate();
1341     __f_ = 0;
1342     if (__f.__f_ == 0)
1343         __f_ = 0;
1344     else if (__f.__f_ == (__base*)&__f.__buf_)
1345     {
1346         __f_ = (__base*)&__buf_;
1347         __f.__f_->__clone(__f_);
1348     }
1349     else
1350     {
1351         __f_ = __f.__f_;
1352         __f.__f_ = 0;
1353     }
1354     return *this;
1355 }
1356
1357 template<class _Rp, class ..._ArgTypes>
1358 function<_Rp(_ArgTypes...)>&
1359 function<_Rp(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT
1360 {
1361     if (__f_ == (__base*)&__buf_)
1362         __f_->destroy();
1363     else if (__f_)
1364         __f_->destroy_deallocate();
1365     __f_ = 0;
1366     return *this;
1367 }
1368
1369 template<class _Rp, class ..._ArgTypes>
1370 template <class _Fp>
1371 typename enable_if
1372 <
1373     function<_Rp(_ArgTypes...)>::template __callable<typename decay<_Fp>::type>::value,
1374     function<_Rp(_ArgTypes...)>&
1375 >::type
1376 function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f)
1377 {
1378     function(_VSTD::forward<_Fp>(__f)).swap(*this);
1379     return *this;
1380 }
1381
1382 template<class _Rp, class ..._ArgTypes>
1383 function<_Rp(_ArgTypes...)>::~function()
1384 {
1385     if (__f_ == (__base*)&__buf_)
1386         __f_->destroy();
1387     else if (__f_)
1388         __f_->destroy_deallocate();
1389 }
1390
1391 template<class _Rp, class ..._ArgTypes>
1392 void
1393 function<_Rp(_ArgTypes...)>::swap(function& __f) _NOEXCEPT
1394 {
1395     if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_)
1396     {
1397         typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
1398         __base* __t = (__base*)&__tempbuf;
1399         __f_->__clone(__t);
1400         __f_->destroy();
1401         __f_ = 0;
1402         __f.__f_->__clone((__base*)&__buf_);
1403         __f.__f_->destroy();
1404         __f.__f_ = 0;
1405         __f_ = (__base*)&__buf_;
1406         __t->__clone((__base*)&__f.__buf_);
1407         __t->destroy();
1408         __f.__f_ = (__base*)&__f.__buf_;
1409     }
1410     else if (__f_ == (__base*)&__buf_)
1411     {
1412         __f_->__clone((__base*)&__f.__buf_);
1413         __f_->destroy();
1414         __f_ = __f.__f_;
1415         __f.__f_ = (__base*)&__f.__buf_;
1416     }
1417     else if (__f.__f_ == (__base*)&__f.__buf_)
1418     {
1419         __f.__f_->__clone((__base*)&__buf_);
1420         __f.__f_->destroy();
1421         __f.__f_ = __f_;
1422         __f_ = (__base*)&__buf_;
1423     }
1424     else
1425         _VSTD::swap(__f_, __f.__f_);
1426 }
1427
1428 template<class _Rp, class ..._ArgTypes>
1429 _Rp
1430 function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
1431 {
1432 #ifndef _LIBCPP_NO_EXCEPTIONS
1433     if (__f_ == 0)
1434         throw bad_function_call();
1435 #endif  // _LIBCPP_NO_EXCEPTIONS
1436     return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...);
1437 }
1438
1439 #ifndef _LIBCPP_NO_RTTI
1440
1441 template<class _Rp, class ..._ArgTypes>
1442 const std::type_info&
1443 function<_Rp(_ArgTypes...)>::target_type() const _NOEXCEPT
1444 {
1445     if (__f_ == 0)
1446         return typeid(void);
1447     return __f_->target_type();
1448 }
1449
1450 template<class _Rp, class ..._ArgTypes>
1451 template <typename _Tp>
1452 _Tp*
1453 function<_Rp(_ArgTypes...)>::target() _NOEXCEPT
1454 {
1455     if (__f_ == 0)
1456         return (_Tp*)0;
1457     return (_Tp*)__f_->target(typeid(_Tp));
1458 }
1459
1460 template<class _Rp, class ..._ArgTypes>
1461 template <typename _Tp>
1462 const _Tp*
1463 function<_Rp(_ArgTypes...)>::target() const _NOEXCEPT
1464 {
1465     if (__f_ == 0)
1466         return (const _Tp*)0;
1467     return (const _Tp*)__f_->target(typeid(_Tp));
1468 }
1469
1470 #endif  // _LIBCPP_NO_RTTI
1471
1472 template <class _Rp, class... _ArgTypes>
1473 inline _LIBCPP_INLINE_VISIBILITY
1474 bool
1475 operator==(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return !__f;}
1476
1477 template <class _Rp, class... _ArgTypes>
1478 inline _LIBCPP_INLINE_VISIBILITY
1479 bool
1480 operator==(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return !__f;}
1481
1482 template <class _Rp, class... _ArgTypes>
1483 inline _LIBCPP_INLINE_VISIBILITY
1484 bool
1485 operator!=(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return (bool)__f;}
1486
1487 template <class _Rp, class... _ArgTypes>
1488 inline _LIBCPP_INLINE_VISIBILITY
1489 bool
1490 operator!=(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return (bool)__f;}
1491
1492 template <class _Rp, class... _ArgTypes>
1493 inline _LIBCPP_INLINE_VISIBILITY
1494 void
1495 swap(function<_Rp(_ArgTypes...)>& __x, function<_Rp(_ArgTypes...)>& __y) _NOEXCEPT
1496 {return __x.swap(__y);}
1497
1498 template<class _Tp> struct __is_bind_expression : public false_type {};
1499 template<class _Tp> struct _LIBCPP_VISIBLE is_bind_expression
1500     : public __is_bind_expression<typename remove_cv<_Tp>::type> {};
1501
1502 template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {};
1503 template<class _Tp> struct _LIBCPP_VISIBLE is_placeholder
1504     : public __is_placeholder<typename remove_cv<_Tp>::type> {};
1505
1506 namespace placeholders
1507 {
1508
1509 template <int _Np> struct __ph {};
1510
1511 extern __ph<1>   _1;
1512 extern __ph<2>   _2;
1513 extern __ph<3>   _3;
1514 extern __ph<4>   _4;
1515 extern __ph<5>   _5;
1516 extern __ph<6>   _6;
1517 extern __ph<7>   _7;
1518 extern __ph<8>   _8;
1519 extern __ph<9>   _9;
1520 extern __ph<10> _10;
1521
1522 }  // placeholders
1523
1524 template<int _Np>
1525 struct __is_placeholder<placeholders::__ph<_Np> >
1526     : public integral_constant<int, _Np> {};
1527
1528 template <class _Tp, class _Uj>
1529 inline _LIBCPP_INLINE_VISIBILITY
1530 _Tp&
1531 __mu(reference_wrapper<_Tp> __t, _Uj&)
1532 {
1533     return __t.get();
1534 }
1535
1536 template <class _Ti, class ..._Uj, size_t ..._Indx>
1537 inline _LIBCPP_INLINE_VISIBILITY
1538 typename __invoke_of<_Ti&, _Uj...>::type
1539 __mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>)
1540 {
1541     return __ti(_VSTD::forward<_Uj>(get<_Indx>(__uj))...);
1542 }
1543
1544 template <class _Ti, class ..._Uj>
1545 inline _LIBCPP_INLINE_VISIBILITY
1546 typename enable_if
1547 <
1548     is_bind_expression<_Ti>::value,
1549     typename __invoke_of<_Ti&, _Uj...>::type
1550 >::type
1551 __mu(_Ti& __ti, tuple<_Uj...>& __uj)
1552 {
1553     typedef typename __make_tuple_indices<sizeof...(_Uj)>::type __indices;
1554     return  __mu_expand(__ti, __uj, __indices());
1555 }
1556
1557 template <bool IsPh, class _Ti, class _Uj>
1558 struct __mu_return2 {};
1559
1560 template <class _Ti, class _Uj>
1561 struct __mu_return2<true, _Ti, _Uj>
1562 {
1563     typedef typename tuple_element<is_placeholder<_Ti>::value - 1, _Uj>::type type;
1564 };
1565
1566 template <class _Ti, class _Uj>
1567 inline _LIBCPP_INLINE_VISIBILITY
1568 typename enable_if
1569 <
1570     0 < is_placeholder<_Ti>::value,
1571     typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::type
1572 >::type
1573 __mu(_Ti&, _Uj& __uj)
1574 {
1575     const size_t _Indx = is_placeholder<_Ti>::value - 1;
1576     return _VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj));
1577 }
1578
1579 template <class _Ti, class _Uj>
1580 inline _LIBCPP_INLINE_VISIBILITY
1581 typename enable_if
1582 <
1583     !is_bind_expression<_Ti>::value &&
1584     is_placeholder<_Ti>::value == 0 &&
1585     !__is_reference_wrapper<_Ti>::value,
1586     _Ti&
1587 >::type
1588 __mu(_Ti& __ti, _Uj&)
1589 {
1590     return __ti;
1591 }
1592
1593 template <class _Ti, bool IsReferenceWrapper, bool IsBindEx, bool IsPh,
1594           class _TupleUj>
1595 struct ____mu_return;
1596
1597 template <class _Ti, class ..._Uj>
1598 struct ____mu_return<_Ti, false, true, false, tuple<_Uj...> >
1599 {
1600     typedef typename __invoke_of<_Ti&, _Uj...>::type type;
1601 };
1602
1603 template <class _Ti, class _TupleUj>
1604 struct ____mu_return<_Ti, false, false, true, _TupleUj>
1605 {
1606     typedef typename tuple_element<is_placeholder<_Ti>::value - 1,
1607                                    _TupleUj>::type&& type;
1608 };
1609
1610 template <class _Ti, class _TupleUj>
1611 struct ____mu_return<_Ti, true, false, false, _TupleUj>
1612 {
1613     typedef typename _Ti::type& type;
1614 };
1615
1616 template <class _Ti, class _TupleUj>
1617 struct ____mu_return<_Ti, false, false, false, _TupleUj>
1618 {
1619     typedef _Ti& type;
1620 };
1621
1622 template <class _Ti, class _TupleUj>
1623 struct __mu_return
1624     : public ____mu_return<_Ti,
1625                            __is_reference_wrapper<_Ti>::value,
1626                            is_bind_expression<_Ti>::value,
1627                            0 < is_placeholder<_Ti>::value,
1628                            _TupleUj>
1629 {
1630 };
1631
1632 template <class _Fp, class _BoundArgs, class _TupleUj>
1633 struct __bind_return;
1634
1635 template <class _Fp, class ..._BoundArgs, class _TupleUj>
1636 struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj>
1637 {
1638     typedef typename __invoke_of
1639     <
1640         _Fp&,
1641         typename __mu_return
1642         <
1643             _BoundArgs,
1644             _TupleUj
1645         >::type...
1646     >::type type;
1647 };
1648
1649 template <class _Fp, class ..._BoundArgs, class _TupleUj>
1650 struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj>
1651 {
1652     typedef typename __invoke_of
1653     <
1654         _Fp&,
1655         typename __mu_return
1656         <
1657             const _BoundArgs,
1658             _TupleUj
1659         >::type...
1660     >::type type;
1661 };
1662
1663 template <class _Fp, class _BoundArgs, size_t ..._Indx, class _Args>
1664 inline _LIBCPP_INLINE_VISIBILITY
1665 typename __bind_return<_Fp, _BoundArgs, _Args>::type
1666 __apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>,
1667                 _Args&& __args)
1668 {
1669     return __invoke(__f, __mu(get<_Indx>(__bound_args), __args)...);
1670 }
1671
1672 template<class _Fp, class ..._BoundArgs>
1673 class __bind
1674     : public __weak_result_type<typename decay<_Fp>::type>
1675 {
1676     typedef typename decay<_Fp>::type _Fd;
1677     typedef tuple<typename decay<_BoundArgs>::type...> _Td;
1678     _Fd __f_;
1679     _Td __bound_args_;
1680
1681     typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices;
1682 public:
1683 #ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
1684
1685     _LIBCPP_INLINE_VISIBILITY
1686     __bind(const __bind& __b)
1687         : __f_(__b.__f_),
1688           __bound_args_(__b.__bound_args_) {}
1689
1690     _LIBCPP_INLINE_VISIBILITY
1691     __bind& operator=(const __bind& __b)
1692     {
1693         __f_ = __b.__f_;
1694         __bound_args_ = __b.__bound_args_;
1695         return *this;
1696     }
1697
1698     _LIBCPP_INLINE_VISIBILITY
1699     __bind(__bind&& __b)
1700         : __f_(_VSTD::move(__b.__f_)),
1701           __bound_args_(_VSTD::move(__b.__bound_args_)) {}
1702
1703     _LIBCPP_INLINE_VISIBILITY
1704     __bind& operator=(__bind&& __b)
1705     {
1706         __f_ = _VSTD::move(__b.__f_);
1707         __bound_args_ = _VSTD::move(__b.__bound_args_);
1708         return *this;
1709     }
1710
1711 #endif  // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
1712
1713     template <class _Gp, class ..._BA,
1714               class = typename enable_if
1715                                <
1716                                   is_constructible<_Fd, _Gp>::value
1717                                >::type>
1718       _LIBCPP_INLINE_VISIBILITY
1719       explicit __bind(_Gp&& __f, _BA&& ...__bound_args)
1720         : __f_(_VSTD::forward<_Gp>(__f)),
1721           __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {}
1722
1723     template <class ..._Args>
1724         _LIBCPP_INLINE_VISIBILITY
1725         typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type
1726         operator()(_Args&& ...__args)
1727         {
1728             return __apply_functor(__f_, __bound_args_, __indices(),
1729                                   tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
1730         }
1731
1732     template <class ..._Args>
1733         _LIBCPP_INLINE_VISIBILITY
1734         typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type
1735         operator()(_Args&& ...__args) const
1736         {
1737             return __apply_functor(__f_, __bound_args_, __indices(),
1738                                    tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
1739         }
1740 };
1741
1742 template<class _Fp, class ..._BoundArgs>
1743 struct __is_bind_expression<__bind<_Fp, _BoundArgs...> > : public true_type {};
1744
1745 template<class _Rp, class _Fp, class ..._BoundArgs>
1746 class __bind_r
1747     : public __bind<_Fp, _BoundArgs...>
1748 {
1749     typedef __bind<_Fp, _BoundArgs...> base;
1750 public:
1751     typedef _Rp result_type;
1752
1753 #ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
1754
1755     _LIBCPP_INLINE_VISIBILITY
1756     __bind_r(const __bind_r& __b)
1757         : base(_VSTD::forward<const base&>(__b)) {}
1758
1759     _LIBCPP_INLINE_VISIBILITY
1760     __bind_r& operator=(const __bind_r& __b)
1761     {
1762         base::operator=(_VSTD::forward<const base&>(__b));
1763         return *this;
1764     }
1765
1766     _LIBCPP_INLINE_VISIBILITY
1767     __bind_r(__bind_r&& __b)
1768         : base(_VSTD::forward<base>(__b)) {}
1769
1770     _LIBCPP_INLINE_VISIBILITY
1771     __bind_r& operator=(__bind_r&& __b)
1772     {
1773         base::operator=(_VSTD::forward<base>(__b));
1774         return *this;
1775     }
1776
1777 #endif  // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
1778
1779     template <class _Gp, class ..._BA>
1780       _LIBCPP_INLINE_VISIBILITY
1781       explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args)
1782         : base(_VSTD::forward<_Gp>(__f),
1783                _VSTD::forward<_BA>(__bound_args)...) {}
1784
1785     template <class ..._Args>
1786         _LIBCPP_INLINE_VISIBILITY
1787         result_type
1788         operator()(_Args&& ...__args)
1789         {
1790             return base::operator()(_VSTD::forward<_Args>(__args)...);
1791         }
1792
1793     template <class ..._Args>
1794         _LIBCPP_INLINE_VISIBILITY
1795         result_type
1796         operator()(_Args&& ...__args) const
1797         {
1798             return base::operator()(_VSTD::forward<_Args>(__args)...);
1799         }
1800 };
1801
1802 template<class _Rp, class _Fp, class ..._BoundArgs>
1803 struct __is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {};
1804
1805 template<class _Fp, class ..._BoundArgs>
1806 inline _LIBCPP_INLINE_VISIBILITY
1807 __bind<_Fp, _BoundArgs...>
1808 bind(_Fp&& __f, _BoundArgs&&... __bound_args)
1809 {
1810     typedef __bind<_Fp, _BoundArgs...> type;
1811     return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
1812 }
1813
1814 template<class _Rp, class _Fp, class ..._BoundArgs>
1815 inline _LIBCPP_INLINE_VISIBILITY
1816 __bind_r<_Rp, _Fp, _BoundArgs...>
1817 bind(_Fp&& __f, _BoundArgs&&... __bound_args)
1818 {
1819     typedef __bind_r<_Rp, _Fp, _BoundArgs...> type;
1820     return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
1821 }
1822
1823 #endif  // _LIBCPP_HAS_NO_VARIADICS
1824
1825 template <>
1826 struct _LIBCPP_VISIBLE hash<bool>
1827     : public unary_function<bool, size_t>
1828 {
1829     _LIBCPP_INLINE_VISIBILITY
1830     size_t operator()(bool __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1831 };
1832
1833 template <>
1834 struct _LIBCPP_VISIBLE hash<char>
1835     : public unary_function<char, size_t>
1836 {
1837     _LIBCPP_INLINE_VISIBILITY
1838     size_t operator()(char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1839 };
1840
1841 template <>
1842 struct _LIBCPP_VISIBLE hash<signed char>
1843     : public unary_function<signed char, size_t>
1844 {
1845     _LIBCPP_INLINE_VISIBILITY
1846     size_t operator()(signed char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1847 };
1848
1849 template <>
1850 struct _LIBCPP_VISIBLE hash<unsigned char>
1851     : public unary_function<unsigned char, size_t>
1852 {
1853     _LIBCPP_INLINE_VISIBILITY
1854     size_t operator()(unsigned char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1855 };
1856
1857 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
1858
1859 template <>
1860 struct _LIBCPP_VISIBLE hash<char16_t>
1861     : public unary_function<char16_t, size_t>
1862 {
1863     _LIBCPP_INLINE_VISIBILITY
1864     size_t operator()(char16_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1865 };
1866
1867 template <>
1868 struct _LIBCPP_VISIBLE hash<char32_t>
1869     : public unary_function<char32_t, size_t>
1870 {
1871     _LIBCPP_INLINE_VISIBILITY
1872     size_t operator()(char32_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1873 };
1874
1875 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
1876
1877 template <>
1878 struct _LIBCPP_VISIBLE hash<wchar_t>
1879     : public unary_function<wchar_t, size_t>
1880 {
1881     _LIBCPP_INLINE_VISIBILITY
1882     size_t operator()(wchar_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1883 };
1884
1885 template <>
1886 struct _LIBCPP_VISIBLE hash<short>
1887     : public unary_function<short, size_t>
1888 {
1889     _LIBCPP_INLINE_VISIBILITY
1890     size_t operator()(short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1891 };
1892
1893 template <>
1894 struct _LIBCPP_VISIBLE hash<unsigned short>
1895     : public unary_function<unsigned short, size_t>
1896 {
1897     _LIBCPP_INLINE_VISIBILITY
1898     size_t operator()(unsigned short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1899 };
1900
1901 template <>
1902 struct _LIBCPP_VISIBLE hash<int>
1903     : public unary_function<int, size_t>
1904 {
1905     _LIBCPP_INLINE_VISIBILITY
1906     size_t operator()(int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1907 };
1908
1909 template <>
1910 struct _LIBCPP_VISIBLE hash<unsigned int>
1911     : public unary_function<unsigned int, size_t>
1912 {
1913     _LIBCPP_INLINE_VISIBILITY
1914     size_t operator()(unsigned int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1915 };
1916
1917 template <>
1918 struct _LIBCPP_VISIBLE hash<long>
1919     : public unary_function<long, size_t>
1920 {
1921     _LIBCPP_INLINE_VISIBILITY
1922     size_t operator()(long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1923 };
1924
1925 template <>
1926 struct _LIBCPP_VISIBLE hash<unsigned long>
1927     : public unary_function<unsigned long, size_t>
1928 {
1929     _LIBCPP_INLINE_VISIBILITY
1930     size_t operator()(unsigned long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1931 };
1932
1933 template <>
1934 struct _LIBCPP_VISIBLE hash<long long>
1935     : public __scalar_hash<long long>
1936 {
1937 };
1938
1939 template <>
1940 struct _LIBCPP_VISIBLE hash<unsigned long long>
1941     : public __scalar_hash<unsigned long long>
1942 {
1943 };
1944
1945 template <>
1946 struct _LIBCPP_VISIBLE hash<float>
1947     : public __scalar_hash<float>
1948 {
1949     _LIBCPP_INLINE_VISIBILITY
1950     size_t operator()(float __v) const _NOEXCEPT
1951     {
1952         // -0.0 and 0.0 should return same hash
1953        if (__v == 0)
1954            return 0;
1955         return __scalar_hash<float>::operator()(__v);
1956     }
1957 };
1958
1959 template <>
1960 struct _LIBCPP_VISIBLE hash<double>
1961     : public __scalar_hash<double>
1962 {
1963     _LIBCPP_INLINE_VISIBILITY
1964     size_t operator()(double __v) const _NOEXCEPT
1965     {
1966         // -0.0 and 0.0 should return same hash
1967        if (__v == 0)
1968            return 0;
1969         return __scalar_hash<double>::operator()(__v);
1970     }
1971 };
1972
1973 template <>
1974 struct _LIBCPP_VISIBLE hash<long double>
1975     : public __scalar_hash<long double>
1976 {
1977     _LIBCPP_INLINE_VISIBILITY
1978     size_t operator()(long double __v) const _NOEXCEPT
1979     {
1980         // -0.0 and 0.0 should return same hash
1981         if (__v == 0)
1982             return 0;
1983 #if defined(__i386__)
1984         // Zero out padding bits
1985         union
1986         {
1987             long double __t;
1988             struct
1989             {
1990                 size_t __a;
1991                 size_t __b;
1992                 size_t __c;
1993                 size_t __d;
1994             };
1995         } __u;
1996         __u.__a = 0;
1997         __u.__b = 0;
1998         __u.__c = 0;
1999         __u.__d = 0;
2000         __u.__t = __v;
2001         return __u.__a ^ __u.__b ^ __u.__c ^ __u.__d;
2002 #elif defined(__x86_64__)
2003         // Zero out padding bits
2004         union
2005         {
2006             long double __t;
2007             struct
2008             {
2009                 size_t __a;
2010                 size_t __b;
2011             };
2012         } __u;
2013         __u.__a = 0;
2014         __u.__b = 0;
2015         __u.__t = __v;
2016         return __u.__a ^ __u.__b;
2017 #else
2018         return __scalar_hash<long double>::operator()(__v);
2019 #endif
2020     }
2021 };
2022
2023 // struct hash<T*> in <memory>
2024
2025 _LIBCPP_END_NAMESPACE_STD
2026
2027 #endif  // _LIBCPP_FUNCTIONAL