# define _LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR
# define _LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS
# define _LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE
+# define _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
#endif // _LIBCPP_ENABLE_CXX17_REMOVED_FEATURES
#if !defined(__cpp_deduction_guides) || __cpp_deduction_guides < 201611
}
template <class Operation>
-class binder1st
+class binder1st // deprecated in C++11, removed in C++17
: public unary_function<typename Operation::second_argument_type,
typename Operation::result_type>
{
};
template <class Operation, class T>
-binder1st<Operation> bind1st(const Operation& op, const T& x);
+binder1st<Operation> bind1st(const Operation& op, const T& x); // deprecated in C++11, removed in C++17
template <class Operation>
-class binder2nd
+class binder2nd // deprecated in C++11, removed in C++17
: public unary_function<typename Operation::first_argument_type,
typename Operation::result_type>
{
};
template <class Operation, class T>
-binder2nd<Operation> bind2nd(const Operation& op, const T& x);
+binder2nd<Operation> bind2nd(const Operation& op, const T& x); // deprecated in C++11, removed in C++17
-template <class Arg, class Result>
+template <class Arg, class Result> // deprecated in C++11, removed in C++17
class pointer_to_unary_function : public unary_function<Arg, Result>
{
public:
};
template <class Arg, class Result>
-pointer_to_unary_function<Arg,Result> ptr_fun(Result (*f)(Arg));
+pointer_to_unary_function<Arg,Result> ptr_fun(Result (*f)(Arg)); // deprecated in C++11, removed in C++17
-template <class Arg1, class Arg2, class Result>
+template <class Arg1, class Arg2, class Result> // deprecated in C++11, removed in C++17
class pointer_to_binary_function : public binary_function<Arg1, Arg2, Result>
{
public:
};
template <class Arg1, class Arg2, class Result>
-pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*f)(Arg1,Arg2));
+pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*f)(Arg1,Arg2)); // deprecated in C++11, removed in C++17
-template<class S, class T>
+template<class S, class T> // deprecated in C++11, removed in C++17
class mem_fun_t : public unary_function<T*, S>
{
public:
};
template<class S, class T, class A>
-class mem_fun1_t : public binary_function<T*, A, S>
+class mem_fun1_t : public binary_function<T*, A, S> // deprecated in C++11, removed in C++17
{
public:
explicit mem_fun1_t(S (T::*p)(A));
S operator()(T* p, A x) const;
};
-template<class S, class T> mem_fun_t<S,T> mem_fun(S (T::*f)());
-template<class S, class T, class A> mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A));
+template<class S, class T> mem_fun_t<S,T> mem_fun(S (T::*f)()); // deprecated in C++11, removed in C++17
+template<class S, class T, class A> mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A)); // deprecated in C++11, removed in C++17
template<class S, class T>
-class mem_fun_ref_t : public unary_function<T, S>
+class mem_fun_ref_t : public unary_function<T, S> // deprecated in C++11, removed in C++17
{
public:
explicit mem_fun_ref_t(S (T::*p)());
};
template<class S, class T, class A>
-class mem_fun1_ref_t : public binary_function<T, A, S>
+class mem_fun1_ref_t : public binary_function<T, A, S> // deprecated in C++11, removed in C++17
{
public:
explicit mem_fun1_ref_t(S (T::*p)(A));
S operator()(T& p, A x) const;
};
-template<class S, class T> mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)());
-template<class S, class T, class A> mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A));
+template<class S, class T> mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)()); // deprecated in C++11, removed in C++17
+template<class S, class T, class A> mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A)); // deprecated in C++11, removed in C++17
template <class S, class T>
-class const_mem_fun_t : public unary_function<const T*, S>
+class const_mem_fun_t : public unary_function<const T*, S> // deprecated in C++11, removed in C++17
{
public:
explicit const_mem_fun_t(S (T::*p)() const);
};
template <class S, class T, class A>
-class const_mem_fun1_t : public binary_function<const T*, A, S>
+class const_mem_fun1_t : public binary_function<const T*, A, S> // deprecated in C++11, removed in C++17
{
public:
explicit const_mem_fun1_t(S (T::*p)(A) const);
S operator()(const T* p, A x) const;
};
-template <class S, class T> const_mem_fun_t<S,T> mem_fun(S (T::*f)() const);
-template <class S, class T, class A> const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const);
+template <class S, class T> const_mem_fun_t<S,T> mem_fun(S (T::*f)() const); // deprecated in C++11, removed in C++17
+template <class S, class T, class A> const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const); // deprecated in C++11, removed in C++17
template <class S, class T>
-class const_mem_fun_ref_t : public unary_function<T, S>
+class const_mem_fun_ref_t : public unary_function<T, S> // deprecated in C++11, removed in C++17
{
public:
explicit const_mem_fun_ref_t(S (T::*p)() const);
};
template <class S, class T, class A>
-class const_mem_fun1_ref_t : public binary_function<T, A, S>
+class const_mem_fun1_ref_t : public binary_function<T, A, S> // deprecated in C++11, removed in C++17
{
public:
explicit const_mem_fun1_ref_t(S (T::*p)(A) const);
S operator()(const T& p, A x) const;
};
-template <class S, class T> const_mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)() const);
-template <class S, class T, class A> const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const);
+template <class S, class T> const_mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)() const); // deprecated in C++11, removed in C++17
+template <class S, class T, class A> const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const); // deprecated in C++11, removed in C++17
template<class R, class T> unspecified mem_fn(R T::*);
binary_negate<_Predicate>
not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);}
+#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
template <class __Operation>
class _LIBCPP_TEMPLATE_VIS binder1st
: public unary_function<typename __Operation::second_argument_type,
const_mem_fun1_ref_t<_Sp,_Tp,_Ap>
mem_fun_ref(_Sp (_Tp::*__f)(_Ap) const)
{return const_mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}
+#endif
////////////////////////////////////////////////////////////////////////////////
// MEMFUN
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+
+// In C++17, the function adapters mem_fun/mem_fun_ref, etc have been removed.
+// However, for backwards compatibility, if _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
+// is defined before including <functional>, then they will be restored.
+
+#define _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
+
+#include <functional>
+#include <cassert>
+
+int identity(int v) { return v; }
+int sum(int a, int b) { return a + b; }
+
+struct Foo {
+ int zero() const { return 0; }
+ int identity(int v) const { return v; }
+ int sum(int a, int b) const { return a + b; }
+};
+
+int main()
+{
+ typedef std::pointer_to_unary_function<int, int> PUF;
+ typedef std::pointer_to_binary_function<int, int, int> PBF;
+ assert((std::ptr_fun<int, int>(identity)(4) == 4));
+ assert((std::ptr_fun<int, int, int>(sum)(4, 5) == 9));
+
+ Foo f;
+ assert((std::mem_fn(&Foo::identity)(f, 5) == 5));
+ assert((std::mem_fn(&Foo::sum)(f, 5, 6) == 11));
+
+ typedef std::mem_fun_ref_t<int, Foo> MFR;
+ typedef std::const_mem_fun_ref_t<int, Foo> CMFR;
+
+ assert((std::mem_fun_ref(&Foo::zero)(f) == 0));
+ assert((std::mem_fun_ref(&Foo::identity)(f, 5) == 5));
+}
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+// pointer_to_binary_function
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <functional>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+double binary_f(int i, short j) {return i - j + .75;}
+
+int main()
+{
+ typedef std::pointer_to_binary_function<int, short, double> F;
+}
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// pointer_to_binary_function
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+// pointer_to_unary_function
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <functional>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+double unary_f(int i) {return 0.5 - i;}
+
+int main()
+{
+ typedef std::pointer_to_unary_function<int, double> F;
+}
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// pointer_to_unary_function
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// template <CopyConstructible Arg, Returnable Result>
+// pointer_to_unary_function<Arg, Result>
+// ptr_fun(Result (*f)(Arg));
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <functional>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+double unary_f(int i) {return 0.5 - i;}
+
+int main()
+{
+ assert(std::ptr_fun(unary_f)(36) == -35.5);
+}
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// template <CopyConstructible Arg, Returnable Result>
// pointer_to_unary_function<Arg, Result>
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// template <CopyConstructible Arg1, CopyConstructible Arg2, Returnable Result>
+// pointer_to_binary_function<Arg1,Arg2,Result>
+// ptr_fun(Result (*f)(Arg1, Arg2));
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <functional>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+double binary_f(int i, short j) {return i - j + .75;}
+
+int main()
+{
+ assert(std::ptr_fun(binary_f)(36, 27) == 9.75);
+}
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// template <CopyConstructible Arg1, CopyConstructible Arg2, Returnable Result>
// pointer_to_binary_function<Arg1,Arg2,Result>
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// template<cReturnable S, ClassType T>
+// const_mem_fun_t<S,T>
+// mem_fun(S (T::*f)() const);
+// Removed in c++1z
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <functional>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct A
+{
+ char a1() {return 5;}
+ short a2(int i) {return short(i+1);}
+ int a3() const {return 1;}
+ double a4(unsigned i) const {return i-1;}
+};
+
+int main()
+{
+ const A a = A();
+ assert(std::mem_fun(&A::a3)(&a) == 1);
+}
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// template<cReturnable S, ClassType T>
// const_mem_fun_t<S,T>
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// template<Returnable S, ClassType T, CopyConstructible A>
+// const_mem_fun1_t<S,T,A>
+// mem_fun(S (T::*f)(A) const);
+// Removed in c++1z
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <functional>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct A
+{
+ char a1() {return 5;}
+ short a2(int i) {return short(i+1);}
+ int a3() const {return 1;}
+ double a4(unsigned i) const {return i-1;}
+};
+
+int main()
+{
+ const A a = A();
+ assert(std::mem_fun(&A::a4)(&a, 6) == 5);
+}
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// template<Returnable S, ClassType T, CopyConstructible A>
// const_mem_fun1_t<S,T,A>
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// const_mem_fun1_ref_t
+// Removed in c++1z
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <functional>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct A
+{
+ char a1() {return 5;}
+ short a2(int i) {return short(i+1);}
+ int a3() const {return 1;}
+ double a4(unsigned i) const {return i-1;}
+};
+
+int main()
+{
+ typedef std::const_mem_fun1_ref_t<double, A, unsigned> F;
+}
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// const_mem_fun1_ref_t
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// const_mem_fun1_t
+// Removed in c++1z
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <functional>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct A
+{
+ char a1() {return 5;}
+ short a2(int i) {return short(i+1);}
+ int a3() const {return 1;}
+ double a4(unsigned i) const {return i-1;}
+};
+
+int main()
+{
+ typedef std::const_mem_fun1_t<double, A, unsigned> F;
+}
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// const_mem_fun1_t
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// template<Returnable S, ClassType T>
+// const_mem_fun_ref_t<S,T>
+// mem_fun_ref(S (T::*f)() const);
+// Removed in c++1z
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <functional>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct A
+{
+ char a1() {return 5;}
+ short a2(int i) {return short(i+1);}
+ int a3() const {return 1;}
+ double a4(unsigned i) const {return i-1;}
+};
+
+int main()
+{
+ const A a = A();
+ assert(std::mem_fun_ref(&A::a3)(a) == 1);
+}
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// template<Returnable S, ClassType T>
// const_mem_fun_ref_t<S,T>
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// template<Returnable S, ClassType T, CopyConstructible A>
+// const_mem_fun1_ref_t<S,T,A>
+// mem_fun_ref(S (T::*f)(A) const);
+// Removed in c++1z
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <functional>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct A
+{
+ char a1() {return 5;}
+ short a2(int i) {return short(i+1);}
+ int a3() const {return 1;}
+ double a4(unsigned i) const {return i-1;}
+};
+
+int main()
+{
+ const A a = A();
+ assert(std::mem_fun_ref(&A::a4)(a, 6) == 5);
+}
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// template<Returnable S, ClassType T, CopyConstructible A>
// const_mem_fun1_ref_t<S,T,A>
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// const_mem_fun_ref_t
+// Removed in c++1z
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <functional>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct A
+{
+ char a1() {return 5;}
+ short a2(int i) {return short(i+1);}
+ int a3() const {return 1;}
+ double a4(unsigned i) const {return i-1;}
+};
+
+int main()
+{
+ typedef std::const_mem_fun_ref_t<int, A> F;
+}
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// const_mem_fun_ref_t
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// const_mem_fun_t
+// Removed in c++1z
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <functional>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct A
+{
+ char a1() {return 5;}
+ short a2(int i) {return short(i+1);}
+ int a3() const {return 1;}
+ double a4(unsigned i) const {return i-1;}
+};
+
+int main()
+{
+ typedef std::const_mem_fun_t<int, A> F;
+}
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// const_mem_fun_t
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// template<Returnable S, ClassType T>
+// mem_fun_t<S,T>
+// mem_fun(S (T::*f)());
+// Removed in c++1z
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <functional>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct A
+{
+ char a1() {return 5;}
+ short a2(int i) {return short(i+1);}
+ int a3() const {return 1;}
+ double a4(unsigned i) const {return i-1;}
+};
+
+int main()
+{
+ A a;
+ assert(std::mem_fun(&A::a1)(&a) == 5);
+}
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// template<Returnable S, ClassType T>
// mem_fun_t<S,T>
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// template<Returnable S, ClassType T, CopyConstructible A>
+// mem_fun1_t<S,T,A>
+// mem_fun(S (T::*f)(A));
+// Removed in c++1z
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <functional>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct A
+{
+ char a1() {return 5;}
+ short a2(int i) {return short(i+1);}
+ int a3() const {return 1;}
+ double a4(unsigned i) const {return i-1;}
+};
+
+int main()
+{
+ A a;
+ assert(std::mem_fun(&A::a2)(&a, 5) == 6);
+}
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// template<Returnable S, ClassType T, CopyConstructible A>
// mem_fun1_t<S,T,A>
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// mem_fun1_ref_t
+// Removed in c++1z
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <functional>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct A
+{
+ char a1() {return 5;}
+ short a2(int i) {return short(i+1);}
+ int a3() const {return 1;}
+ double a4(unsigned i) const {return i-1;}
+};
+
+int main()
+{
+ typedef std::mem_fun1_ref_t<short, A, int> F;
+}
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// mem_fun1_ref_t
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// mem_fun1_t
+// Removed in c++1z
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <functional>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct A
+{
+ char a1() {return 5;}
+ short a2(int i) {return short(i+1);}
+ int a3() const {return 1;}
+ double a4(unsigned i) const {return i-1;}
+};
+
+int main()
+{
+ typedef std::mem_fun1_t<short, A, int> F;
+}
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// mem_fun1_t
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// template<Returnable S, ClassType T>
+// mem_fun_ref_t<S,T>
+// mem_fun_ref(S (T::*f)());
+// Removed in c++1z
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <functional>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct A
+{
+ char a1() {return 5;}
+ short a2(int i) {return short(i+1);}
+ int a3() const {return 1;}
+ double a4(unsigned i) const {return i-1;}
+};
+
+int main()
+{
+ A a;
+ assert(std::mem_fun_ref(&A::a1)(a) == 5);
+}
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// template<Returnable S, ClassType T>
// mem_fun_ref_t<S,T>
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// template<Returnable S, ClassType T, CopyConstructible A>
+// mem_fun1_ref_t<S,T,A>
+// mem_fun_ref(S (T::*f)(A));
+// Removed in c++1z
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <functional>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct A
+{
+ char a1() {return 5;}
+ short a2(int i) {return short(i+1);}
+ int a3() const {return 1;}
+ double a4(unsigned i) const {return i-1;}
+};
+
+int main()
+{
+ A a;
+ assert(std::mem_fun_ref(&A::a2)(a, 5) == 6);
+}
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// template<Returnable S, ClassType T, CopyConstructible A>
// mem_fun1_ref_t<S,T,A>
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// mem_fun_ref_t
+// Removed in c++1z
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <functional>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct A
+{
+ char a1() {return 5;}
+ short a2(int i) {return short(i+1);}
+ int a3() const {return 1;}
+ double a4(unsigned i) const {return i-1;}
+};
+
+int main()
+{
+ typedef std::mem_fun_ref_t<char, A> F;
+}
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// mem_fun_ref_t
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// mem_fun_t
+// Removed in c++1z
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <functional>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct A
+{
+ char a1() {return 5;}
+ short a2(int i) {return short(i+1);}
+ int a3() const {return 1;}
+ double a4(unsigned i) const {return i-1;}
+};
+
+int main()
+{
+ typedef std::mem_fun_t<char, A> F;
+}
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// mem_fun_t
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// template <class Fn, class T>
// binder1st<Fn>
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// template <class Fn, class T>
// binder2nd<Fn>
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// template <class Fn>
// class binder1st
//===----------------------------------------------------------------------===//
// <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
// template <class Fn>
// class binder2nd