Comments on: Functors are not dead: the double functor trick

By: Tony Lewis

Tony Lewis — Fri, 17 Mar 2017 12:01:00 +0000

Nice post. Thanks.

Whilst you’re on the theme of comparing elements with a value of a different type, it might be worth mentioning the projection functions adopted in the ongoing Ranges work by Eric Niebler and others. In these sorts of contexts, the projections can often make things substantially cleaner and more expressive than with the std algorithms, eg you could sort your vector of Employees by ID with something like:

sort(
employees,
less{},
[] (const Employee &e){ return e.getId(); }
);

See:
* Eric’s range-v3 library: https://github.com/ericniebler/range-v3
* eg start of cppreference documentation of ranges proposal for the Standard http://en.cppreference.com/w/cpp/experimental/ranges/algorithm/sort

By: Vladislav Kaplan

Vladislav Kaplan — Tue, 14 Mar 2017 10:24:00 +0000

Thank you for the article

By: Jonathan Boccara

Jonathan Boccara — Sun, 12 Mar 2017 21:12:00 +0000

In reply to Arne Mertz. Thanks Arne for taking the time to point this out.

By: Jonathan Boccara

Jonathan Boccara — Sun, 12 Mar 2017 21:12:00 +0000

In reply to Yehezkel. This is interesting indeed! Thanks Yehezkel for sharing.

By: Jonathan Boccara

Jonathan Boccara — Sun, 12 Mar 2017 21:11:00 +0000

In reply to DimanNe DimanNe. Thanks for pointing this out, I've included this info in the body of the post.

By: Yehezkel

Yehezkel — Sun, 12 Mar 2017 18:59:00 +0000

With C++17 “constexpr if” you can do something like:
auto comparator = [](auto const& a, auto const& b) {
if constexpr (typeid(a) == typeid(int) && typeid(b) == typeid(Employee))
return a < b.getReference();
else if constexpr (typeid(a) == typeid(Employee) && typeid(b) == typeid(int))
return a.getReference() < b;
else
static_assert(false, "Unsupported argument types");
};

🙂

By: DimanNe DimanNe

DimanNe DimanNe — Fri, 10 Mar 2017 16:40:00 +0000

Why can’t you just inherit from two lambdas?
auto Lambda1 = [](std::string s) { return s; };
auto Lambda2 = [](int ) { return “int”; };
auto MultiLambda = MakeMultiLambda(Lambda1, Lambda2, Lambda3);
std::cout << MultiLambda(3) << std::endl;
std::cout << MultiLambda("qwer") << std::endl;

Search for "Lambda overloading" here – https://sites.google.com/view/compthoughts/c

By: Arne Mertz

Arne Mertz — Fri, 10 Mar 2017 14:02:00 +0000

Hi Jonathan, nice article!
There is a proposal (P0051) for a generalized overload function that combines function objects like lambdas. With that, your “CompareWithReference” class could be written on the fly as

overload (
[](Employee const& employee, int reference) { return employee.getReference() < reference; },
[](int reference, Employee const& employee) { return reference < employee.getReference(); }
)

In this case, it's not as nice to read as the named function object, but in some cases (e.g. std::visit) it comes handy. I have included an example and a simplified implementation of overload for lambdas here: http://foonathan.net/blog/2017/03/01/tuple-iterator.html

In general I agree with you, however: Lambdas are not the silver bullet people are looking for.