Передача лямбда выражения в функцию

class Node {
public:
    virtual bool Evaluate(const Date& date, const string& event) const = 0;
};
 
class DateComparisonNode : public Node {
public:
    DateComparisonNode(const Comparison& c, const Date& d)
        : cmp { c }
        , date_ { d }
    {
    }
    bool Evaluate(const Date& date, const string& event) const override
    {
        switch (cmp) {
        case Comparison::Less:
            return date < date_;
        case Comparison::LessOrEqual:
            return date <= date_;
        case Comparison::Greater:
            return date > date_;
        case Comparison::GreaterOrEqual:
            return date >= date_;
        case Comparison::Equal:
            return date == date_;
        case Comparison::NotEqual:
            return date != date_;
        }
        return -1;
    }
    const Comparison cmp;
    const Date date_;
};
 
class EventComparisonNode : public Node {
public:
    EventComparisonNode(const Comparison& c, const string& event)
        : cmp { c }
        , event_ { event }
    {
    }
    bool Evaluate(const Date& date, const string& event) const override
    {
        switch (cmp) {
        case Comparison::Equal:
            return event_ == event;
        case Comparison::NotEqual:
            return event_ != event;
        }
        return 0;
    }
    const Comparison cmp;
    const string event_;
};
 
class LogicalOperationNode : public Node {
public:
    LogicalOperationNode(const LogicalOperation& l_op, const shared_ptr<Node>& l, const shared_ptr<Node>& r)
        : logical_operation { l_op }
        , left { l }
        , right { r }
    {
    }
    bool Evaluate(const Date& date, const string& event) const override
    {
        switch (logical_operation) {
        case LogicalOperation::And:
            return left->Evaluate(date, event) && right->Evaluate(date, event);
        case LogicalOperation::Or:
            return left->Evaluate(date, event) || right->Evaluate(date, event);
        }
    }
    const LogicalOperation logical_operation;
    const shared_ptr<Node> left;
    const shared_ptr<Node> right;
};
 
class EmptyNode : public Node {
    bool Evaluate(const Date& date, const string& event) const
    {
        return 0;
    }
};
 
class Database {
public:
    Database() {}
    void Add(const Date& date, const string& event);
 
    bool DeleteEvent(const Date& date, const string& event);
 
    int DeleteDate(const Date& date);
 
    vector<string> FindIf(function<bool(Date, string)> f);
 
    void Print(ostream& ost);
 
private:
    map<Date, set<string>> db;
};
 
int main()
{
    TestAll();
 
    Database db;
 
    for (string line; getline(cin, line);) {
        istringstream is(line);
 
        string command;
        is >> command;
        if (command == "Add") {
            const auto date = ParseDate(is);
            const auto event = ParseEvent(is);
            db.Add(date, event);
        } else if (command == "Print") {
            db.Print(cout);
        } else if (command == "Del") {
            auto condition = ParseCondition(is);
            auto predicate = [condition](const Date& date, const string& event) {
                return condition->Evaluate(date, event);
            };
            //                int count = db.RemoveIf(predicate);
            //                cout << "Removed " << count << " entries" << endl;
        } else if (command == "Find") {
            auto condition = ParseCondition(is);
            auto predicate = [condition](const Date& date, const string& event) {
                return condition->Evaluate(date, event);
            };
            const auto entries = db.FindIf(predicate);
            for (const auto& entry : entries) {
                cout << entry << endl;
            }
            cout << "Found " << entries.size() << " entries" << endl;
        } else if (command == "Last") {
            try {
                //                    cout << db.Last(ParseDate(is)) << endl;
            } catch (invalid_argument&) {
                cout << "No entries" << endl;
            }
        } else if (command.empty()) {
            continue;
        } else {
            throw logic_error("Unknown command: " + command);
        }
    }
 
    return 0;
}

function<bool(Date, string)>
//-->
auto predicate = [condition](const Date& date, const string& event)

vector<string> Database::FindIf(function<bool(const Date& date, const string& event)> f);
{
    return { "123" };
}

vector<string> Database::FindIf(function<bool(const Date& date, const string& event)> f);
{
    vector<string> copy;
    for (auto set_ : db)
        for (auto item : set_.second)
            if (f(set_.first, item)) {
                ostringstream ost();
                ost << set_.first;
                copy.push_back(ost.str() + ' ' + item);
            }
    return copy;
}

vector<string> Database::FindIf(const function<bool(const Date& date, const string& event)>& f)
{
    vector<string> copy;
    for (const auto& set_ : db)
        for (const auto& item : set_.second)
            if (f(set_.first, item)) {
                ostringstream ost();
                ost << set_.first;
                copy.emplace_back(ost.str() + ' ' + item);
            }
    return copy;
}