Concept that ONLY allows non-type template parameters that are members of certain namespace

I have a namespace Bar and a namespace Bar::Inner (declared within Bar).

// Bar
namespace Bar {
    size_t num = 32;
    
    // Bar::Inner
    namespace Inner {
        size_t num = 4;
    };
};

<br>

Then, I have a variadic function template foo. This variadic template accepts non-type parameters of common type T.
<br>
However, I want the non-type parameters to HAVE TO be members of namespace Bar, but NOT members of namespace Bar::Inner.

template<typename T, T ...Sz>
    requires MyConcept<T, Sz...>
auto foo()
{
    return (Sz + ...);
}

And I'd like to accomplish that using concepts, if possible.

template<typename T, T ...Sz>
concept MyConcept = (/*Whatever goes here*/);

So, to sum it up, I basically need a concept that can allow the non-type template parameters only if they are members of namespace Bar, but NOT of namespace Bar::Inner.

It's entirely possible to filter variables by namespace if you allow yourself to use some extensions.

You have to also know that you won't accept values anymore. This may be a big downside.

First, let's declare fixed_string, this is gonna be useful for compile time string manipulation:

template<std::size_t n>
struct fixed_string {
constexpr fixed_string() = default;
constexpr fixed_string(const char(&str)[n + 1]) noexcept {
auto i = std::size_t{0};
for (char const c : str) {
_data[i++] = c;
}
}
friend constexpr auto operator<=>(fixed_string const&, fixed_string const&) = default;
[[nodiscard]]
static constexpr auto size() noexcept -> std::size_t {
return n;
}
constexpr auto data() const& noexcept {
return _data;
}
constexpr auto data() & noexcept {
return _data;
}
constexpr auto begin() const& noexcept -> char const* {
return _data;
}
constexpr auto end() const& noexcept -> char const* {
return _data + n;
}
constexpr auto begin() & noexcept -> char* {
return _data;
}
constexpr auto end() & noexcept -> char* {
return _data + n;
}
constexpr auto operator[](std::size_t index) noexcept {
return _data[index];
}
constexpr auto starts_with(std::string_view str) {
return std::string_view{_data, n}.starts_with(str);
}
char _data[n + 1];
};
template<std::size_t n>
fixed_string(char const(&)[n]) -> fixed_string<n - 1>;

Now that we have the basic, let's create a function that returns the qualified name of an object using a compiler extension. It's technically doable pretty portably if you use compiler specific extension and you dynamically filter the string so it returns only the name of the object.

template<auto& v>
constexpr auto name_of() -> std::string_view {
constexpr auto size = std::string_view{__PRETTY_FUNCTION__}.size();
constexpr auto drop_begin = "constexpr std::string_view name_of() [with auto& v = "sv.size();
constexpr auto drop_end = "; std::string_view = std::basic_string_view<char>]"sv.size();
return std::string_view{__PRETTY_FUNCTION__}.substr(drop_begin, size - drop_end - drop_begin);
}

Then, we can create a concept to only yield true of the qualified name starts with a particular string:

template<auto& v, fixed_string namesp>
concept in_namespace = name_of<v>().starts_with(std::string_view{namesp.data(), namesp.size()});

Now, you can write a function that only accepts objects from a particular namespace:

template<auto& v> requires in_namespace<v, "bar">
void im_clever();

To filter out the inner namespace you can do this:

template<auto& v>
concept in_bar_not_in_inner = in_namespace<v, "bar"> and not in_namespace<v, "bar::inner">;

See my code running in compiler explorer

Non-type template parameters are... values. Values do not belong to a namespace; they're just values. The constant expression 2 is exactly equivalent to any constexpr value that evaluates to the value 2. There is no difference.

If you take an NTTP, you are saying that it can assume any value the user provides. A concept can restrict the actual values of such a parameter, but not the argument expression used to provide those values. That is, by the time a concept sees an NTTP, all information about where it came from has been lost.

That is, if some template templ<2> can work, any constant expression expr will work in place of 2 so long as it resolves to the value of 2.