Fornecendo restrições para um pacote de parâmetros

Tenho uma classe modelo que contém uma tupla.

template <class... SomeTypes>
class Foo
{ ... };

Como posso aplicar uma restrição aos tipos contidos no pacote de parâmetros SomeTypes? Por exemplo, se eu quisesse garantir que todos os tipos se encaixassem no std::movableconceito?

E se SomeTypestambém houvesse modelos?

template < template<typename> class... SomeTypes>
class Bar
{ ... };

Aqui está um caso mais específico do que estou procurando. O código não deveria (e não compila) porque FooBnão é copiável.

Infelizmente, o compilador não exibe as melhores mensagens de erro quando isso acontece (no código com o qual estou lidando, os tipos são mais complexos e isso resulta em listas de erros gigantescas). Espero poder adicionar algum tipo de requirescláusula FooContainerque gere um erro muito mais claro.

#include <tuple>
#include <concepts>

template <typename ContainerType>
class Foo
{
};

template <typename ContainerType>
class FooA : public Foo<ContainerType>
{
    public:
    int some_data {0};

    void DoSomething()
    {
        some_data++;
    }
};

template <typename ContainerType>
class FooB : public Foo<ContainerType>
{
    public:
    // non-copyable object
    FooB() = default;
    FooB( const FooB& ) = delete;
    FooB& operator=( const FooB& ) = delete;
    ~FooB() = default;

    int some_data {0};

    void DoSomething()
    {
        some_data++;
    }
};


template < template<typename> class... SomeTypes>
// requires (std::copyable<SomeTypes...>) ???
class FooContainer
{
    public:
    std::tuple<SomeTypes<FooContainer>...> my_tuple;

    template <std::size_t I = 0, std::enable_if_t<I == sizeof...(SomeTypes)>* = nullptr>
    void DoAllThings()
    {
    }

    template <std::size_t I = 0, std::enable_if_t<I < sizeof...(SomeTypes)>* = nullptr>
    void DoAllThings()
    {
        std::get<I>(my_tuple).DoSomething();
        DoAllThings<I + 1>();
    }
};


using MyContainer = FooContainer<FooA, FooB>;

int main()
{
    MyContainer my_bar;
    my_bar.DoAllThings();
    MyContainer my_bar2 = my_bar;
}

--Edição 2--

Então, depois de brincar com algumas das sugestões aqui, o mais próximo que cheguei do que eu queria foi usar uma função estática externa para fazer a verificação.

template <typename FooType>
requires (std::copyable<FooType>)
constexpr bool FooTypeCheck()
{
    return true;
}

static_assert(FooTypeCheck<FooA<int>>());

Isso me dá a verificação que eu quero (se a classe Foo derivada é copiável) e, portanto, a saída do compilador mais fácil de ler se a verificação falhar. Para fins de verificação de tipo, o ContainerType não importa, então eu apenas passo um int. Infelizmente, isso também significa que preciso adicionar o static_assert para cada classe Foo derivada, e o int que eu passo para ContainerType é um pouco estranho.

--Edição Final (Resposta)-- Dei os créditos a @Ted Lyngmo pela resposta, pois estava próxima do que eu precisava. Como o parâmetro ContainerType é apenas parte do CRTP, ele realmente não importa para os propósitos da restrição, e posso usar apenas int, e a solução é um pouco mais simples.

template <template <typename> class FooType>
concept FooTypeCheck = std::copyable<FooType<int>>;

template < template<typename> class... SomeTypes>
requires (... && FooTypeCheck<SomeTypes>)
class FooContainer
{ ... };