restrict types of function using C++20 Concepts

I've created the following class:

using namespace std;

typedef std::variant<long, bool> value;

class settings {
public:
    template<class T>
    void set(const string &name, const T &val) noexcept {
        data_[name] = val;
    }

    template<class T>
    [[nodiscard]] inline const T &get_or_default(const string &name, const T &val) noexcept {
        if (data_.contains(name)) {
            if (auto value = get_if<T>(&data_[name]); value) {
                return *value;
            }
        }
        return val;
    }

private:
    unordered_map<string, value> data_;
};

And this works fine, for example with this usage:

    auto config = settings{};
    config.set("foo", 100L);
    config.set("bar", true);
    cout << "foo: " << config.get_or_default("foo", 0L) << endl;
    cout << "bar: " << config.get_or_default("bar", false) << endl;
    cout << "foobar: " << config.get_or_default("foobar", 500L) << endl;

output

foo: 0
bar: 1
foobar: 500

If I try to use the method set with something that is not valid for the type value (bool or long):

    auto config = settings{};
    config.set("foo", 100.0);

We get an error like this:

\main.cpp(13): error C2679: binary '=': no operator found which takes a right-hand operand of type 'const T' (or there is no acceptable conversion)
with
[
T=double
]
variant(1200): note: could be 'std::variant<long,bool> &std::variant<long,bool>::operator =(std::variant<long,bool> &&)'
variant(1200): note: or       'std::variant<long,bool> &std::variant<long,bool>::operator =(const std::variant<long,bool> &)'
variant(1042): note: or       'std::variant<long,bool> &std::variant<long,bool>::operator =(_Ty &&) noexcept(<expr>)'
main.cpp(12): note: 'std::variant<long,bool> &std::variant<long,bool>::operator =(_Ty &&) noexcept(<expr>)': could not deduce template argument for '__formal'
main.cpp(13): note: while trying to match the argument list '(std::variant<long,bool>, const T)'
with
[
T=double
]
main.cpp(32): note: see reference to function template instantiation 'void settings::set<double>(const std::string &,const T &) noexcept' being compiled
with
[
T=double
]

Similar using the method get_or_default:

    auto config = settings{};
    cout << "foo: " << config.get_or_default("foo", 100) <<endl;

We get this error:

variant(1302): error C2338: static_assert failed: 'get_if<T>(variant<Types...> *) requires T to occur exactly once in Types. (N4835 [variant.get]/9)'
main.cpp(17): note: see reference to function template instantiation 'int *std::get_if<int,long,bool>(std::variant<long,bool> *) noexcept' being compiled
main.cpp(32): note: see reference to function template instantiation 'const T &settings::get_or_default<int>(const std::string &,const T &) noexcept' being compiled
with
[
T=int
]

These errors are fine, however I like to use c++ 20 concepts to restrict the types for the method set and get_or_default to give a more simple error to the user of the class that indicates that the types valid are only bool and long.

Is possible as well to give a specific assertion message for those messages using only concepts? Very specifically, not third parties libraries.

Add a declaration:

#include <type_traits>
template<typename T>
concept is_value=std::is_same_v<T,long> || std::is_same_v<T,bool>;

and then make a tiny change to the template:

    template<is_value T>
[[nodiscard]] inline const T &get_or_default(const string &name, const T &val) noexcept {

That's it. Make the same change to the other template function.

Not using concept, but you could write your settings in a way that set/get_or_default are not template:

template <typename... Ts>
struct settings_base
{
std::unordered_map<std::string, std::variant<Ts...>> data_;
};
template <typename Base, typename T>
struct settings_node : virtual Base
{
void set(const std::string& name, const T& value)
{
Base::data_[name] = value;
}
[[nodiscard]] const T &get_or_default(const std::string &name, const T &val) noexcept
{
auto it = Base::data_.find(name);
if (it != Base::data_.end()) {
if (auto value = std::get_if<T>(&it->second); value) {
return *value;
}
}
return val;
}
};
template <typename... Ts>
class settings_impl : settings_node<settings_base<Ts...>, Ts>...
{
public:
using settings_node<settings_base<Ts...>, Ts>::set...;
using settings_node<settings_base<Ts...>, Ts>::get_or_default...;
// So equivalent to:
// void set(const std::string&, const T1& value);
// ..
// void set(const std::string&, const TN& value);
};

And then

using settings = settings_impl<bool, long /*std::string*/>;

That allows conversion contrary to template way.

Note though that "xxxx" (const char [N]) would select bool overload and not std::string one, due to overload rules.

Not a concept, but a different approach:

If you want to limit get and set to exactly long or bool, you can have non-template overloads:

class settings {
public:
void set(const std::string &name, const long &val) noexcept {
set_impl(name, val);
}
[[nodiscard]] const long &get_or_default(const std::string &name, const long &val) noexcept {
return get_impl(name, val);
}
void set(const std::string &name, const bool &val) noexcept {
set_impl(name, val);
}
[[nodiscard]] const bool &get_or_default(const std::string &name, const bool &val) noexcept {
return get_impl(name, val);
}
private:
template<class T>
void set_impl(const std::string &name, const T &val) noexcept {
data_[name] = val;
}
template<class T>
[[nodiscard]] const T &get_impl(const std::string &name, const T &val) noexcept {
if (data_.contains(name)) {
if (auto value = get_if<T>(&data_[name])) {
return *value;
}
}
return val;
}
std::unordered_map<std::string, value> data_;
};