Combine lambdas with operators

Question

I want to know if it is possible to chain a bunch of lambdas so that I can use them all at once, something like this:

std::vector<int> vec{1, 2, 3};
auto f1 = [](int i){return i == 1;};
auto f2 = [](int i){return i == 2;};

// What template type can I use for logical_or ?
auto f = combine(std::logical_or, f1, f2); 

vec.erase(std::remove_if(vec.begin(), vec.end(), f), vec.end());

So far I was thinking something like this:

template <typename OP, typename T>
T combine(const OP& op, const T& t1, const T& t2) {
    return t1 op t2;
}

template <typename OP, typename T, typename... Ts>
T combine(const OP& op, const T& t1, const T& t2, const Ts&... ts) {
    return t1 op t2 op combine(op, ts...);
}

But lambda || lambda doesn't make sense. Is what I'm trying to do possible?

You need to call the lambdas with arguments: op(t1(arg), t2(arg)) — Barmar
– Barmar, Commented Apr 13, 2018 at 2:20
how about auto f = [&](int i) { return f1(i) || f2(i); }; ? — Jarod42
– Jarod42, Commented Apr 13, 2018 at 2:36
Am I the only one who thinks the code vec.erase(std::remove_if(vec.begin(), vec.end(), f), vec.end()); is problematic? The outer erase call seems to be useless. — Lingxi
– Lingxi, Commented Apr 13, 2018 at 2:39

Jarod42 · Accepted Answer · 2018-04-13 02:54:40Z

3

You might create class to do the job:

template <typename ... Fs>
struct AnyOf
{
public:
    AnyOf(Fs... fs) : fs(fs...) {};

    template <typename ...Ts>
    decltype(auto) operator()(Ts&&... args) const
    {
        return call(std::index_sequence_for<Fs...>(), std::forward<Ts>(args)...);
    }

private:
    template <std::size_t ...Is, typename ...Ts>
    decltype(auto) call(std::index_sequence<Is...>, Ts&&... args) const
    {
        return (... || std::get<Is>(fs)(args...));
    }
private:
    std::tuple<Fs...> fs;
};

With usage:

auto f = AnyOf(f1, f2); // C++17 way.
                        //previously, template function `MakeAnyOf` should be implemented

Demo

answered Apr 13, 2018 at 2:54

Jarod42

227k15 gold badges214 silver badges350 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

user3666471 Over a year ago

That looks very cool!! The fold statement in the call function is C++17 only right? Is it possible to do something like that in C++14?

Jarod42 Over a year ago

Yes it is fold expression, you can do similar code using c++14 only but it is more verbose (and extra difficulty is to respect short-circuit evaluation).

apple apple · Accepted Answer · 2018-04-13 04:48:36Z

2

try this functional one-liner (it use fold expression so it's c++17)

auto any_combiner = [](auto&& ...fs){return [=](auto&& ...params){return (fs(params...) ||...);};}; 
auto any = any_combiner(f1,f2);

Wandbox example

or you can simply use std::any_of for || (and std::all_of for &&), and it's c++11

vector<function<bool(int)>> fs = {f1,f2};
auto any = [&](int i){return std::any_of(fs.begin(),fs.end(),[i](function<bool(int)>&f){return f(i);});};

or what's wrong with plain old for, it so simple! (basically std::any_of)

vector<function<bool(int)>> fs = {f1,f2};
auto any = [&](int i){
    for(auto& f:fs)
        if(f(i))
            return true;
    return false;
};

edited Apr 13, 2018 at 4:48

answered Apr 13, 2018 at 3:58

apple apple

10.7k2 gold badges20 silver badges41 bronze badges

Comments

Yakk - Adam Nevraumont · Accepted Answer · 2018-04-13 03:04:21Z

1

template<class F>
struct logical_f;
template<class F>
logical_f<F> logical( F f ){
  return std::move(f);
}
template<class F>
struct logical_f:F{
  logical_f(F in):F(std::move(in)){}
  template<class O>
  friend auto operator||( logical_f self, logical_f<O> const& o ) {
    auto r = [lhs=std::move(self.f), rhs=o.f](auto&&...args)->bool{
      return lhs(args...)||rhs(args...);
    };
    return logical(std::move(r));
};

now you can do:

auto f = logical(f1) || logical(f2);

In c++17 you can fold over ||; prior to that you can use hand written functions that do the folding.

answered Apr 13, 2018 at 3:04

Yakk - Adam Nevraumont

280k31 gold badges367 silver badges585 bronze badges

1 Comment

user3666471 Over a year ago

Very helpful! Thanks!

Collectives™ on Stack Overflow

Combine lambdas with operators

3 Answers 3

2 Comments

Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

2 Comments

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related