NOT AN ISSUE - alternative implementation

[pfeatherstone]

It would seem that this does the trick for C++11 onward:

        template< typename F, typename ... Args >
        auto INVOKE(F&& fn, Args&& ... args)
        -> typename std::enable_if<
                std::is_member_pointer<typename std::decay<F>::type>::value,
                decltype(std::mem_fn(fn)(std::forward<Args>(args)...))>::type
        {
            return std::mem_fn(fn)(std::forward<Args>(args)...) ;
        }

        template< typename F, typename ... Args >
        auto INVOKE(F&& fn, Args&& ... args)
        -> typename std::enable_if<
                not std::is_member_pointer<typename std::decay<F>::type>::value,
                decltype(std::forward<F>(fn)(std::forward<Args>(args)...))>::type
        {
            return std::forward<F>(fn)(std::forward<Args>(args)...);
        }

[pfeatherstone]

Rather than:

template< typename T > struct is_reference_wrapper : std::false_type {};
template< typename U > struct is_reference_wrapper<std::reference_wrapper<U>> : std::true_type {};

template <typename Base, typename T, typename Derived, typename... Args>
auto INVOKE( T Base::*pmf, Derived && ref, Args &&... args )
    -> typename std::enable_if<
        std::is_function<T>::value
        && std::is_base_of<Base, typename std::decay<Derived>::type>::value
        , decltype((std::forward<Derived>(ref).*pmf)(std::forward<Args>(args)...))>::type
{
    return (std::forward<Derived>(ref).*pmf)(std::forward<Args>(args)...);
}

template< typename Base, typename T, typename RefWrap, typename... Args >
auto INVOKE( T Base::*pmf, RefWrap && ref, Args &&... args )
    -> typename std::enable_if<
        std::is_function<T>::value
        && is_reference_wrapper<typename std::decay<RefWrap>::type>::value
        , decltype((ref.get().*pmf)(std::forward<Args>(args)...))>::type
{
    return (ref.get().*pmf)(std::forward<Args>(args)...);
}

template< typename Base, typename T, typename Ptr, typename... Args>
auto INVOKE( T Base::*pmf, Ptr && ptr, Args &&... args )
    -> typename std::enable_if<
        std::is_function<T>::value
        && !is_reference_wrapper<typename std::decay<Ptr>::type>::value
        && !std::is_base_of<Base, typename std::decay<Ptr>::type>::value
        , decltype(((*std::forward<Ptr>(ptr)).*pmf)(std::forward<Args>(args)...))>::type
{
    return ((*std::forward<Ptr>(ptr)).*pmf)( std::forward<Args>( args )...);
}

template< typename Base, typename T, typename Derived>
auto INVOKE( T Base::*pmd, Derived && ref )
    -> typename std::enable_if<
        !std::is_function<T>::value
        && std::is_base_of<Base, typename std::decay<Derived>::type>::value
        , decltype(std::forward<Derived>(ref).*pmd)>::type
{
    return std::forward<Derived>(ref).*pmd;
}

template< typename Base, typename T, typename RefWrap>
auto INVOKE( T Base::*pmd, RefWrap && ref )
    -> typename std::enable_if<
        !std::is_function<T>::value
        && is_reference_wrapper<typename std::decay<RefWrap>::type>::value
        , decltype(ref.get().*pmd)>::type
{
    return std::forward<RefWrap>(ref.get()).*pmd;
}

template< typename Base, typename T, typename Ptr>
auto INVOKE( T Base::*pmd, Ptr && ptr )
    -> typename std::enable_if<
        !std::is_function<T>::value
        && !is_reference_wrapper<typename std::decay<Ptr>::type>::value
        && !std::is_base_of<Base, typename std::decay<Ptr>::type>::value
        , decltype((*std::forward<Ptr>(ptr)).*pmd)>::type
{
    return (*std::forward<Ptr>(ptr)).*pmd;
}

template< typename F, typename... Args>
auto INVOKE( F && f, Args &&... args )
 -> typename std::enable_if<
    !std::is_member_pointer<typename std::decay<F>::type>::value
    , decltype(std::forward<F>(f)(std::forward<Args>(args)...))>::type
{
    return std::forward<F>( f )( std::forward<Args>( args )...);
}

[pfeatherstone]

I've put both implementations in compiler explorer, turned optimizations to -O2, and you get exactly the same assembly. So i think you get the same level of inlining

[pfeatherstone]

Anybody have any opinions on this? I am interested in people's thoughts.

[martinmoene]

Thanks for your input!

I've not many memories why it looks the way it is...

I'll take a look, and see how it fares with various compilers.

Your code is attractively concise :)

[pfeatherstone]

Maybe we could build some unit tests for this project and benchmark at the same time. Is it easy to pinch the test cases from libc++ and boost ?

[martinmoene]

The project still needs some work, such as:

• Add Readme
• Add tests
• Add better standard detection as in other lite projects
• Add configuration, to specify standard, to select between std::invoke and nonstd::invoke
• Add Packaging, CMake, Conan
• ...

Have to see when I can spend some time on it.