Synopsis

namespace std {
template<class Arg, class Result>
    struct unary_function;
template<class Arg1, class Arg2, class Result>
    struct binary_function;
template<class Ty>
    struct plus;
template<class Ty>
    struct minus;
template<class Ty>
    struct multiplies;
template<class Ty>
    struct divides;
template<class Ty>
    struct modulus;
template<class Ty>
    struct negate;
template<class Ty>
    struct equal_to;
template<class Ty>
    struct not_equal_to;
template<class Ty>
    struct greater;
template<class Ty>
    struct less;
template<class Ty>
    struct greater_equal;
template<class Ty>
    struct less_equal;
template<class Ty>
    struct logical_and;
template<class Ty>
    struct logical_or;
template<class Ty>
    struct logical_not;
template<class Fn1>
    struct unary_negate;
template<class Fn2>
    struct binary_negate;
template<class Fn2>
    class binder1st;
template<class Fn2>
    class binder2nd;
template<class Arg, class Result>
    class pointer_to_unary_function;
template<class Arg1, class Arg2, class Result>
    class pointer_to_binary_function;
template<class Result, class Ty>
    struct mem_fun_t;
template<class Result, class Ty, class Arg>
    struct mem_fun1_t;
template<class Result, class Ty>
    struct const_mem_fun_t;
template<class Result, class Ty, class Arg>
    struct const_mem_fun1_t;
template<class Result, class Ty>
    struct mem_fun_ref_t;
template<class Result, class Ty, class Arg>
    struct mem_fun1_ref_t;
template<class Result, class Ty>
    struct const_mem_fun_ref_t;
template<class Result, class Ty, class Arg>
    struct const_mem_fun1_ref_t;

// TEMPLATE FUNCTIONS
template<class Fn1>
    unary_negate<Fn1> not1(const Fn1& func);
template<class Fn2>
    binary_negate<Fn2> not2(const Fn2& func);
template<class Fn2, class Ty>
    binder1st<Fn2> bind1st(const Fn2& func, const Ty& left);
template<class Fn2, class Ty>
    binder2nd<Fn2> bind2nd(const Fn2& func, const Ty& left);
template<class Arg, class Result>
    pointer_to_unary_function<Arg, Result>
        ptr_fun(Result (*)(Arg));
template<class Arg1, class Arg2, class Result>
    pointer_to_binary_function<Arg1, Arg2, Result>
        ptr_fun(Result (*)(Arg1, Arg2));
template<class Result, class Ty>
    mem_fun_t<Result, Ty> mem_fun(Result (Ty::*pm)());
template<class Result, class Ty, class Arg>
    mem_fun1_t<Result, Ty, Arg> mem_fun(Result (Ty::*pm)(Arg left));
template<class Result, class Ty>
    const_mem_fun_t<Result, Ty> mem_fun(Result (Ty::*pm)() const);
template<class Result, class Ty, class Arg>
    const_mem_fun1_t<Result, Ty, Arg> mem_fun(Result (Ty::*pm)(Arg left) const);
template<class Result, class Ty>
    mem_fun_ref_t<Result, Ty> mem_fun_ref(Result (Ty::*pm)());
template<class Result, class Ty, class Arg>
    mem_fun1_ref_t<Result, Ty, Arg>
        mem_fun_ref(Result (Ty::*pm)(Arg left));
template<class Result, class Ty>
    const_mem_fun_ref_t<Result, Ty> mem_fun_ref(Result (Ty::*pm)() const);
template<class Result, class Ty, class Arg>
    const_mem_fun1_ref_t<Result, Ty, Arg>
        mem_fun_ref(Result (Ty::*pm)(Arg left) const);

#ifdef __IBMCPP_TR1__

namespace tr1 {
// TEMPLATE STRUCT hash
template <class Ty>
        struct hash;

// REFERENCE WRAPPERS 
template <class Ty> 
    reference_wrapper<Ty>
        ref(Ty&);
template <class Ty> 
    reference_wrapper<Ty>
        ref(reference_wrapper<Ty>&);
template <class Ty> 
    reference_wrapper<const Ty>
        cref(const Ty&);
template <class Ty> 
    reference_wrapper<const Ty>
        cref(const reference_wrapper<Ty>&);
template <class Ty>
    struct reference_wrapper;

// FUNCTION OBJECT RETURN TYPES
template <class Ty>
    struct result_of;

// ENHANCED MEMBER POINTER ADAPTER
template <class Ret, class Ty>
    unspecified mem_fn(Ret Ty::*);

// FUNCTION OBJECT WRAPPERS
class bad_function_call;
template<class Fty>
    class function;
template<class Fty>
    void swap(function<Fty>& f1,
        function<Fty>& f2);
template<class Fty>
    bool operator!=(const function<Fty>&,
        null_ptr_type);
template<class Fty>
    bool operator!=(null_ptr_type,
        const function<Fty>&);
template<class Fty>
    bool operator==(const function<Fty>&,
        null_ptr_type);
template<class Fty>
    bool operator==(null_ptr_type,
        const function<Fty>&);

// ENHANCED BINDERS
template <class Fty, class T1, class T2, ..., class TN>
    unspecified bind(Fty, T1, T2, ..., TN);
template <class Ret, class Fty, class T1, class T2, ..., class TN>
    unspecified bind(Fty, T1, T2, ..., TN);
template <class Ret, class Ty, class T1, class T2, ..., class TN>
    unspecified bind(Ret Ty::*, T1, T2, ..., TN);

template <class Ty>
    struct is_bind_expression;
template <class Ty>
    struct is_placeholder;

namespace placeholders {
    extern unspecified _1;  // _2, _3, ... _M
        } // namespace placeholders
    } //namespace tr1
} //namespace std

#endif /* def __IBMCPP_TR1__ */