Any expression can be explicitly converted to type cv void (5.4). An expression of type void shall be used only as an expression statement (6.2), as an operand of a comma expression (5.18), as a second or third operand of ?: (5.16), as the operand of typeid, or as the expression in a return statement (6.6.3) for a function with the return type void.

template <class Fn, class... Types>
    auto fwd(Fn fn, Types &&... args) ->
        decltype(fn(std::forward<Types>(args)...))
{
    return fn(std::forward<Types>(args)...);
}

An id-expression that denotes a non-static data member or non-static member function of a class can only be used
[...]
— if that id-expression denotes a non-static data member and it appears in an unevaluated operand.
[ Example:

struct S {
  int m;
};
int i = sizeof(S::m);      // OK
int j = sizeof(S::m + 42); // OK

struct B
{
    int m;
};

struct D : B
{
    void f()
    {
        int size = sizeof B::m; // OK
    }
};

struct X
{
    static void f()
    {
        int size = sizeof B::m; // OK
    }
    void g()
    {
        int size = sizeof B::m; // ill-formed
    }
};

When an id-expression (5.1) that is not part of a class member access syntax (5.2.5) and not used to form a pointer to member (5.3.1) is used in the body of a non-static member function of class X, if name lookup (3.4.1) resolves the name in the id-expression to a non-static non-type member of some class C, the id-expression is transformed into a class member access expression (5.2.5) using (*this) (9.3.2) as the postfix-expression to the left of the . operator. [ Note: if C is not X or a base class of X, the class member access expression is ill-formed. —end note ]

struct X
{
    static int const value = 1;
};

template <class T>
    void f(T const &) { /*....*/ }
    
int main()
{
    f(X::value);
}

struct X
{
    static int const value = 1;
};

void f(int) { /*....*/ }
    
int main()
{
    f(X::value);
}

template <class T>
    struct is_pointer_impl : false_type {};
template <class T>
    struct is_pointer_impl<T *> : true_type {};
template <class T>
    struct is_pointer_impl<T *const> : true_type {};
template <class T>
    struct is_pointer_impl<T *volatile> : true_type {};
template <class T>
    struct is_pointer_impl<T *const volatile> : true_type {};
template <class T>
    constexpr bool is_pointer()
        { return is_pointer_impl<T>::value; }

template <bool b, class T = void>
    struct enable_if_impl;
template <class T>
    struct enable_if_impl<true, T>
        { typedef T type; };
template <bool b, class T = void>
    using enable_if = typename enable_if_impl<b, T>::type;

template <class T>
    enable_if<is_pointer<T>()> f(T);

template <class T>
    typename enable_if<is_pointer<T>::value>::type f(T);