如何强制模板要求 function 谓词可使用类型或任何该类型的派生类型调用？

Question

I have the following event dispatcher relationship:

    enum class Type {type1, type2, ...};
    enum class Category {category1, category2, ...};    

    template <Category C, Type T>
    class Event<C, T>{
        public:
          virtual std::string name() const = 0;
          inline void consume(bool consume) { m_Consumed = consume; }
          inline bool consumed() const { return m_Consumed; }
        private:
          bool m_Consumed = false;
    };
    
    template <Category C, Type T>
    class Dispatcher {
        Dispatcher(Event<C, T> & event) : m_Event(event) {}
        template <class F> requires std::predicate<F, Event<C,T>>
        void dispatch(const F & function) {
            m_Event.consume(function(m_Event));
        }
    }

I'm unable to have the requires clause evaluate to true. I think it's because the event parameter in my lambda function invocable is a derived type of Event<C, T> ; it cannot match the predicate. An example Event type is from the enum construction:

    class Tick : public Event<Instance, Tick> {};

Here is how I call it, for example:

    Instance::Tick event;
    Dispatcher dispatcher(event);
    dispatcher.dispatch([](const Instance::Tick & event) {
        return true;
    });

on the other hand, modifying the lambda with auto compiles fine.

    dispatcher.dispatch([](const auto & event) { 
        return true;
    });

Is there a way to expand the concept to include any of the derived types, if that's the case?

If there isn't, can the predicate only require that the function returns true and is invocable, without constraints on the parameters?

Answer 1

I have the following event dispatcher relationship:

    enum class Type {type1, type2, ...};
    enum class Category {category1, category2, ...};    

    template <Category C, Type T>
    class Event<C, T>{
        public:
          virtual std::string name() const = 0;
          inline void consume(bool consume) { m_Consumed = consume; }
          inline bool consumed() const { return m_Consumed; }
        private:
          bool m_Consumed = false;
    };
    
    template <Category C, Type T>
    class Dispatcher {
        Dispatcher(Event<C, T> & event) : m_Event(event) {}
        template <class F> requires std::predicate<F, Event<C,T>>
        void dispatch(const F & function) {
            m_Event.consume(function(m_Event));
        }
    }

I'm unable to have the requires clause evaluate to true. I think it's because the event parameter in my lambda function invocable is a derived type of Event<C, T> ; it cannot match the predicate. An example Event type is from the enum construction:

    class Tick : public Event<Instance, Tick> {};

Here is how I call it, for example:

    Instance::Tick event;
    Dispatcher dispatcher(event);
    dispatcher.dispatch([](const Instance::Tick & event) {
        return true;
    });

on the other hand, modifying the lambda with auto compiles fine.

    dispatcher.dispatch([](const auto & event) { 
        return true;
    });

Is there a way to expand the concept to include any of the derived types, if that's the case?

If there isn't, can the predicate only require that the function returns true and is invocable, without constraints on the parameters?