On Sun, Mar 2, 2025 at 4:10 AM Thiago Macieira wrote:
>
> On Saturday, 1 March 2025, Frederick Virchanza Gotham wrote:
> >
> > The class 'function_defargs" is writeable in current C++ except for
> > needing compiler support to garner the default arguments from the
> > declaration of the assigned-from function.
>
> Have you tried checking if this is in the plans for reflection?



Do you mean that we would write "std::function_defargs" something like
as follows if we could use reflection?

        https://godbolt.org/z/K7hvxxf4c

And here's the entire GodBolt copy-pasted:

#include <cstddef>
#include <tuple>
#include <type_traits>
#include <utility>

namespace std {

    // The following 'Reflection' namespace is make-believe
    // to provide a way of getting the default arguments
    // from a function declaration.
    namespace Reflection {
        template<typename... Ts>
        consteval bool HasDefaultArgument(Ts...) { return true; } //
just make-believe

        template<typename R, typename... Ts>
        consteval R GetDefaultArgument(Ts...) { return {}; } // just
make-believe
    }

    // First we need some helper templates to
    // get information about function pointers
    template<typename T>
    struct is_func_ptr : false_type {};

    template<typename R, typename... Params>
    struct is_func_ptr< R(*)(Params...) > : true_type {};

    template<typename T>
    struct func_ptr_args_tuple;

    template<typename R, typename... Params>
    struct func_ptr_args_tuple< R(*)(Params...) > {
        using type = tuple<Params...>;
    };

    template<typename T> requires is_func_ptr< remove_cvref_t<T> >::value
    class function_defargs {
        using FuncPtr = remove_cvref_t<T>;
        typename func_ptr_args_tuple<FuncPtr>::type func_args;
    public:
        template<typename FuncPtrParam> requires is_func_ptr<
remove_cvref_t<FuncPtrParam> >::value
        consteval function_defargs(FuncPtrParam arg)
        {
            using FuncPtr = remove_cvref_t<FuncPtrParam>;
            using FuncArgsTuple = func_ptr_args_tuple<FuncPtr>::type;
            constructor_proper( arg, FuncArgsTuple(),
make_index_sequence< tuple_size_v<FuncArgsTuple> >() );
        }
    private:
        template<typename FuncPtrParam, typename... Ts, size_t... I>
        consteval void constructor_proper(FuncPtrParam fptr,
tuple<Ts...> &&tup, index_sequence<I...>)
        {
            constexpr auto mylambda =
                []<size_t I2, typename Tuple>(Tuple &&tup2,
function_defargs<T> *const this2, FuncPtrParam fptr2)
                {
                    if ( false ==
Reflection::HasDefaultArgument(fptr2, I2) ) return;
                    using ArgType = tuple_element_t<I2,Tuple>;
                    get<I2>(this2->func_args) =
Reflection::GetDefaultArgument<ArgType>(fptr2, I2);
                };

            ( mylambda.template operator()<I>( move(tup), this, fptr ), ... );
        }
    };

    template <typename FuncPtrParam>
    function_defargs(FuncPtrParam&&) -> function_defargs<
remove_cvref_t<FuncPtrParam> >;

} // close namespace std

int SomeFunc(int a, int b = 4, int c = 5)
{
    return a + b + c;
}

int main(void)
{
    std::function_defargs f(&SomeFunc);
}