Статический полиморфизм на концептах

#include <iostream>
#include <concepts>
#include <string>

// Интерфейс

template <typename T>
concept ResourceManager = requires(T&& t, const std::string& filename) { { t.read(filename) } -> std::convertible_to<typename T::resource_t&>; }
                       && requires(T&& t                             ) { { t.show()         } -> std::same_as<void>;                           }
                       ;

template <typename T, typename Resource>
struct IResourceManager
{
    using resource_t = Resource;
    IResourceManager() { static_assert(ResourceManager<T>, "IResourceManager not implemented properly"); };
    IResourceManager(IResourceManager&&) = default;
};

// Реализации

class StringManager : public IResourceManager<StringManager, std::string>
{
public:
    std::string& read(const std::string& filename)
    {
        m_resource = std::move(filename);
        return m_resource;
    }
    void show()
    {
        std::cout << m_resource << std::endl;
    }
private:
    std::string m_resource;
};

class IntManager : public IResourceManager<IntManager, int>
{
public:
    int& read(const std::string& filename)
    {
        m_resource = std::stoi(filename);
        return m_resource;
    }
    void show()
    {
        std::cout << m_resource << std::endl;
    }
private:
    int m_resource;
};

template <ResourceManager T>
void foo(T&& x)
{
    x.show();
};

int main()
{

    StringManager stringManager;
    stringManager.read("Hello");
    stringManager.show();

    IntManager intManager;
    intManager.read("123");
    intManager.show();

    foo(std::move(stringManager));

}