I need help creating a function type declaration based on variadic template class parameters

I would like to create a function type declaration within a variadic template class. The function needs to take parameters corresponding to the template parameter list. I'm trying to figure out if there is a way to constrain all but the last parameter, in the function parameter list, to be const references. The last function parameter needs to be a non-const reference.

Below is some code which hopefully demonstrates the challenge I'm trying to overcome. I have chosen SomeClass<int, int, double> to use in this simple example, but both the template types and number of template arguments will change...

#include <iostream>

template<typename First, typename ...Rest>
struct SomeClass
{
  using Fn = void (*)(First&, Rest&...);
  using FnConst = void (*)(const First&, const Rest&...);
  //using FnLastNonConst = HELP;
};

int main()
{
  std::cout << typeid(SomeClass<int, int, double>::Fn).name() << std::endl;
  std::cout << typeid(SomeClass<int, int, double>::FnConst).name() << std::endl;
  return 0;
}

Here is the generate output, when piped through c++filt -t...

void (*)(int&, int&, double&)
void (*)(int const&, int const&, double const&)

I'm trying to figure out how to define FnLastNonConst such that it would generate...

void (*)(int const&, int const&, double&)

I have attempted numerous recursive solutions involving std::conditional and helper classes, but I can't figure out how to bring that together into the top-most function type declaration. I've reached my limits and I'm starting to think this might not be possible. Any insight would be much appreciated.

You might need to adjust the boilerplate to make it perfectly suit your needs (the cumbersome part, I know) but as for the basic skeleton it can look more-less like this:

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

namespace detail
{

    template<typename Tuple, std::size_t ...IDX>
    constexpr auto repack_tuple_in_cref(const Tuple t, std::index_sequence<IDX...>)
    -> decltype(std::tie(std::get<IDX>(t)...));

    template<typename Last, typename ...Args>
    constexpr auto add_tuple_tail_ref(Last&&,  std::tuple<Args...>)
    -> std::tuple<Args..., Last&>;

    template<typename ...Args>
    constexpr auto void_func_ptr_with_args(std::tuple<Args...>)
    -> void (*)(Args...);
}

template<typename ...Args>
constexpr auto func_with_last_non_const()
{
    using ValT = std::tuple<Args...>;
    using Last = std::tuple_element_t<std::tuple_size_v<ValT>-1, ValT>;
    using ConstRefAddedT = decltype(
        detail::repack_tuple_in_cref(
            std::declval<ValT>(),
            std::make_index_sequence<std::tuple_size_v<ValT>-1>{}));
    using LastNonConstRefT = decltype(
        detail::add_tuple_tail_ref(
            std::declval<Last>(), std::declval<ConstRefAddedT>())
    );

    using FptrT = decltype(detail::void_func_ptr_with_args(
        std::declval<LastNonConstRefT>()));

    return FptrT{};
}


template <typename First, typename ...Args>
struct S
{
    using Fn = decltype(func_with_last_non_const<First, Args...>());
};




int main(int, char const*[])
{
    using F = typename S<int, char, double>::Fn;

    static_assert(
      std::is_same_v<
        F,
        void (*)(const int&, const char&, double&)>,
    "");
    return 0;
};

https://godbolt.org/z/zEnGxea37

The principle behind it is quite straightforward once broken down into separate steps: put all the the types is a tuple, add the consts/refs/whatever to the types needed, put it together into a tuple again and unpack its inner types into a function pointer params in the end.
Also I've assumed you are using C++17 or newer, I'm not sure if that code compiles on earlier versions of the language.

There is one more approach to achieve this other than the approach suggested by @alagner, but this might not be the best way to achieve the solution.

One can declare one more function template type as follows

template<typename OneMoreFirst, typename ...OneMoreRest>
using FnCustom = void (*) (OneMoreFirst&, OneMoreRest&...);

Usage:

typeid(SomeClass<int, int, double>::FnCustom<const int, const int, double>).name()

And pass the types with const-ness and non-const-ness as needed.

For complete example please refer to: https://godbolt.org/z/v778hG31e

Thanks

Using extra layer seems required, for example:

template<typename Tuple, typename Seq>
struct Helper;
template<typename... Ts, std::size_t... Is>
struct Helper<std::tuple<Ts...>, std::index_sequence<Is...>>
{
using type = void (*) (std::conditional_t<(1 + Is) == sizeof...(Is), Ts&, const Ts&>...);
};
template<typename ...Ts>
struct SomeClass
{
using Fn = void (*)(Ts&...);
using FnConst = void (*)(const Ts&...);
using FnLastNonConst = typename Helper<std::tuple<Ts...>, std::index_sequence_for<Ts...>>::type;
};

Demo