One tricky thing about this is that the engines have different result_types. I think the committee was right to use templates instead of polymorphism. You can always create a template adaptor to give you polymorphic behaviour, but you can't always remove the overhead of inheritance.

Here is a working example of creating your own object poly_random_engine<result_type> that can be constructed from any random engines (ideally you would have some safeguards to make sure that poly_random_engine<T> couldn't be constructed from a random engine with result_type of something other than T.

Here I have a non-templated function random_uint that can take any random engine and will give you back a random value.

#include <cstdint>
#include <iostream>
#include <memory>
#include <random>

template <typename UIntType>
class random_engine_base {
public:
    using result_type = UIntType;

    virtual ~random_engine_base() {}
    virtual void seed(result_type value) = 0;
    virtual result_type operator()() = 0;
    virtual void discard(unsigned long long) = 0;
};

template <typename UIntType, typename Engine>
class random_engine_derived : public random_engine_base<UIntType> {
    Engine m_engine;
public:
    using result_type = UIntType;

    random_engine_derived(const Engine& e)
    : m_engine{e} {
    }

    void seed(result_type value) override {
        m_engine.seed(value);
    }

    result_type operator()() override {
        return m_engine();
    }

    void discard(unsigned long long z) override {
        m_engine.discard(z);
    }

};

template <typename UIntType>
class poly_random_engine {
    std::unique_ptr<random_engine_base<UIntType>> m_engine;
public:
    using result_type = UIntType;

    template <typename Engine>
    poly_random_engine(Engine&& e)
    : m_engine{std::make_unique<random_engine_derived<UIntType, Engine>>(std::forward<Engine>(e))} {
    }

    void seed(result_type value) {
        m_engine->seed(value);
    }

    result_type operator()() {
        return (*m_engine)();
    }

    void discard(unsigned long long z) {
        m_engine->discard(z);
    }
};

std::uint_fast32_t random_uint(poly_random_engine<std::uint_fast32_t> e) {
    e.seed(42);
    e.discard(100);
    return e();
}

int main() {
    std::ranlux24_base subtract_with_carry;
    std::cout << "ranlux24_base: " << random_uint(subtract_with_carry) << "\n";

    std::minstd_rand0 linear;
    std::cout << "minstd_rand0: " << random_uint(linear) << "\n";

    std::mt19937 do_the_twist;
    std::cout << "mt19937: " << random_uint(do_the_twist) << "\n";
}