int_finder.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: © 2025 Larry Chips <larry@larrychips.net>
 * SPDX-Licence-Identifier: MIT
 */
#ifndef UGMISC_INT_FINDER_HPP
#define UGMISC_INT_FINDER_HPP

 
#include <cstdint>
#include <limits>
#include <string_view>
#include <type_traits>
#include "ugmisc/bitops.hpp"
#include "ugmisc/features.hpp"
#include "ugmisc/member.hpp"
#include "ugmisc/quote.hpp"
#include "ugmisc/sfinae_helpers.hpp"
#include "ugmisc/templated_callable_loop.hpp"
#include "ugmisc/typelist.hpp"
 
 
namespace ugmisc {
 

enum int_sign { INVALID_SIGN = 0, UNSIGNED = 1, SIGNED = 2 };
 
 
 
 
constexpr int_sign flip( int_sign s ) {
    return static_cast<int_sign>(((unsigned)s) ^ 3);
}
 
 
 

enum sign_opt : std::uint8_t {
    SELECT_SIGN_OPTION_NONE = 0,
    SELECT_UNSIGNED   = 1, 
    SELECT_SIGNED     = 2, 
    SELECT_TYPE_SIGN  = 3, 
    SELECT_VALUE_SIGN = 4, 
 
    SELECT_SIGN_OPTION_MAX = SELECT_VALUE_SIGN,
    SELECT_SIGN_OPTION_MASK = 7,
};
 
 
 

inline std::string_view get_name(sign_opt opt) {
    switch( opt ) {
    case SELECT_SIGN_OPTION_NONE:
        return "NONE";
    case SELECT_UNSIGNED:
        return "SELECT_UNSIGNED";
    case SELECT_SIGNED:
        return "SELECT_SIGNED";
    case SELECT_TYPE_SIGN:
        return "SELECT_TYPE_SIGN";
    case SELECT_VALUE_SIGN:
        return "SELECT_VALUE_SIGN";
    default:
        return "INVALID";
    }
};
 
 
 
 
 
template<class T>
constexpr int_sign sign(sign_opt opt, T v) {
 
    switch( opt ) {
    case SELECT_UNSIGNED: return UNSIGNED;
    case SELECT_SIGNED: return SIGNED;
    case SELECT_TYPE_SIGN:
        return std::is_signed_v<T> ? SIGNED : UNSIGNED;
    case SELECT_VALUE_SIGN:
        return v < (T)0 ? SIGNED : UNSIGNED;
    default:
        return INVALID_SIGN;
    }
}
 
 
 

enum sign_flag : std::uint8_t {
    SELECT_SIGN_FLAGS_NONE,
    SELECT_SIGN_SMALLEST     = 1 << 3,

    SELECT_SIGN_ALLOW_VALUE_SIGN_LOSS = 1 << 4,
 
    SELECT_SIGN_FLAGS_MASK = SELECT_SIGN_SMALLEST|SELECT_SIGN_ALLOW_VALUE_SIGN_LOSS
};
 
 
constexpr sign_flag operator~(sign_flag f) {
    return static_cast<sign_flag>((~(std::uint8_t)f)&(std::uint8_t)SELECT_SIGN_FLAGS_MASK);
}
 
 
constexpr sign_flag operator|(sign_flag a, sign_flag b) {
    return static_cast<sign_flag>((std::uint8_t)a | (std::uint8_t)b);
}
 
 
constexpr bool smallest(sign_flag s) {
    return (std::uint8_t)SELECT_SIGN_SMALLEST & (std::uint8_t)s;
}
 
 
constexpr bool allow_value_sign_loss(sign_flag s) {
    return (std::uint8_t)SELECT_SIGN_ALLOW_VALUE_SIGN_LOSS & (std::uint8_t)s;
}
 
 
/*
 * This might have to be a `string` instead of a `string_view` if we add more
 * flags, because we can't just special case every combination.
 *
 * This function is *not* declared `constexpr` in case it one day has to return
 * `std::string`.
 */
inline std::string_view get_name(sign_flag flags) {
    bool smol     = smallest(flags);
    bool signloss = allow_value_sign_loss(flags);
    if ( smol && signloss ) {
        return "SELECT_SIGN_SMALLEST|SELECT_SIGN_ALLOW_VALUE_SIGN_LOSS";
    } else if ( smol ) {
        return "SELECT_SIGN_SMALLEST";
    } else if ( signloss ) {
        return "SELECT_SIGN_ALLOW_VALUE_SIGN_LOSS";
    } else {
        return "NONE";
    }
}
 
 
 

namespace intfind_ {
 
 
 
template<class T>
constexpr bool is_opt = std::is_convertible_v<T, sign_opt>;
 
template<class T>
constexpr bool is_flag = std::is_convertible_v<T, sign_flag>;
 
template<class T>
constexpr bool is_opt_or_flag = is_opt<T> || is_flag<T>;
 
template<class T>
constexpr bool is_int = std::numeric_limits<T>::is_integer;
 
template<class T>
constexpr bool is_required_int_tparam_type =
    is_opt_or_flag<T>
    || is_int<T>;
 
template<class T, class R=T>
using required_int_tparam_type_only =
    std::enable_if_t<
        is_required_int_tparam_type<T>,
        R
        >;
 
/*
 * Concepts will make errors more understandable, if available.
 */
#ifdef UGMISC_USE_CONCEPT_DECLS
template<class T>
concept Opt = is_opt<T>;
 
template<class T>
concept Flag = is_flag<T>;
 
template<class T>
concept OptOrFlag = Opt<T> || Flag<T>;
 
template<class T>
concept RequiredIntTparamType = OptOrFlag<T> || Int<T>;
#endif
 
 
 

#ifdef UGMISC_USE_CONCEPT_DECLS
template< RequiredIntTparamType T >
constexpr sign_opt sign_opt_or_not(T t)
#else
template< class T >
constexpr auto
sign_opt_or_not(T t)
    -> required_int_tparam_type_only<T, sign_opt>
#endif
{
    if constexpr ( is_opt<T> ) {
        return static_cast<sign_opt>(t);
    } else {
        return SELECT_SIGN_OPTION_NONE;
    }
}
 
 
template<class T> constexpr bool is_non_null_opt(T t) {
    return (unsigned)sign_opt_or_not(t);
}
 
 
#ifdef UGMISC_USE_CONCEPT_DECLS
template<RequiredIntTparamType T> constexpr sign_flag sign_flag_or_not(T t)
#else
template<class T> constexpr auto sign_flag_or_not(T t)
    -> required_int_tparam_type_only<T, sign_flag>
#endif
{
    if constexpr ( is_flag<T> ) {
        return static_cast<sign_flag>(t);
    } else if constexpr ( is_opt<T> ) {
        return SELECT_SIGN_FLAGS_NONE;
    } else {
        static_assert(
                false,
                "sign_flag_or_not takes sign_flag and sign_opt, "
                "and types convertible to them."
                );
    }
}
 
 
 

template<auto...Opts>
constexpr sign_opt combine_sign_opts_f()
{
    constexpr sign_opt opt_array[sizeof...(Opts)] = { sign_opt_or_not(Opts)... };
    sign_opt found_opt = SELECT_SIGN_OPTION_NONE;
    for( sign_opt opt: opt_array ) {
        if ( opt == SELECT_SIGN_OPTION_NONE ) {
            continue;
        }
        if ( found_opt != SELECT_SIGN_OPTION_NONE && opt != found_opt ) {
            return SELECT_SIGN_OPTION_NONE;
        }
        found_opt = opt;
    }
    return found_opt;
}
 
 
 
 
template<auto...Opts> static constexpr sign_opt combined_sign_opts
    = combine_sign_opts_f<Opts...>();
 
 
template<auto...Flags> static constexpr sign_flag combined_sign_flags
    = (SELECT_SIGN_FLAGS_NONE | ... | sign_flag_or_not(Flags));
 
 
 
 
template<auto...Opt>
static constexpr bool valid_sign_opts = (unsigned)combined_sign_opts<Opt...>;
 
 
 
 
template<auto...Opt>
static constexpr bool any_sign_opts = (... || is_non_null_opt(Opt));
 
 
 

template<bool HasOpt>
class flag_opt_combo {
    const sign_flag m_flags;
 
public:
    flag_opt_combo(const flag_opt_combo&) = default;
    constexpr flag_opt_combo(sign_flag sflags) : m_flags(sflags) {}
 
    constexpr sign_flag flags() const { return m_flags; }
    constexpr sign_opt safe_opt() const { return SELECT_SIGN_OPTION_NONE; }
    constexpr sign_opt opt() const {
        static_assert(
                false,
                "This flag_opt_combo does not have an option."
                );
        return safe_opt();
    }
    constexpr bool has_opt() const { return false; }
 
    constexpr operator sign_flag() const { return flags(); }
};
 
 
template<>
class flag_opt_combo<true> : public flag_opt_combo<false> {
    const sign_opt m_opt;
 
public:
    flag_opt_combo(const flag_opt_combo&) = default;
    constexpr flag_opt_combo(sign_opt sopt, sign_flag sflags)
        : flag_opt_combo<false>(sflags), m_opt(sopt)
    {}
 
    constexpr sign_opt opt() const { return m_opt; }
    constexpr sign_opt safe_opt() const { return opt(); }
    constexpr bool has_opt() const { return true; }
 
    constexpr operator sign_opt() const { return opt(); }
};
 
 
 
 
template<auto...args>
constexpr auto combine_flags_opts()
{
    constexpr sign_flag flags = combined_sign_flags<args...>;
    constexpr sign_opt opt  = combined_sign_opts<args...>;
    constexpr bool valid_opts = valid_sign_opts<args...>;
    constexpr bool any_opts = any_sign_opts<args...>;
 
    if constexpr ( any_opts ) {
        static_assert( valid_opts );
        return flag_opt_combo<true>{opt, flags};
    } else {
        return flag_opt_combo<false>{flags};
    }
}
 
 
 
 
 
} /* intfind_ */
// INTERNAL
 
 
 

template<auto...FlagOpts>
constexpr auto combined = intfind_::combine_flags_opts<FlagOpts...>();
 
 
 
 
#ifndef UGMISC_INT_FINDER_MAX_INT_WIDTH
# define UGMISC_INT_FINDER_MAX_INT_WIDTH (1U << 12);
#endif
inline constexpr unsigned max_int_width = UGMISC_INT_FINDER_MAX_INT_WIDTH;
 
 
 

template<unsigned N> struct get_int_types {};
 
 
template<> struct get_int_types<8> {
    using unsigned_type = std::uint8_t;
    using signed_type = std::int8_t;
};
 
template<> struct get_int_types<16> {
    using unsigned_type = std::uint16_t;
    using signed_type = std::int16_t;
};
 
template<> struct get_int_types<32> {
#ifndef UGMISC_TEST_INT_FINDER_SKIP_U32
    using unsigned_type = std::uint32_t;
#endif
    using signed_type = std::int32_t;
};
 
template<> struct get_int_types<64> {
    using unsigned_type = std::uint64_t;
    using signed_type = std::int64_t;
};
 
 
 

namespace intfind_ {
 
 
 
 
/*
 * This allows us to test the existence of a type easily.
 *
 * Resulting declarations are listed below for clarity.
 */
UGMISC_DECL_MEMBER_ACCESS(utype, unsigned_type);
UGMISC_DECL_MEMBER_ACCESS(stype, signed_type);
// has_member_type_unsigned_type< T >; // T can be a type_list.
// member_type_unsigned_type< T, D (optional) > // T can be type_list,
                                                // D is a default type.
// member_type_test_unsigned_type< T > // Usually not used directly.
// has_member_type_signed_type< T >; // T can be a type_list.
// member_type_signed_type< T, D (optional) > // T can be type_list,
                                              // D is a default type.
// member_type_test_signed_type< T > // Usually not used directly.
 
 
 
template<unsigned N>
constexpr bool check_member_int_types(get_int_types<N> t) {
    static_assert( N <= max_int_width,
           "Integer width must be no more than "
           UGMISC_QQ(UGMISC_INT_FINDER_MAX_INT_WIDTH)
           " bits."
           );
    using T = decltype(t);
 
    if constexpr ( member_type_access<utype, T>::has_member ) {
        using I = typename T::unsigned_type;
        using limits = std::numeric_limits<I>;
        constexpr unsigned bits = limits::digits;
        static_assert( limits::radix == 2 );
        static_assert( limits::is_integer );
        static_assert( ! limits::is_signed );
        static_assert( bits == N );
    }
 
    if constexpr ( member_type_access<stype, T>::has_member ) {
        using I = typename T::signed_type;
        using limits = std::numeric_limits<I>;
        constexpr unsigned bits = limits::digits + 1; // Sign bit.
        static_assert( limits::radix == 2 );
        static_assert( limits::is_integer );
        static_assert( limits::is_signed );
        static_assert( bits == N );
    }
 
    return true;
}
 
 
 

template<unsigned N> struct get_int_types : public ::ugmisc::get_int_types<N> {
private:
    static constexpr bool _check =
        check_member_int_types(::ugmisc::get_int_types<N>{});
};
 
 
 
 
} /* intfind_ (::ugmisc::intfind_) */
// INTERNAL
 
 
 

template<unsigned N, int_sign Sign>
inline constexpr bool has_int_type =
    Sign == UNSIGNED
    ? member_type_access<intfind_::utype, intfind_::get_int_types<N> >::has_member
    : member_type_access<intfind_::stype, intfind_::get_int_types<N> >::has_member
    ;
 

template<unsigned N> inline constexpr bool has_unsigned_type =
    has_int_type<N, UNSIGNED>;

template<unsigned N> inline constexpr bool has_signed_type = has_int_type<N, SIGNED>;

template<unsigned N> inline constexpr bool has_both_int_types =
    has_unsigned_type<N> && has_signed_type<N>;

template<unsigned N> inline constexpr bool  has_either_int_type =
    has_unsigned_type<N> || has_signed_type<N>;
 
 
 

template<unsigned N> using exact_unsigned_type = typename intfind_::get_int_types<N>::unsigned_type;

template<unsigned N> using exact_signed_type = typename intfind_::get_int_types<N>::signed_type;
 
 
 

namespace intfind_ {
 

template<unsigned N, int_sign S> struct get_exact_int_type;
 
 
template<unsigned N>
struct get_exact_int_type<N, UNSIGNED> {
    using type = typename get_int_types<N>::unsigned_type;
};
 
template<unsigned N>
struct get_exact_int_type<N, SIGNED> {
    using type = typename get_int_types<N>::signed_type;
};
 
 
} /* intfind_ */
// INTERNAL
 

template<unsigned N, int_sign S> using exact_int_type =
    typename intfind_::get_exact_int_type<N, S>::type;
 
 
 

namespace intfind_ {
 
 
 
 
static constexpr unsigned find_inner_loop_max = 100;
 
 
 

template<int_sign Sign>
struct type_finder {
    template<unsigned V>
    constexpr decltype(auto) operator() (
            std::integral_constant<unsigned, V> I
            ) const
    {
        if constexpr ( has_int_type<I.value, Sign> ) {
            return exact_int_type<I.value, Sign>{1};
        } else {
            return template_find_continue;
        }
    }
};
 
 
 
 
}
// INTERNAL
 
 
 

template<unsigned N, int_sign Sign>
using least_int_type =
    decltype(
    intfind_::template_callable_find<N, max_int_width, intfind_::type_finder<Sign>>()
    );
 

template<unsigned N, int_sign Sign>
constexpr bool has_sufficient_int_type =
    intfind_::template_callable_find_success<N, max_int_width, intfind_::type_finder<Sign>>();
 

template<unsigned N>
using least_unsigned_type = least_int_type<N, UNSIGNED>;
 

template<unsigned N>
using least_signed_type = least_int_type<N, SIGNED>;
 
 
 

#ifdef UGMISC_USE_CONCEPT_DECLS
template< bool IncludingSignBit, Int T >
constexpr unsigned signed_bitwidth(T v)
#else
template< bool IncludingSignBit, class T >
constexpr int_only<T, unsigned> signed_bitwidth(T v)
#endif
{
    using U = least_unsigned_type<std::numeric_limits<T>::digits>;
    constexpr bool use_sign_bit = std::is_signed_v<T> && IncludingSignBit;
    constexpr unsigned extra_bits = use_sign_bit ? 1 : 0;
    const U w = v >= 0 ? (U)v : ~(U)v;
    return bitwidth(w) + extra_bits;
}
 
 
 

namespace intfind_ {
 
 
 
 
/*
 * Returns `int_type{1}` if there is such a type, otherwise returns `false`.
 */
template<unsigned LeastBits, int_sign Sign>
constexpr auto find_type() {
    if constexpr ( has_sufficient_int_type<LeastBits, Sign> ) {
        using int_type = least_int_type<LeastBits, Sign>;
        return int_type{1};
    } else {
        return false;
    }
}
 
 
 
 
template<class T>
struct range_result_compare {
    const T value;
    range_result_compare(const range_result_compare&) = default;
    constexpr range_result_compare(T v) : value(v) {}
    constexpr bool valid() const { return value; }
    constexpr unsigned size() const { return sizeof(T); }
    constexpr unsigned used_bits() const {
        unsigned sign_bit = std::numeric_limits<T>::is_signed ? 1 : 0;
        return std::numeric_limits<T>::digits + sign_bit;
    }
};
 
 
 
 
/*
 * When looking for a smaller result type, a valid one always wins if the other
 * is invalid.  We care most about storage size, then used bits.
 */
template<class T, class U>
constexpr bool operator < (range_result_compare<T> a, range_result_compare<U> b) {
    if ( !a.valid() ) { return false; }
    if ( !b.valid() ) { return true; }
    if ( a.size() < b.size() ) { return true; }
    if ( a.size() > b.size() ) { return false; }
    return a.used_bits() < b.used_bits();
}
 
 
 
template<class T>
struct plus_max {
    T value;
    constexpr plus_max(T v) : value(v) {}
    plus_max(const plus_max&) = default;
 
    constexpr operator T() const { return value; }
};
 
template<class T>
constexpr plus_max<T> operator+(plus_max<T> a, plus_max<T> b) {
    return std::max(a.value, b.value);
}
 
template<class T>
plus_max(T v) -> plus_max<T>;
template<class T>
plus_max(T& v) -> plus_max<T>;
template<class T>
plus_max(const T& v) -> plus_max<T>;
 
 
 
 
template<class T>
struct get_int_type_from_sequence;
 
template<class T, T...Int>
struct get_int_type_from_sequence<std::integer_sequence<T, Int...>> {
    using type = T;
};
 
template<class T>
using int_type_from_sequence = typename get_int_type_from_sequence<T>::type;
 
 
 
 
struct required_int_arg_traits {
    enum errcode {
        OK,
        ERROR_SIGN_OPT_CLASH,
        ERROR_INVALID_SIGN
    };
 
    errcode error = OK;
 
    sign_opt clashing_opts[2] = {
        SELECT_SIGN_OPTION_NONE,
        SELECT_SIGN_OPTION_NONE
    };
 
    sign_opt opt = SELECT_SIGN_OPTION_NONE;
    sign_flag flags = SELECT_SIGN_FLAGS_NONE;
    bool any_invalid_sign = false;
    bool any_signed = false;
    bool any_negative = false;
    unsigned bitwidth = 0;
 
    required_int_arg_traits() = default;
    required_int_arg_traits(const required_int_arg_traits&) = default;
 
    template<class T>
    constexpr required_int_arg_traits(T v) {
        if constexpr ( intfind_::is_int<T> ) {
            any_signed = std::numeric_limits<T>::is_signed;
            any_negative = v < (T)0;
            bitwidth = signed_bitwidth<true>(v);
        } else {
            if constexpr ( intfind_::is_opt<T> ) { opt = v; }
            if constexpr ( intfind_::is_flag<T> ) { flags = v; }
        }
    }
 
    constexpr int_sign sign() const {
        if ( any_signed ) {
            return ugmisc::sign(opt, any_negative ? -1 : 1);
        } else {
            return ugmisc::sign(opt, any_negative ? -1U : 1U);
        }
    }
 
    constexpr bool complete() const {
        return opt != SELECT_SIGN_OPTION_NONE;
    }
 
    constexpr operator bool() const { return error == OK; }
};
 
 
 
 
constexpr required_int_arg_traits operator+(
        required_int_arg_traits lhs,
        required_int_arg_traits rhs
        )
{
    required_int_arg_traits out{lhs};
 
    if (
            lhs.opt != rhs.opt
            && lhs.opt != SELECT_SIGN_OPTION_NONE
            && rhs.opt != SELECT_SIGN_OPTION_NONE
       )
    {
        out.clashing_opts[0] = lhs.opt;
        out.clashing_opts[1] = rhs.opt;
        out.error = required_int_arg_traits::ERROR_INVALID_SIGN;
        return out;
    }
 
    out.opt = lhs.opt == SELECT_SIGN_OPTION_NONE ? rhs.opt : lhs.opt;
    out.flags = lhs.flags | rhs.flags;
    out.any_signed = lhs.any_signed || rhs.any_signed;
    out.any_negative = lhs.any_negative || rhs.any_negative;
    out.bitwidth = std::max(lhs.bitwidth, rhs.bitwidth);
    out.any_invalid_sign = lhs.any_invalid_sign || rhs.any_invalid_sign;
    if ( out.opt != SELECT_SIGN_OPTION_NONE ) {
        out.any_invalid_sign =
            out.any_invalid_sign ||(out.sign() == INVALID_SIGN);
    }
 
    if ( out.any_invalid_sign && out.error == out.OK ) {
        out.error = out.ERROR_INVALID_SIGN;
    }
 
    return out;
}
 
 
template<class T>
constexpr required_int_arg_traits operator+(required_int_arg_traits a, T b) {
    return a + required_int_arg_traits{b};
}
 
 
template<class T>
constexpr required_int_arg_traits operator+(T a, required_int_arg_traits b) {
    return required_int_arg_traits{a}, b;
}
 
 
 
 
} /* intfind_ (::ugmisc::intfind_) */
// INTERNAL
 
 
 

template<auto...V1>
#ifdef UGMISC_USE_CONCEPT_DECLS
// Try to make errors more self-explanatory.
requires (... && intfind_::RequiredIntTparamType<decltype(V1)>)
#endif
class least_required_int_type_finder
{
    template<auto V>
    struct wrapped {
        static constexpr auto value = V;
    };
 
    template<class T>
    struct int_test {
        static constexpr bool value = intfind_::is_int<decltype(T::value)>;
    };
 
    template<auto...V2>
    using wrapped_items = type_list<wrapped<V1>..., wrapped<V2>...>;
 
    template<auto...V2>
    using wrapped_ints = type_list_filter<
        int_test,
        wrapped_items<V2...>
        >;
 
    template<class...U>
    struct get_sequences {
        template<class I>
        using std_sequence = std::integer_sequence<I, (I)U::value...>;
 
        template<class I>
        using type_list =
            type_list<std::integral_constant<I, (I)U::value>...>;
    };
 
    template<auto...V2>
    using sequences = typename wrapped_ints<V2...>
        ::template apply_t<get_sequences>;
 
    template<class...T>
    static constexpr intfind_::required_int_arg_traits get_traits(T...v) {
        return (intfind_::required_int_arg_traits{} + ... + v);
    }
 
    /*
     * Returns std::integer_sequence<T, (T)V...>, where T is the required type
     * to hold all the values, according to the requirements of SelectArgs.
     */
    template<auto...V2>
    static constexpr auto typed_zero() {
        constexpr auto traits = get_traits(V1..., V2...);
 
        if constexpr ( !traits ) {
            // Error in traits.
            static_assert(
                    traits.error != traits.ERROR_SIGN_OPT_CLASH,
                    "Conflicting sign select options provided."
                    );
            static_assert(
                    traits.error != traits.ERROR_INVALID_SIGN,
                    "Valid sign can't be found with this option for these values."
                    );
        }
 
        static_assert(
                traits.complete(),
                "At least one argument must be a sign_opt."
                );
 
        constexpr int_sign pref_sign = traits.sign();
        constexpr int_sign other_sign = flip(pref_sign);
        constexpr int_sign value_sign =
            traits.any_negative ? SIGNED : UNSIGNED;
        constexpr bool choose_smaller = smallest(traits.flags);
        constexpr unsigned value_bits = traits.bitwidth;
 
        constexpr bool may_be_unsigned =
            value_sign == UNSIGNED
            || allow_value_sign_loss(traits.flags)
            ;
 
        // pref_value is a value which converts to true in boolean context if a
        // type was found, and whose type (in that case) is the type found.
        // Otherwise it will be false, and its type will be bool.
        constexpr auto pref_value =
            intfind_::find_type<value_bits, pref_sign>();
        constexpr auto other_value =
            intfind_::find_type<value_bits, other_sign>();
 
        using pref_t = std::remove_const_t<decltype(pref_value)>;
        using other_t = std::remove_const_t<decltype(other_value)>;
 
        // We want to be compatible with custom int types that don't
        // automatically convert to bool (although most probably do).
        constexpr bool pref_b = std::is_same_v<pref_t, bool> ? pref_value : true;
        constexpr bool other_b = std::is_same_v<other_t, bool> ? other_value : true;
 
        constexpr bool pref_valid = pref_b && (std::numeric_limits<pref_t>::is_signed || may_be_unsigned);
 
        /*
         * We never treat the sign select option as a mere suggestion unless
         * allowing a smaller type of the other sign to be chosen.
         */
        constexpr bool other_valid = other_b && (std::numeric_limits<other_t>::is_signed || may_be_unsigned) && choose_smaller;
 
        static_assert(
                pref_valid || other_valid,
                "least_required_type could not find a type that satisfies all "
                "requirements."
                );
 
 
        constexpr bool use_pref = [=]() -> bool {
            // Find out whether to use the found type (if any) of the preferred
            // sign, or the other one.  Usually there will always be a pair of
            // types of one size available, signed and unsigned, so most of these
            // cases will not be matched.
            if constexpr ( ! other_valid ) {
                // We have a valid type of preferred sign, and no type of other sign.
                return true;
            } else if constexpr ( ! pref_valid ) {
                // No preferred sign available, but the other sign is available.
                return false;
            } else if constexpr (
                    choose_smaller && other_valid
                    &&
                    intfind_::range_result_compare{other_value} < intfind_::range_result_compare{pref_value}
                    )
            {
                // There is a smaller type available that is large enough but not
                // of the preferred type.
                return false;
            } else {
                // Special cases have been exhausted (probably not really, sorry).
                return true;
            }
        }();
 
        if constexpr ( use_pref ) {
            static_assert(
                    pref_valid,
                    "This is Larry's fault."
                    " An earlier static assertion should have failed already."
                    );
            return (pref_t)0;
        } else {
            static_assert(
                    other_valid,
                    "This is Larry's fault."
                    " An earlier static assertion should have failed already."
                    );
            return (other_t)0;
        }
    }
 
public:
    template<auto...V2>
    using type = decltype(typed_zero<V2...>());

    template<auto...V2>
    using std_sequence = typename sequences<V2...>
        ::template std_sequence<type<V2...>>;

    template<auto...V2>
    using type_list = typename sequences<V2...>
        ::template type_list<type<V2...>>;

    template<auto...V2>
    using finder = least_required_int_type_finder<V1..., V2...>;
};
 
 
 

template<auto...V>
constexpr auto to_least_required_int_type() {
    using finder = least_required_int_type_finder<V...>;
    using ints = typename finder::template type_list<>;
    static_assert( ints::size == 1 );
    using int_const = type_list_member<0, ints>;
    return int_const::value;
};
 
 
 

template<auto...V>
inline constexpr auto as_least_required_int_type =
    to_least_required_int_type<V...>();
 
 
 

template<auto...V>
using least_required_int_type =
    typename least_required_int_type_finder<>::template type<V...>;
 

template<auto...V>
using least_required_int_type_multi = least_required_int_type<V...>;
 

template<auto...V>
using least_required_int_std_sequence =
    typename least_required_int_type_finder<>
    :: template std_sequence<V...>;
 

template<auto...V>
using least_required_int_type_list =
    typename least_required_int_type_finder<>
    ::template type_list<V...>;
 
 
 
 
} /* ugmisc */
#endif /* UGMISC_INT_FINDER_HPP */