NDC{TechTown} - Modern Techniques for Keeping Your Code DRY

Modern DRY C++ – NDC{TechTown} 2019 © Björn Fahller @bjorn_fahller 1/125
Modern Techniques for Keeping Your Code DRY

Björn Fahller

View Slide

assert(state == IDLE || state == DISCONNECTING || state == DISCONNECTED);

View Slide


View Slide


Björn Fahller

View Slide

enum state_type { IDLE, CONNECTING, CONNECTED, DISCONNECTING, DISCONNECTED };

View Slide

variadic function template

View Slide

template
bool is_any_of(state_type s, const Ts& ... ts)
{
return ((s == ts) || ...);
}

View Slide

template
{
return ((s == ts) || ...);
}

View Slide

template
{
return ((s == ts) || ...);
}
assert(is_any_of(state, IDLE, DISCONNECTING, DISCONNECTED));

View Slide

template
{
return ((s == ts) || ...);
}
assert(is_any_of(state, IDLE, DISCONNECTING, DISCONNECTED));
Utterly unreadable
trash code!

View Slide

variadic non-type template parameter function template

View Slide

template
bool is_any_of(state_type t)
{
return ((t == states) || ...);
}

View Slide

template
{
}

View Slide

template
{
}
assert(is_any_of(state));

View Slide

auto for non-type template
parameters from C++17
template
bool is_any_of(const T& t)
{
return ((t == alternatives) || ...);
}

View Slide

template
bool is_any_of(const T& t)
{
return ((t == alternatives) || ...);
}
Not all types can be
used as non-type
template parameters
Only constexpr values
Yoda speak

View Slide

construct then test

View Slide


View Slide

template
auto is_in(const T& t)
{
return [t](const auto& ... vs) { return ((t == vs) || ...); };
}

View Slide

template
{
}
assert(is_in(state)(IDLE, DISCONNECTING, DISCONNECTED));

View Slide

template
{
}

View Slide

template
{
}
Works with all types
Looks horrible
Is a bit too terse

View Slide

explicit construct and compare function

View Slide

template
struct is {
T t;
template
bool any_of(const Ts& ... ts) const { return ((t == ts) || ...); }
};
template
is(T) -> is;

View Slide

template
struct is {
T t;
template
};
template
is(T) -> is;

View Slide

template
struct is {
T t;
template
};
template
is(T) -> is;
C++17 Deduction Guide for
Constructor Template Argument Deduction

View Slide

template
struct is {
T t;
template
};
template
is(T) -> is;
C++17 Deduction Guide for
Constructor Template Argument Deduction
https://youtu.be/-H-ut6j1BYU https://youtu.be/UDs90b0yjjQ

View Slide

template
struct is {
T t;
template
};
template
is(T) -> is;
assert(is{state}.any_of(IDLE, DISCONNECTING, DISCONNECTED));
Works with all types
Explicit
Still Yoda speak

View Slide

time passes...

View Slide

your mildly annoyed developer stays annoyed...

View Slide

Then one day, two years later!

View Slide


View Slide

template
struct any_of : private std::tuple
{
using std::tuple::tuple;
template
bool operator==(const T& t) const {
return std::apply([&t](const auto&… ts){ return ((ts == t) || ...);},
static_cast&>(*this));
}
};
template
any_of(Ts...) -> any_of;
assert(any_of(IDLE, DISCONNECTING, DISCONNECTED) == state);

View Slide

Pure laziness, but these
give me 18 constructors
template
{
template
return std::apply([&t](const auto&... ts){ return ((ts == t) || ...);},
}
};
template
assert(any_of(IDLE, DISCONNECTING, DISCONNECTED) == state);

View Slide

Call function with each member
of the tuple as a parameter.
template
{
template
}
};
template
assert(state == any_of(IDLE, DISCONNECTING, DISCONNECTED));

View Slide

template
{
template
}
template
friend bool operator==(const T& lh, const any_of& rh) { return rh == lh;}
};
template
Provide symmetric operator==

View Slide

template
{
template
}
template
};
template
Maybe exaggerated
cuteness, but I like this!

View Slide

template
{
template
}
template
};
template
https://gcc.godbolt.org/z/IY865r

View Slide

template
{
template
}
template
};
template

View Slide

template
{
template
}
template
};
template
Add relational operators!

View Slide

template
{
template
}
template
bool operator<(const T& t) const {
return std::apply([&t](const auto&... ts){ return ((ts < t) || ...);},
}
...
};
while (any_of(a, b, c) < 0) ...

View Slide

template
{
template
}
template
}
...
};

View Slide

template
{
template
}
template
}
...
};
https://gcc.godbolt.org/z/YyvAtT

View Slide

template
{
template
}
template
}
...
};

View Slide

template
{
template
}
template
}
...
};
An awful lot of
repetition here!

View Slide

template
bool or_elements(const F& f, const std::tuple& t)
{
return std::apply([&f](const auto& ... ts){ return (f(ts) || ...);}, t);
}

View Slide

template
{
}
template
{
template
return or_elements([&t](const auto& v){ return v == t;}, *this);
}
template
return or_elements([&t](const auto& v){ return v < t;}, *this);
}
};

View Slide

template
{
}
template
{
template
}
template
}
};
https://godbolt.org/z/SP8POJ

View Slide

template
{
}
template
{
template
}
template
}
};
each_of?
Repeat
Everything
Again?

View Slide

struct or_elements {
template
static bool apply(const F& f, const std::tuple& t) {
return std::apply([&](const auto& ... ts){ return (f(ts) || ...);}, t);
}
};
template
struct op_t : private std::tuple {
template
return Op::apply([&t](const auto& v){ return v == t;}, *this);
}
...
};
template
struct any_of : op_t {
using op_t::op_t;
};

View Slide

template
}
};
template
template
}
...
};
template
using op_t::op_t;
};

View Slide

struct and_elements {
template
return std::apply([&](const auto& ... ts){ return (f(ts) && ...);}, t);
}
};
template
template
}
...
};
template
struct each_of : op_t {
using op_t::op_t;
};

View Slide

template
}
};
template
template
}
...
};
template
using op_t::op_t;
};
template
using each_of = op_t; In a better world
we could deduce
constructor template
args for aliases
too

View Slide

template
}
};
template
template
}
...
};
template
using op_t::op_t;
};
https://gcc.godbolt.org/z/EAuUnM

View Slide

Can we try
something else?

View Slide

Can we try
something else?
Lambdas are so cool!

View Slide

constexpr auto tuple = [](auto ... ts)
{
return [=](const auto& func) { return func(ts...); };
};
assert(tuple(a,b,c)([](auto ... e){ return ((e > 0) && ...); }));

View Slide

{
};

View Slide

{
};
constexpr auto and_elements = [](auto func)
{
return [=](auto ... elements) { return (func(elements) && ...); };
};
assert(tuple(a,b,c)(and_elements([](auto e){ return e > 0;}));

View Slide

{
};
{
};

View Slide

{
};
{
};
constexpr auto bind_rh = [](auto func, auto rh)
{
return [=](auto lh) { return func(lh, rh); };
};

View Slide

{
};
{
return [=](auto … elements) { return (func(elements) && ...); };
};
{
};
constexpr auto greater_than = [](auto rh)
{
return bind_rh(std::greater{}, rh);
};

View Slide

{
};
{
};
{
};
{
};
assert(tuple(a,b,c)(and_elements(greater_than(0)));

View Slide

constexpr auto tuple = [](auto ... ts) ...
constexpr auto and_elements = [](auto func) ...
constexpr auto equal_to = [](auto rh) ...
constexpr auto greater_than = [](auto rh) ...
template
class op_t {
Tuple tup;
Func func;
template
auto apply(F f) const{ return tup(func(f)); }
public:
op_t(Func f, Tuple t) : tup(t), func(f) {}
template
auto operator==(const T& t) const { return apply(equal_to(t)); }
template
auto operator>(const T& t) const{ return apply(greater_than(t)); }
};
constexpr auto each_of=[](auto...ts){ return op_t(and_elements,tuple(ts...));};
assert(each_of(a,b,c) > 0);

View Slide

template
class op_t {
Tuple tup;
Func func;
template
public:
template
template
};

View Slide

template
class op_t {
Tuple tup;
[[no_unique_address]] Func func;
template
public:
template
template
};
C++20 attribute to make
empty member take no space.
If saving this byte is important
pre C++20, use private inheritance
for Empty Base Class Optimization.

View Slide

template
class op_t {
Tuple tup;
template
public:
template
template
};

View Slide

template
class op_t {
Tuple tup;
template
public:
template
template
};
https://gcc.godbolt.org/z/uyDzC8

View Slide

template
class op_t {
Tuple tup;
template
public:
template
template
};
Things to improve:

View Slide

template
class op_t {
Tuple tup;
template
public:
template
template
};
Things to improve:
●
constexpr

View Slide

template
class op_t {
Tuple tup;
template
constexpr auto apply(F f) const{ return tup(func(f)); }
public:
constexpr op_t(Func f, Tuple t) : tup(t), func(f) {}
template
constexpr auto operator==(const T& t) const { return apply(equal_to(t)); }
template
constexpr auto operator>(const T& t) const{ return apply(greater_than(t));}
};
Things to improve:
●
constexpr

View Slide

template
class op_t {
Tuple tup;
template
public:
template
template
};
Things to improve:
✔
constexpr
●
Perfect forwarding

View Slide

template
class op_t {
Tuple tup;
template
public:
template
template
};
Things to improve:
✔
constexpr
●
Perfect forwarding
●
Conditional noexcept

View Slide

template
class op_t {
Tuple tup;
template
public:
template
template
};
Things to improve:
✔
constexpr
●
Perfect forwarding
●
●
Explicit return type

View Slide

template
class op_t {
Tuple tup;
template
public:
template
template
};
Things to improve:
✔
constexpr
●
Perfect forwarding
●
●

View Slide

{
};

View Slide

constexpr auto and_elements = [](auto&& func)
{
return [func = std::forward(func)](auto ... elements) {
return (func(elements) && ...);
};
};

View Slide

constexpr auto and_elements = [](auto&& func)
{
};
};

View Slide

constexpr auto and_elements = [](T&& func)
{
};
}; C++20 allows us to
explicitly state template
parameters to lambdas.

View Slide

{
};
{
};
};

View Slide

constexpr auto tuple = [](auto&& ... ts)
{
};
{
};
};
Not possible to forward
parameter packs in
C++14 or C++17!

View Slide

constexpr auto tuple = [](auto&& ... ts)
{
return [...ts = std::forward(ts)](const auto& func) {
return func(ts...);
};
};
{
};
};
C++20 parameter pack
capture with perfect
forwarding.

View Slide

constexpr auto tuple = [](Ts&& ... ts)
{
return [...ts = std::forward(ts)](const auto& func) {
return func(ts...);
};
};
{
};
};

View Slide

constexpr auto tuple = [](Ts&& ... ts) ...
constexpr auto and_elements = [](T&& func) ...
template
class op_t {
Tuple tup;
template
constexpr auto apply(F&& f) const { return tup(func(std::forward(f))); }
public:
constexpr op_t(Func f, Tuple t) : Func(std::move(f)), tup(std::move(t)) {}
template
template
};
constexpr auto each_of=[](Ts&&... ts){
return op_t(and_elements,tuple(std::forward(ts)...));
};

View Slide

template
class op_t {
Tuple tup;
template
public:
template
template
};
};
Things to improve:
✔
constexpr
✔
Perfect forwarding
●
●

View Slide

{
return [...ts = std::forward(ts)](const auto& func)
{
return func(ts...);
};
};
{
return [func = std::forward(func)](auto … elements)
{
};
};

View Slide

3.08
{
noexcept(noexcept(func(ts...)))
{
return func(ts...);
};
};
{
return [func = std::forward(func)](auto ... elements)
noexcept(noexcept((func(elements) && ...)))
{
};
}; Yes, double parenthesis

View Slide

{
{
return func(ts...);
};
};
{
{
};
};
There’s no way around
this repetition!

View Slide

template
class op_t {
Tuple tup;
template
constexpr auto apply(F&& f) const
noexcept(noexcept(tup(func(std::forward(f)))))
{
return tup(func(std::forward(f)));
}
public:
constexpr op_t(Func f, Tuple t) : tup(std::move(t)), func(std::move(f)) {}
template
constexpr auto operator==(const T& t) const
noexcept(noexcept(apply(equal_to(t))))
{ return apply(equal_to(t)); }
...
};

View Slide

template
class op_t {
Tuple tup;
template
{
}
public:
template
...
};

View Slide

template
class op_t {
Tuple tup;
template
{
}
public:
template
...
};
Ugly ugly repetition!

View Slide

template
class op_t {
Tuple tup;
template
{
}
public:
template
...
};
Things to improve:
✔
constexpr
✔
Perfect forwarding
✔
●

View Slide

{
noexcept(noexcept(func(ts…)))
{
return func(ts...);
};
};
{
{
};
};

View Slide

Yes, double parenthesis
{
-> decltype(func(ts...))
{
return func(ts...);
};
};
{
-> decltype((func(elements) && ...))
{
};
};
3.08

View Slide

{
{
return func(ts...);
};
};
{
{
};
};
https://sacratomatovillepost.com/2017/10/03/stop-being-silly/

View Slide

{
{
return func(ts...);
};
};
{
{
};
};
www.youtube.com/watch?v=I3T4lePH-yA

View Slide

template
class op_t {
Tuple tup;
template
-> decltype(tup(func(std::forward(f))))
{
}
public:
template
-> decltype(apply(equal_to(t)))
Things to improve:
✔
constexpr
✔
Perfect forwarding
✔
✔

View Slide

That was

View Slide

Björn Fahller
That was

View Slide

Björn Fahller
That was
Remember

View Slide

Björn Fahller
That was
Remember
●
Fold expressions are awesome

View Slide

Björn Fahller
Remember
●
●
std::tuple<> and std::apply() is awsome

View Slide

Björn Fahller
Remember
●
●
●
Higher order functions are awesome

View Slide

Björn Fahller
Remember
●
●
●
●
Lambdas are awesome

View Slide

Björn Fahller
Remember
●
●
●
●
Lambdas are awesome
●
C++20 lambdas are awsomer!

View Slide

Björn Fahller
Remember
●
●
●
●
Lambdas are awesome
●
●
Compilers are awesome

View Slide

Björn Fahller
Remember
●
●
●
●
Lambdas are awesome
●
●
●
noexcept/SFINAE-return is aweso^H^Hful

View Slide

Björn Fahller
Remember
●
●
●
●
Lambdas are awesome
●
●
●
●
Sweating the small stuff makes you annoyed

View Slide

Björn Fahller
Remember
●
●
●
●
Lambdas are awesome
●
●
●
●
●
But it can lead to neat code

View Slide

[email protected]
@bjorn_fahller
@rollbear
Björn Fahller

View Slide

NDC{TechTown} - Modern Techniques for Keeping Your Code DRY

NDC{TechTown} - Modern Techniques for Keeping Your Code DRY

Björn Fahller

More Decks by Björn Fahller

Other Decks in Programming

Featured

Transcript