sdk/include/libc++/__functional/bind.h - 3p/cheriot-rtos - Git at Google


            
            // -*- C++ -*-

            
            //===----------------------------------------------------------------------===//

            
            //

            
            // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

            
            // See https://llvm.org/LICENSE.txt for license information.

            
            // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

            
            //

            
            //===----------------------------------------------------------------------===//


            #ifndef _LIBCPP___FUNCTIONAL_BIND_H

            
            #define _LIBCPP___FUNCTIONAL_BIND_H


            #include <__config>

            
            #include <__functional/weak_result_type.h>

            
            #include <__functional/invoke.h>

            
            #include <cstddef>

            
            #include <tuple>

            
            #include <type_traits>


            #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

            
            #pragma GCC system_header

            
            #endif


            _LIBCPP_BEGIN_NAMESPACE_STD


            template<class _Tp> struct __is_bind_expression : public false_type {};

            
            template<class _Tp> struct _LIBCPP_TEMPLATE_VIS is_bind_expression

            
                : public __is_bind_expression<typename remove_cv<_Tp>::type> {};


            #if _LIBCPP_STD_VER > 14

            
            template <class _Tp>

            
            _LIBCPP_INLINE_VAR constexpr size_t is_bind_expression_v = is_bind_expression<_Tp>::value;

            
            #endif


            template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {};

            
            template<class _Tp> struct _LIBCPP_TEMPLATE_VIS is_placeholder

            
                : public __is_placeholder<typename remove_cv<_Tp>::type> {};


            #if _LIBCPP_STD_VER > 14

            
            template <class _Tp>

            
            _LIBCPP_INLINE_VAR constexpr size_t is_placeholder_v = is_placeholder<_Tp>::value;

            
            #endif


            namespace placeholders

            
            {


            template <int _Np> struct __ph {};


            #if defined(_LIBCPP_CXX03_LANG) || defined(_LIBCPP_BUILDING_LIBRARY)

            
            _LIBCPP_FUNC_VIS extern const __ph<1>   _1;

            
            _LIBCPP_FUNC_VIS extern const __ph<2>   _2;

            
            _LIBCPP_FUNC_VIS extern const __ph<3>   _3;

            
            _LIBCPP_FUNC_VIS extern const __ph<4>   _4;

            
            _LIBCPP_FUNC_VIS extern const __ph<5>   _5;

            
            _LIBCPP_FUNC_VIS extern const __ph<6>   _6;

            
            _LIBCPP_FUNC_VIS extern const __ph<7>   _7;

            
            _LIBCPP_FUNC_VIS extern const __ph<8>   _8;

            
            _LIBCPP_FUNC_VIS extern const __ph<9>   _9;

            
            _LIBCPP_FUNC_VIS extern const __ph<10> _10;

            
            #else

            
            /* _LIBCPP_INLINE_VAR */ constexpr __ph<1>   _1{};

            
            /* _LIBCPP_INLINE_VAR */ constexpr __ph<2>   _2{};

            
            /* _LIBCPP_INLINE_VAR */ constexpr __ph<3>   _3{};

            
            /* _LIBCPP_INLINE_VAR */ constexpr __ph<4>   _4{};

            
            /* _LIBCPP_INLINE_VAR */ constexpr __ph<5>   _5{};

            
            /* _LIBCPP_INLINE_VAR */ constexpr __ph<6>   _6{};

            
            /* _LIBCPP_INLINE_VAR */ constexpr __ph<7>   _7{};

            
            /* _LIBCPP_INLINE_VAR */ constexpr __ph<8>   _8{};

            
            /* _LIBCPP_INLINE_VAR */ constexpr __ph<9>   _9{};

            
            /* _LIBCPP_INLINE_VAR */ constexpr __ph<10> _10{};

            
            #endif // defined(_LIBCPP_CXX03_LANG) || defined(_LIBCPP_BUILDING_LIBRARY)


            }  // placeholders


            template<int _Np>

            
            struct __is_placeholder<placeholders::__ph<_Np> >

            
                : public integral_constant<int, _Np> {};


            #ifndef _LIBCPP_CXX03_LANG


            template <class _Tp, class _Uj>

            
            inline _LIBCPP_INLINE_VISIBILITY

            
            _Tp&

            
            __mu(reference_wrapper<_Tp> __t, _Uj&)

            
            {

            
                return __t.get();

            
            }


            template <class _Ti, class ..._Uj, size_t ..._Indx>

            
            inline _LIBCPP_INLINE_VISIBILITY

            
            typename __invoke_of<_Ti&, _Uj...>::type

            
            __mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>)

            
            {

            
                return __ti(_VSTD::forward<_Uj>(_VSTD::get<_Indx>(__uj))...);

            
            }


            template <class _Ti, class ..._Uj>

            
            inline _LIBCPP_INLINE_VISIBILITY

            
            typename _EnableIf

            
            <

            
                is_bind_expression<_Ti>::value,

            
                __invoke_of<_Ti&, _Uj...>

            
            >::type

            
            __mu(_Ti& __ti, tuple<_Uj...>& __uj)

            
            {

            
                typedef typename __make_tuple_indices<sizeof...(_Uj)>::type __indices;

            
                return _VSTD::__mu_expand(__ti, __uj, __indices());

            
            }


            template <bool IsPh, class _Ti, class _Uj>

            
            struct __mu_return2 {};


            template <class _Ti, class _Uj>

            
            struct __mu_return2<true, _Ti, _Uj>

            
            {

            
                typedef typename tuple_element<is_placeholder<_Ti>::value - 1, _Uj>::type type;

            
            };


            template <class _Ti, class _Uj>

            
            inline _LIBCPP_INLINE_VISIBILITY

            
            typename enable_if

            
            <

            
                0 < is_placeholder<_Ti>::value,

            
                typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::type

            
            >::type

            
            __mu(_Ti&, _Uj& __uj)

            
            {

            
                const size_t _Indx = is_placeholder<_Ti>::value - 1;

            
                return _VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(_VSTD::get<_Indx>(__uj));

            
            }


            template <class _Ti, class _Uj>

            
            inline _LIBCPP_INLINE_VISIBILITY

            
            typename enable_if

            
            <

            
                !is_bind_expression<_Ti>::value &&

            
                is_placeholder<_Ti>::value == 0 &&

            
                !__is_reference_wrapper<_Ti>::value,

            
                _Ti&

            
            >::type

            
            __mu(_Ti& __ti, _Uj&)

            
            {

            
                return __ti;

            
            }


            template <class _Ti, bool IsReferenceWrapper, bool IsBindEx, bool IsPh,

            
                      class _TupleUj>

            
            struct __mu_return_impl;


            template <bool _Invokable, class _Ti, class ..._Uj>

            
            struct __mu_return_invokable  // false

            
            {

            
                typedef __nat type;

            
            };


            template <class _Ti, class ..._Uj>

            
            struct __mu_return_invokable<true, _Ti, _Uj...>

            
            {

            
                typedef typename __invoke_of<_Ti&, _Uj...>::type type;

            
            };


            template <class _Ti, class ..._Uj>

            
            struct __mu_return_impl<_Ti, false, true, false, tuple<_Uj...> >

            
                : public __mu_return_invokable<__invokable<_Ti&, _Uj...>::value, _Ti, _Uj...>

            
            {

            
            };


            template <class _Ti, class _TupleUj>

            
            struct __mu_return_impl<_Ti, false, false, true, _TupleUj>

            
            {

            
                typedef typename tuple_element<is_placeholder<_Ti>::value - 1,

            
                                               _TupleUj>::type&& type;

            
            };


            template <class _Ti, class _TupleUj>

            
            struct __mu_return_impl<_Ti, true, false, false, _TupleUj>

            
            {

            
                typedef typename _Ti::type& type;

            
            };


            template <class _Ti, class _TupleUj>

            
            struct __mu_return_impl<_Ti, false, false, false, _TupleUj>

            
            {

            
                typedef _Ti& type;

            
            };


            template <class _Ti, class _TupleUj>

            
            struct __mu_return

            
                : public __mu_return_impl<_Ti,

            
                                          __is_reference_wrapper<_Ti>::value,

            
                                          is_bind_expression<_Ti>::value,

            
                                          0 < is_placeholder<_Ti>::value &&

            
                                          is_placeholder<_Ti>::value <= tuple_size<_TupleUj>::value,

            
                                          _TupleUj>

            
            {

            
            };


            template <class _Fp, class _BoundArgs, class _TupleUj>

            
            struct __is_valid_bind_return

            
            {

            
                static const bool value = false;

            
            };


            template <class _Fp, class ..._BoundArgs, class _TupleUj>

            
            struct __is_valid_bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj>

            
            {

            
                static const bool value = __invokable<_Fp,

            
                                typename __mu_return<_BoundArgs, _TupleUj>::type...>::value;

            
            };


            template <class _Fp, class ..._BoundArgs, class _TupleUj>

            
            struct __is_valid_bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj>

            
            {

            
                static const bool value = __invokable<_Fp,

            
                                typename __mu_return<const _BoundArgs, _TupleUj>::type...>::value;

            
            };


            template <class _Fp, class _BoundArgs, class _TupleUj,

            
                      bool = __is_valid_bind_return<_Fp, _BoundArgs, _TupleUj>::value>

            
            struct __bind_return;


            template <class _Fp, class ..._BoundArgs, class _TupleUj>

            
            struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj, true>

            
            {

            
                typedef typename __invoke_of

            
                <

            
                    _Fp&,

            
                    typename __mu_return

            
                    <

            
                        _BoundArgs,

            
                        _TupleUj

            
                    >::type...

            
                >::type type;

            
            };


            template <class _Fp, class ..._BoundArgs, class _TupleUj>

            
            struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj, true>

            
            {

            
                typedef typename __invoke_of

            
                <

            
                    _Fp&,

            
                    typename __mu_return

            
                    <

            
                        const _BoundArgs,

            
                        _TupleUj

            
                    >::type...

            
                >::type type;

            
            };


            template <class _Fp, class _BoundArgs, size_t ..._Indx, class _Args>

            
            inline _LIBCPP_INLINE_VISIBILITY

            
            typename __bind_return<_Fp, _BoundArgs, _Args>::type

            
            __apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>,

            
                            _Args&& __args)

            
            {

            
                return _VSTD::__invoke(__f, _VSTD::__mu(_VSTD::get<_Indx>(__bound_args), __args)...);

            
            }


            template<class _Fp, class ..._BoundArgs>

            
            class __bind

            
            #if _LIBCPP_STD_VER <= 17 || !defined(_LIBCPP_ABI_NO_BINDER_BASES)

            
                : public __weak_result_type<typename decay<_Fp>::type>

            
            #endif

            
            {

            
            protected:

            
                typedef typename decay<_Fp>::type _Fd;

            
                typedef tuple<typename decay<_BoundArgs>::type...> _Td;

            
            private:

            
                _Fd __f_;

            
                _Td __bound_args_;


                typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices;

            
            public:

            
                template <class _Gp, class ..._BA,

            
                          class = typename enable_if

            
                                           <

            
                                              is_constructible<_Fd, _Gp>::value &&

            
                                              !is_same<typename remove_reference<_Gp>::type,

            
                                                       __bind>::value

            
                                           >::type>

            
                  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17

            
                  explicit __bind(_Gp&& __f, _BA&& ...__bound_args)

            
                    : __f_(_VSTD::forward<_Gp>(__f)),

            
                      __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {}


                template <class ..._Args>

            
                    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17

            
                    typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type

            
                    operator()(_Args&& ...__args)

            
                    {

            
                        return _VSTD::__apply_functor(__f_, __bound_args_, __indices(),

            
                                              tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));

            
                    }


                template <class ..._Args>

            
                    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17

            
                    typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type

            
                    operator()(_Args&& ...__args) const

            
                    {

            
                        return _VSTD::__apply_functor(__f_, __bound_args_, __indices(),

            
                                               tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));

            
                    }

            
            };


            template<class _Fp, class ..._BoundArgs>

            
            struct __is_bind_expression<__bind<_Fp, _BoundArgs...> > : public true_type {};


            template<class _Rp, class _Fp, class ..._BoundArgs>

            
            class __bind_r

            
                : public __bind<_Fp, _BoundArgs...>

            
            {

            
                typedef __bind<_Fp, _BoundArgs...> base;

            
                typedef typename base::_Fd _Fd;

            
                typedef typename base::_Td _Td;

            
            public:

            
                typedef _Rp result_type;


                template <class _Gp, class ..._BA,

            
                          class = typename enable_if

            
                                           <

            
                                              is_constructible<_Fd, _Gp>::value &&

            
                                              !is_same<typename remove_reference<_Gp>::type,

            
                                                       __bind_r>::value

            
                                           >::type>

            
                  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17

            
                  explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args)

            
                    : base(_VSTD::forward<_Gp>(__f),

            
                           _VSTD::forward<_BA>(__bound_args)...) {}


                template <class ..._Args>

            
                    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17

            
                    typename enable_if

            
                    <

            
                        is_convertible<typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type,

            
                                       result_type>::value || is_void<_Rp>::value,

            
                        result_type

            
                    >::type

            
                    operator()(_Args&& ...__args)

            
                    {

            
                        typedef __invoke_void_return_wrapper<_Rp> _Invoker;

            
                        return _Invoker::__call(static_cast<base&>(*this), _VSTD::forward<_Args>(__args)...);

            
                    }


                template <class ..._Args>

            
                    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17

            
                    typename enable_if

            
                    <

            
                        is_convertible<typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type,

            
                                       result_type>::value || is_void<_Rp>::value,

            
                        result_type

            
                    >::type

            
                    operator()(_Args&& ...__args) const

            
                    {

            
                        typedef __invoke_void_return_wrapper<_Rp> _Invoker;

            
                        return _Invoker::__call(static_cast<base const&>(*this), _VSTD::forward<_Args>(__args)...);

            
                    }

            
            };


            template<class _Rp, class _Fp, class ..._BoundArgs>

            
            struct __is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {};


            template<class _Fp, class ..._BoundArgs>

            
            inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17

            
            __bind<_Fp, _BoundArgs...>

            
            bind(_Fp&& __f, _BoundArgs&&... __bound_args)

            
            {

            
                typedef __bind<_Fp, _BoundArgs...> type;

            
                return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);

            
            }


            template<class _Rp, class _Fp, class ..._BoundArgs>

            
            inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17

            
            __bind_r<_Rp, _Fp, _BoundArgs...>

            
            bind(_Fp&& __f, _BoundArgs&&... __bound_args)

            
            {

            
                typedef __bind_r<_Rp, _Fp, _BoundArgs...> type;

            
                return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);

            
            }


            #endif // _LIBCPP_CXX03_LANG


            _LIBCPP_END_NAMESPACE_STD


            #endif // _LIBCPP___FUNCTIONAL_BIND_H
	// -- C++ --
	//===----------------------------------------------------------------------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP___FUNCTIONAL_BIND_H
	#define _LIBCPP___FUNCTIONAL_BIND_H

	#include <__config>
	#include <__functional/weak_result_type.h>
	#include <__functional/invoke.h>
	#include <cstddef>
	#include <tuple>
	#include <type_traits>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	template<class _Tp> struct __is_bind_expression : public false_type {};
	template<class _Tp> struct _LIBCPP_TEMPLATE_VIS is_bind_expression
	: public __is_bind_expression<typename remove_cv<_Tp>::type> {};

	#if _LIBCPP_STD_VER > 14
	template <class _Tp>
	_LIBCPP_INLINE_VAR constexpr size_t is_bind_expression_v = is_bind_expression<_Tp>::value;
	#endif

	template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {};
	template<class _Tp> struct _LIBCPP_TEMPLATE_VIS is_placeholder
	: public __is_placeholder<typename remove_cv<_Tp>::type> {};

	#if _LIBCPP_STD_VER > 14
	template <class _Tp>
	_LIBCPP_INLINE_VAR constexpr size_t is_placeholder_v = is_placeholder<_Tp>::value;
	#endif

	namespace placeholders
	{

	template <int _Np> struct __ph {};

	#if defined(_LIBCPP_CXX03_LANG) \|\| defined(_LIBCPP_BUILDING_LIBRARY)
	_LIBCPP_FUNC_VIS extern const __ph<1> _1;
	_LIBCPP_FUNC_VIS extern const __ph<2> _2;
	_LIBCPP_FUNC_VIS extern const __ph<3> _3;
	_LIBCPP_FUNC_VIS extern const __ph<4> _4;
	_LIBCPP_FUNC_VIS extern const __ph<5> _5;
	_LIBCPP_FUNC_VIS extern const __ph<6> _6;
	_LIBCPP_FUNC_VIS extern const __ph<7> _7;
	_LIBCPP_FUNC_VIS extern const __ph<8> _8;
	_LIBCPP_FUNC_VIS extern const __ph<9> _9;
	_LIBCPP_FUNC_VIS extern const __ph<10> _10;
	#else
	/* _LIBCPP_INLINE_VAR */ constexpr __ph<1> _1{};
	/* _LIBCPP_INLINE_VAR */ constexpr __ph<2> _2{};
	/* _LIBCPP_INLINE_VAR */ constexpr __ph<3> _3{};
	/* _LIBCPP_INLINE_VAR */ constexpr __ph<4> _4{};
	/* _LIBCPP_INLINE_VAR */ constexpr __ph<5> _5{};
	/* _LIBCPP_INLINE_VAR */ constexpr __ph<6> _6{};
	/* _LIBCPP_INLINE_VAR */ constexpr __ph<7> _7{};
	/* _LIBCPP_INLINE_VAR */ constexpr __ph<8> _8{};
	/* _LIBCPP_INLINE_VAR */ constexpr __ph<9> _9{};
	/* _LIBCPP_INLINE_VAR */ constexpr __ph<10> _10{};
	#endif // defined(_LIBCPP_CXX03_LANG) \|\| defined(_LIBCPP_BUILDING_LIBRARY)

	} // placeholders

	template<int _Np>
	struct __is_placeholder<placeholders::__ph<_Np> >
	: public integral_constant<int, _Np> {};


	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp, class _Uj>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp&
	__mu(reference_wrapper<_Tp> __t, _Uj&)
	{
	return __t.get();
	}

	template <class _Ti, class ..._Uj, size_t ..._Indx>
	inline _LIBCPP_INLINE_VISIBILITY
	typename __invoke_of<_Ti&, _Uj...>::type
	__mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>)
	{
	return __ti(_VSTD::forward<_Uj>(_VSTD::get<_Indx>(__uj))...);
	}

	template <class _Ti, class ..._Uj>
	inline _LIBCPP_INLINE_VISIBILITY
	typename _EnableIf
	<
	is_bind_expression<_Ti>::value,
	__invoke_of<_Ti&, _Uj...>
	>::type
	__mu(_Ti& __ti, tuple<_Uj...>& __uj)
	{
	typedef typename __make_tuple_indices<sizeof...(_Uj)>::type __indices;
	return _VSTD::__mu_expand(__ti, __uj, __indices());
	}

	template <bool IsPh, class _Ti, class _Uj>
	struct __mu_return2 {};

	template <class _Ti, class _Uj>
	struct __mu_return2<true, _Ti, _Uj>
	{
	typedef typename tuple_element<is_placeholder<_Ti>::value - 1, _Uj>::type type;
	};

	template <class _Ti, class _Uj>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	0 < is_placeholder<_Ti>::value,
	typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::type
	>::type
	__mu(_Ti&, _Uj& __uj)
	{
	const size_t _Indx = is_placeholder<_Ti>::value - 1;
	return _VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(_VSTD::get<_Indx>(__uj));
	}

	template <class _Ti, class _Uj>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	!is_bind_expression<_Ti>::value &&
	is_placeholder<_Ti>::value == 0 &&
	!__is_reference_wrapper<_Ti>::value,
	_Ti&
	>::type
	__mu(_Ti& __ti, _Uj&)
	{
	return __ti;
	}

	template <class _Ti, bool IsReferenceWrapper, bool IsBindEx, bool IsPh,
	class _TupleUj>
	struct __mu_return_impl;

	template <bool _Invokable, class _Ti, class ..._Uj>
	struct __mu_return_invokable // false
	{
	typedef __nat type;
	};

	template <class _Ti, class ..._Uj>
	struct __mu_return_invokable<true, _Ti, _Uj...>
	{
	typedef typename __invoke_of<_Ti&, _Uj...>::type type;
	};

	template <class _Ti, class ..._Uj>
	struct __mu_return_impl<_Ti, false, true, false, tuple<_Uj...> >
	: public __mu_return_invokable<__invokable<_Ti&, _Uj...>::value, _Ti, _Uj...>
	{
	};

	template <class _Ti, class _TupleUj>
	struct __mu_return_impl<_Ti, false, false, true, _TupleUj>
	{
	typedef typename tuple_element<is_placeholder<_Ti>::value - 1,
	_TupleUj>::type&& type;
	};

	template <class _Ti, class _TupleUj>
	struct __mu_return_impl<_Ti, true, false, false, _TupleUj>
	{
	typedef typename _Ti::type& type;
	};

	template <class _Ti, class _TupleUj>
	struct __mu_return_impl<_Ti, false, false, false, _TupleUj>
	{
	typedef _Ti& type;
	};

	template <class _Ti, class _TupleUj>
	struct __mu_return
	: public __mu_return_impl<_Ti,
	__is_reference_wrapper<_Ti>::value,
	is_bind_expression<_Ti>::value,
	0 < is_placeholder<_Ti>::value &&
	is_placeholder<_Ti>::value <= tuple_size<_TupleUj>::value,
	_TupleUj>
	{
	};

	template <class _Fp, class _BoundArgs, class _TupleUj>
	struct __is_valid_bind_return
	{
	static const bool value = false;
	};

	template <class _Fp, class ..._BoundArgs, class _TupleUj>
	struct __is_valid_bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj>
	{
	static const bool value = __invokable<_Fp,
	typename __mu_return<_BoundArgs, _TupleUj>::type...>::value;
	};

	template <class _Fp, class ..._BoundArgs, class _TupleUj>
	struct __is_valid_bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj>
	{
	static const bool value = __invokable<_Fp,
	typename __mu_return<const _BoundArgs, _TupleUj>::type...>::value;
	};

	template <class _Fp, class _BoundArgs, class _TupleUj,
	bool = __is_valid_bind_return<_Fp, _BoundArgs, _TupleUj>::value>
	struct __bind_return;

	template <class _Fp, class ..._BoundArgs, class _TupleUj>
	struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj, true>
	{
	typedef typename __invoke_of
	<
	_Fp&,
	typename __mu_return
	<
	_BoundArgs,
	_TupleUj
	>::type...
	>::type type;
	};

	template <class _Fp, class ..._BoundArgs, class _TupleUj>
	struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj, true>
	{
	typedef typename __invoke_of
	<
	_Fp&,
	typename __mu_return
	<
	const _BoundArgs,
	_TupleUj
	>::type...
	>::type type;
	};

	template <class _Fp, class _BoundArgs, size_t ..._Indx, class _Args>
	inline _LIBCPP_INLINE_VISIBILITY
	typename __bind_return<_Fp, _BoundArgs, _Args>::type
	__apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>,
	_Args&& __args)
	{
	return _VSTD::__invoke(__f, _VSTD::__mu(_VSTD::get<_Indx>(__bound_args), __args)...);
	}

	template<class _Fp, class ..._BoundArgs>
	class __bind
	#if _LIBCPP_STD_VER <= 17 \|\| !defined(_LIBCPP_ABI_NO_BINDER_BASES)
	: public __weak_result_type<typename decay<_Fp>::type>
	#endif
	{
	protected:
	typedef typename decay<_Fp>::type _Fd;
	typedef tuple<typename decay<_BoundArgs>::type...> _Td;
	private:
	_Fd __f_;
	_Td __bound_args_;

	typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices;
	public:
	template <class _Gp, class ..._BA,
	class = typename enable_if
	<
	is_constructible<_Fd, _Gp>::value &&
	!is_same<typename remove_reference<_Gp>::type,
	__bind>::value
	>::type>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	explicit __bind(_Gp&& __f, _BA&& ...__bound_args)
	: __f_(_VSTD::forward<_Gp>(__f)),
	__bound_args_(_VSTD::forward<_BA>(__bound_args)...) {}

	template <class ..._Args>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type
	operator()(_Args&& ...__args)
	{
	return _VSTD::__apply_functor(__f_, __bound_args_, __indices(),
	tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
	}

	template <class ..._Args>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type
	operator()(_Args&& ...__args) const
	{
	return _VSTD::__apply_functor(__f_, __bound_args_, __indices(),
	tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
	}
	};

	template<class _Fp, class ..._BoundArgs>
	struct __is_bind_expression<__bind<_Fp, _BoundArgs...> > : public true_type {};

	template<class _Rp, class _Fp, class ..._BoundArgs>
	class __bind_r
	: public __bind<_Fp, _BoundArgs...>
	{
	typedef __bind<_Fp, _BoundArgs...> base;
	typedef typename base::_Fd _Fd;
	typedef typename base::_Td _Td;
	public:
	typedef _Rp result_type;


	template <class _Gp, class ..._BA,
	class = typename enable_if
	<
	is_constructible<_Fd, _Gp>::value &&
	!is_same<typename remove_reference<_Gp>::type,
	__bind_r>::value
	>::type>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args)
	: base(_VSTD::forward<_Gp>(__f),
	_VSTD::forward<_BA>(__bound_args)...) {}

	template <class ..._Args>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	typename enable_if
	<
	is_convertible<typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type,
	result_type>::value \|\| is_void<_Rp>::value,
	result_type
	>::type
	operator()(_Args&& ...__args)
	{
	typedef __invoke_void_return_wrapper<_Rp> _Invoker;
	return _Invoker::__call(static_cast<base&>(*this), _VSTD::forward<_Args>(__args)...);
	}

	template <class ..._Args>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	typename enable_if
	<
	is_convertible<typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type,
	result_type>::value \|\| is_void<_Rp>::value,
	result_type
	>::type
	operator()(_Args&& ...__args) const
	{
	typedef __invoke_void_return_wrapper<_Rp> _Invoker;
	return _Invoker::__call(static_cast<base const&>(*this), _VSTD::forward<_Args>(__args)...);
	}
	};

	template<class _Rp, class _Fp, class ..._BoundArgs>
	struct __is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {};

	template<class _Fp, class ..._BoundArgs>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	__bind<_Fp, _BoundArgs...>
	bind(_Fp&& __f, _BoundArgs&&... __bound_args)
	{
	typedef __bind<_Fp, _BoundArgs...> type;
	return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
	}

	template<class _Rp, class _Fp, class ..._BoundArgs>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	__bind_r<_Rp, _Fp, _BoundArgs...>
	bind(_Fp&& __f, _BoundArgs&&... __bound_args)
	{
	typedef __bind_r<_Rp, _Fp, _BoundArgs...> type;
	return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
	}

	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP___FUNCTIONAL_BIND_H