template<typename It, std::enable_if_t<is_const_iterator_of_v<It, char>, int> = 0>
    constexpr It CalcSomething(It str, It last) noexcept;
    template<typename It, std::enable_if_t<is_const_iterator_of_v<It, char16_t>
        || (is_const_iterator_of_v<It, wchar_t> && sizeof(wchar_t) == sizeof(char16_t)), int> = 0>
    constexpr It CalcSomething(It str, It last) noexcept;
    template<typename It, std::enable_if_t<is_const_iterator_of_v<It, char32_t>
        || (is_const_iterator_of_v<It, wchar_t> && sizeof(wchar_t) == sizeof(char32_t)), int> = 0>
    constexpr It CalcSomething(It str, It last) noexcept;

#include <type_traits>
#include <utility>
#include <numeric>
#include <boost/iterator_adaptors.hpp>

/////////0/////////1/////////2/////////3/////////4/////////5/////////6/////////7
template <class SrcIter, class DstValue>
class IterAdaptor
  : public boost::iterator_adaptor<
        IterAdaptor<SrcIter, DstValue>      // Derived
      , SrcIter                             // Base
      , DstValue                            // Value
    >
{
 public:
    explicit IterAdaptor(const IterAdaptor::iterator_adaptor_::base_type& p)
      : IterAdaptor::iterator_adaptor_(p) {}

    DstValue& dereference() const
    {
        DstValue *ptr = reinterpret_cast<DstValue *>(&*this->base_reference());
        return *ptr;
    }
};

/////////0/////////1/////////2/////////3/////////4/////////5/////////6/////////7
template<typename It, typename Value>
struct const_iterator_of_type
{
    static constexpr bool value = std::is_same_v<std::decay_t<decltype(*std::declval<It>())>, Value>;
};

template<typename It, typename Value>
constexpr bool const_iterator_of_type_v = const_iterator_of_type<It, Value>::value;

/////////0/////////1/////////2/////////3/////////4/////////5/////////6/////////7
template<typename It, std::enable_if_t<const_iterator_of_type_v<It, char>, int> = 0>
int CalcSomething(It beg, It end)
{
    return 100 + std::accumulate(beg, end, int{});
}

template<typename It, std::enable_if_t<const_iterator_of_type_v<It, char16_t>, int> = 0>
int CalcSomething(It beg, It end)
{
    return 200 + std::accumulate(beg, end, int{});
}

template<typename It, std::enable_if_t<const_iterator_of_type_v<It, char32_t>, int> = 0>
int CalcSomething(It beg, It end)
{
    return 300 + std::accumulate(beg, end, int{});
}

template<typename It, std::enable_if_t<const_iterator_of_type_v<It, wchar_t>, int> = 0>
int CalcSomething(It beg, It end)
{
    if constexpr (sizeof(wchar_t) == sizeof(char16_t))
    {
        using Adaptor = IterAdaptor<It, const char16_t>;
        return CalcSomething(Adaptor{beg}, Adaptor{end}); // ????
    }
    else if constexpr (sizeof(wchar_t) == sizeof(char32_t))
    {
        using Adaptor = IterAdaptor<It, const char32_t>;
        return CalcSomething(Adaptor{beg}, Adaptor{end}); // ????
    }
    else
        static_assert(!std::is_same_v<wchar_t, char16_t> && !std::is_same_v<wchar_t, char32_t>, "Unsuported wchar_t size!");
}

int main()
{
    wchar_t wchars[7];

    return CalcSomething(std::begin(wchars), std::end(wchars));
}

#include <type_traits>
#include <utility>
#include <numeric>

/////////0/////////1/////////2/////////3/////////4/////////5/////////6/////////7
template <class SrcIter, class DstValue>
class IterAdaptor
{
public:
    using iterator_category = typename std::iterator_traits<SrcIter>::iterator_category;
    using iterator_concept = typename std::iterator_traits<SrcIter>::iterator_concept;
    using value_type = DstValue;
    using difference_type = std::iter_difference_t<SrcIter>;
    using pointer = std::add_pointer_t<DstValue>;
    using reference = std::add_lvalue_reference_t<DstValue>;

    SrcIter iter;

    constexpr IterAdaptor(SrcIter iter):iter(iter){}

    auto operator<=>(IterAdaptor const& other) const = default;

    constexpr DstValue operator*() { return *iter; }// со ссылками не заморачиваюсь пока, но судя по всему это нужно будет сделать
    constexpr IterAdaptor& operator++() { ++iter; return *this; }
};
/////////0/////////1/////////2/////////3/////////4/////////5/////////6/////////7

template<typename It, typename Value>
concept const_iterable_of_type = std::same_as<std::decay_t<decltype(*std::declval<It>())>, Value>;

using wchar_t_as_char_t =
    std::conditional_t<sizeof(wchar_t) == sizeof(char16_t), char16_t,
    std::conditional_t < sizeof(wchar_t) == sizeof(char32_t), char32_t, void>>;
static_assert(!std::is_same_v<wchar_t_as_char_t, void>);

/////////0/////////1/////////2/////////3/////////4/////////5/////////6/////////7
template<const_iterable_of_type<char> It>
constexpr int CalcSomething(It beg, It end)
{
    return 100 + std::accumulate(beg, end, int{});
}

template<const_iterable_of_type<char16_t> It>
constexpr int CalcSomething(It beg, It end)
{
return 200 + std::accumulate(beg, end, int{});
}

template<const_iterable_of_type<char32_t> It>
constexpr int CalcSomething(It beg, It end)
{
    return 300 + std::accumulate(beg, end, int{});
}

template<const_iterable_of_type<wchar_t> It>
constexpr int CalcSomething(It beg, It end)
{
    using Adaptor = IterAdaptor<It, const wchar_t_as_char_t>;
    return CalcSomething(Adaptor{ beg }, Adaptor{ end }); // ????
}

int main()
{
    constexpr wchar_t wchars[7] = L"abc";

    constexpr auto x = CalcSomething(std::begin(wchars), std::end(wchars));
    return x;
}

template<const_iterable_of_type<wchar_t> It>
constexpr int CalcSomething(It beg, It end)

template<const_iterable_of_type<wchar_t> ItBegin, const_iterable_of_type<wchar_t> ItEnd>

V>template<const_iterable_of_type<wchar_t> It>
V>constexpr int CalcSomething(It beg, It end)
V>

CalcSomething(std::list<wchar_t>::const_iterator{}, std::vector<wchar_t>::const_iterator{});

template<Concept T> 
auto foo(T param) …

template<typename T>
requires Concept<T>
auto foo(T param) …

template<Concept T> 
W>auto foo(T param) …
W>

template<typename T>
W>requires Concept<T>
W>auto foo(T param) …
W>

template<const_iterable_of_type<char> It>
constexpr int CalcSomething(It beg, It end);

template<typename It> requires const_iterable_of_type<It, char>
constexpr int CalcSomething(It beg, It end);