MeetingC++ : Higher order functions for ordinary C++ developers

Higher Order Functions – Meeting C++ 2018 © Björn Fahller @bjorn_fahller 1/93
compose([](auto const& s) { return s == "foo";},
std=:mem_fn(&foo=:name))
Higher Order Functions for Ordinary C++ Developers
Björn Fahller

View Slide

Very brief intro to higher order functions
Gradually expanding example
optional (and extension)
Managing overload sets

View Slide

Definition
A higher-order function is a function
that takes other functions as arguments
or returns a function as result.

View Slide

#include
#include
std=:vector v;
==.
if (std=:none_of(std=:begin(v), std=:end(v),
[](int x) { return x == 0; })) {
==.
}

View Slide

#include
#include
std=:vector v;
==.
[](int x) { return x == 0; })) {
==.
}
template
bool none_of(Iterator i, Iterator e, Predicate predicate)
{
while (i == e)
{
if (predicate(*i)) return false;
i=+;
}
return true;
}

View Slide

#include
#include
std=:vector v;
==.
[](int x) { return x == 0; })) {
==.
}
==.
int num;
==.
while (std=:any_of(std=:begin(v), std=:end(v),
[num](int x){ return x == num; })) {
==.
}

View Slide

[num](int x){ return x == num; }

View Slide

auto equals(int num)
{
return [num](int x){ return x == num; };
}

View Slide

auto equals(int num)
{
return [num](int x){ return x == num; };
}
std=:function equals(int num)
{
return [num](int x) { return x == num; };
}

View Slide

template
auto equals(T key)
{
return [key](auto const& x){ return x == key; };
}

View Slide

template
auto equals(T key)
{
}
template
std=:function equals(T key)
{
return [key](T x) { return x == key; };
}

View Slide

template
auto equals(T key)
{
}
template
{
}
Callable with anything equality
comparable with T, for example
C-string and std=:string

View Slide

template
auto equals(T key)
{
}
template
{
}
Callable with anything equality
comparable with T, for example
C-string and std=:string
Only callable with T, because
std=:function=> does not have
a templated function call operator.

View Slide

template
auto equals(T key)
{
}

View Slide

#include
#include
std=:vector v;
==.
if (std=:none_of(std=:begin(v), std=:end(v), equals(0)) {
==.
}
==.
int num;
==.
while (std=:any_of(std=:begin(v), std=:end(v), equals(num)) {
==.
}

View Slide

Live demo!

View Slide

✔Very brief intro to higher order functions
Gradually expanding example

View Slide

struct ip_address
{
ip_address(uint8_t i1, uint8_t i2, uint8_t i3, uint8_t i4)
: num((uint32_t(i1) =< 24) | (uint32_t(i2) =< 16) | (uint32_t(i3) =< 8) | i4) {}
ip_address(uint32_t n) : num(n) {}
bool operator==(ip_address rh) const { return num == rh.num;}
bool operator==(ip_address rh) const { return !(*this == rh);}
uint32_t num;
};
struct netmask : ip_address
{
using ip_address=:ip_address;
};
inline ip_address operator&(ip_address lh, netmask rh)
{
return {lh.num & rh.num};
};

View Slide

struct ip_address
{
uint32_t num;
};
{
};
{
};

View Slide

struct ip_address
{
uint32_t num;
};
{
};
{
};
auto ip_matches(ip_address desired,
netmask mask = netmask{255,255,255,255})
{
return [desired, mask](ip_address actual)
{
return (desired & mask) == (actual & mask);
};
}

View Slide

struct ip_address
{
uint32_t num;
};
{
};
{
};
{
{
};
}

View Slide

struct ip_address
{
uint32_t num;
};
{
};
{
};
{
{
};
}
std=:vector v;
==.
auto i = std=:remove_if(v.begin(), v.end(),
ip_matches({192,168,1,1}, {255,255,0,0}));

View Slide

class ipif
{
public:
using state_type = enum { off, on };
==.
void set_state(state_type);
state_type state() const { return state_; }
ip_address address() const { return addr_; }
netmask mask() const { return mask_; }
ip_address gateway() const { return gw_; }
private:
ip_address addr_;
netmask mask_;
ip_address gw_;
state_type state_;
};

View Slide

class ipif
{
public:
==.
private:
ip_address addr_;
netmask mask_;
ip_address gw_;
state_type state_;
};

View Slide

class ipif
{
public:
==.
private:
ip_address addr_;
netmask mask_;
ip_address gw_;
state_type state_;
};
To match, for example the
address of an ipif,
we need to make the
ip_matches() predicate work
on a member.

View Slide

class ipif
{
public:
==.
private:
ip_address addr_;
netmask mask_;
ip_address gw_;
state_type state_;
};
Given:
f1(y) -> z
and
f2(x) -> y
We want a composition f(x)->z as f1(f2(x))

View Slide

class ipif
{
public:
==.
private:
ip_address addr_;
netmask mask_;
ip_address gw_;
state_type state_;
};
Given:
f1(y) -> z ip_matches(ip_address) -> bool
and
f2(x) -> y select_address(ipif) -> ip_address

View Slide

class ipif
{
public:
==.
private:
ip_address addr_;
netmask mask_;
ip_address gw_;
state_type state_;
}; template
auto compose(F1 f1, F2 f2)
{
return [=](auto const& x) { return f1(f2(x)); };
}
Given:
f1(y) -> z ip_matches(ip_address) -> bool
and
f2(x) -> y select_address(ipif) -> ip_address

View Slide

class ipif
{
public:
==.
ip_address address() const { return addr_;}
==.
private:
ip_address addr_;
==.
};
std=:vector interfaces;
auto i = std=:find_if(interfaces.begin(), interfaces.end(),
compose(ip_matches({192,168,1,1}),
select_address));

View Slide

class ipif
{
public:
==.
==.
private:
ip_address addr_;
==.
};
ip_address select_address(ipif const& interface)
{
return interface.address();
}
select_address));

View Slide

class ipif
{
public:
==.
==.
private:
ip_address addr_;
==.
};
auto address_matches(ip_address addr, netmask mask = {255,255,255,255})
{
return compose(ip_matches(addr, mask),
select_address);
}
select_address);

View Slide

class ipif
{
public:
==.
==.
private:
ip_address addr_;
==.
};
auto address_matches(ip_address addr, netmask mask = {255,255,255,255})
{
select_address);
}
address_matches({192,168,1,1}));

View Slide

class ipif
{
public:
==.
==.
};
inline ip_address select_gateway(ipif const& interface)
{
return interface.gateway();
}
inline ipif=:state_type select_state(ipif const& interface)
{
return interface.state();
}

View Slide

auto i = find_if(v.begin(), v.end(),
when_all(address_matches({192,168,1,1},{255,255,0,0}),
state_is(ipif=:off)));

View Slide

template
auto when_all(Predicates ==. ps)
{
return [=](auto const& x)
{
return (ps(x) =& ==.);
};
}

View Slide

template
{
{
};
}
auto address_matches(ip_address addr, netmask mask=netmask{255,255,255,255})
{
select_addr);
}

View Slide

template
{
{
};
}
auto address_matches(ip_address addr, netmask mask=netmask{255,255,255,255})
{
select_addr);
}
auto state_is(ipif=:state_type state)
{
return compose(equals(state),
select_state);
}

View Slide

for_each(v.begin(), v.end(),
if_then(when_all(address_matches({192,168,1,1}, {255,255,0,0}),
state_is(ipif=:off)),
set_state(ipif=:on)));

View Slide

template
auto if_then(Predicate predicate, Action action)
{
return [=](auto=& x)
{
if (predicate(x)) {
action(std=:forward(x));
}
};
}

View Slide

template
auto if_then(Predicate predicate, Action action)
{
return [=](auto=& x)
{
if (predicate(x)) {
action(std=:forward(x));
}
};
}
auto set_state(ipif=:state_type state)
{
return [=](ipif& interface) { interface.set_state(state); };
}

View Slide

Live demo!

View Slide

✔Gradually expanding example

View Slide

std=:optional

View Slide

std=:optional
●
The class template std=:optional manages an optional
contained value, i.e. a value that may or may not be present.

View Slide

std=:optional
●
●
Since C++17
– available for older versions in various open source libraries

View Slide

std=:optional
●
●
Since C++17
●
Very useful in lookup functions

View Slide

std=:optional
●
●
Since C++17
●
Very useful in lookup functions
●
T must not be a reference
– Minor inconvenience, use std=:reference_wrapper

View Slide

template
std=:optional lookup(std=:vector& ifs, Predicate pred)
{
auto iter = std=:find_if(ifs.begin(), ifs.end(), pred);
if (iter == ifs.end()) return std=:nullopt;
return {*iter};
}

View Slide

template
std=:optional lookup(std=:vector& ifs, Predicate pred)
{
if (iter == ifs.end()) return std=:nullopt;
return {*iter};
}
void do_stuff(ipif&);
void some_func()
{
=/==.
auto found = lookup(ip_interfaces, address_matches({192,168,1,1}));
if (found)
{
do_stuff(found.value());
}
=/
}

View Slide

Simon Brand
@tartanllama
https:=/github.com/TartanLlama/optional
C++11/14/17 std=:optional with functional-style extensions and
reference support https:=/optional.tartanllama.xyz

View Slide

Simon Brand
@tartanllama
Standards proposal P0798R2: Monadic operations for std::optional.

View Slide

Simon Brand
@tartanllama
#include
int i = 3;
tl=:optional v; =/ no value
v = i; =/ v refers to i

View Slide

Simon Brand
@tartanllama
#include
int i = 3;
v.value() = 4; =/ i == 4

View Slide

Simon Brand
@tartanllama
#include
int i = 3;
v.value() = 4; =/ i == 4
int j = 2;
v = j; =/ i == 4. v bound to j

View Slide

Simon Brand
@tartanllama
#include
int i = 3;
v.value() = 4; =/ i == 4
int j = 2;
==.
v.and_then([&v](int& n) { n = 2; return v;});
v.or_else([](){std=:cout =< "nothing\n"; });
v.or_else([&](){return tl=:optional{i};});

View Slide

Simon Brand
@tartanllama
#include
int i = 3;
v.value() = 4; =/ i == 4
int j = 2;
==.
v.and_then([&v](int& n) { n = 2; return v;})
.or_else([](){std=:cout =< "nothing\n"; })
.or_else([&](){return tl=:optional{i};});

View Slide

template
tl=:optional lookup(std=:vector& ifs, Predicate pred)
{
if (iter == ifs.end()) return tl=:nullopt;
return {*iter};
}
void do_stuff(ipif&);
void some_func()
{
=/==.
auto found = lookup(ip_interfaces, address_matches({192,168,1,1}));
if (found)
{
do_stuff(found.value());
}
=/
}

View Slide

template
{
return {*iter};
}
tl=:optional do_stuff(ipif&);
void some_func()
{
=/==.
lookup(ip_interfaces, address_matches({192,168,1,1}))
.and_then(do_stuff);
=/
}

View Slide

template
{
return {*iter};
}
void some_func()
{
=/==.
.and_then(set_state(ipif=:off));
=/
}

View Slide

template
{
return {*iter};
}
void some_func()
{
=/==.
.and_then(set_state(ipif=:off))
.or_else([](){std=:cerr =< “Failed\n”;});
=/
}

View Slide

Live demo!

View Slide

✔optional (and extension)

View Slide

class ipif
{
public:
==.
ip_address addr() const { return addr_;}
};
ip_address select_addr(ipif const& interface)
{
return interface.addr();
}

View Slide

class ipif
{
public:
==.
};
{
}
std=:vector
addresses(std=:vector& const v)
{
std=:vector rv;
std=:transform(std=:begin(v), std=:end(v),
std=:back_inserter(rv),
select_addr);
return rv;
}

View Slide

class ipif
{
public:
==.
};
{
}
class street_address;
class customer {
==.
street_address addr() const { return addr_; }
};
street_address select_addr(customer const& c)
{
return c.addr();
}
std=:vector
{
std=:vector rv;
select_addr);
return rv;
}

View Slide

class ipif
{
public:
==.
};
{
}
class customer {
==.
};
{
return c.addr();
}
std=:vector
{
std=:vector rv;
select_addr);
return rv;
}
example.cpp
(40): error C2672: 'std=:transform': no matching overloaded function found
(40): error C2783: '_OutIt std=:transform(_InIt,_InIt,_OutIt,_Fn1)': could not deduce
template argument for '_Fn1'

View Slide

class ipif
{
public:
==.
};
{
}
class customer {
==.
};
{
return c.addr();
}
std=:vector
{
std=:vector rv;
select_addr);
return rv;
}
:38:5: error: no matching function for call to 'transform'
^~~~~~~~~~~~~~
==./include/c=+/7.2.0/bits/stl_algo.h:4295:5: note: candidate template ignored:
couldn't infer template argument '_UnaryOperation'
transform(_InputIterator =_first, _InputIterator =_last,
^
==./include/c=+/7.2.0/bits/stl_algo.h:4332:5: note: candidate function template not viable:
requires 5 arguments, but 4 were provided
transform(_InputIterator1 =_first1, _InputIterator1 =_last1,
^

View Slide

class ipif
{
public:
==.
};
{
}
class customer {
==.
};
{
return c.addr();
}
std=:vector
addresses(std=:vector const& v)
{
std=:vector rv;
select_addr);
return rv;
}

View Slide

class ipif
{
public:
==.
};
{
}
class customer {
==.
};
{
return c.addr();
}
std=:vector
{
std=:vector rv;
select_addr);
return rv;
}
How to solve this?

View Slide

class ipif
{
public:
==.
};
{
}
class customer {
==.
};
{
return c.addr();
}
std=:vector
{
std=:vector rv;
select_addr);
return rv;
}
Solution #1

View Slide

class ipif
{
public:
==.
};
{
}
class customer {
==.
};
{
return c.addr();
}
std=:vector
{
std=:vector rv;
select_addr);
return rv;
}
¯\_( ツ )_/¯

View Slide

class ipif
{
public:
==.
};
{
}
class customer {
==.
};
{
return c.addr();
}
std=:vector
{
std=:vector rv;
select_addr);
return rv;
}
¯\_( ツ )_/¯
●
This is rarely a problem, so why worry?
●
Arrange your code such that only one
version is needed in the same source file.

View Slide

class ipif
{
public:
==.
};
{
}
class customer {
==.
};
{
return c.addr();
}
std=:vector
{
std=:vector rv;
select_addr);
return rv;
}
Solution #2

View Slide

class ipif
{
public:
==.
};
{
}
class customer {
==.
};
{
return c.addr();
}
std=:vector
{
std=:vector rv;
[](auto const& p) {
return select_addr(p);
});
return rv;
}
●
Call through a generic lambda for the access

View Slide

class ipif
{
public:
==.
};
{
}
class customer {
==.
};
{
return c.addr();
}
std=:vector
{
std=:vector rv;
[](auto const& p) {
return select_addr(p);
});
return rv;
}
●
Call through a generic lambda for the access
+ OK to write and use occasionally
- Becomes cumbersome if needed frequently

View Slide

class ipif
{
public:
==.
};
{
}
class customer {
==.
};
{
return c.addr();
}
std=:vector
{
std=:vector rv;
select_addr);
return rv;
}
Solution #2b

View Slide

class ipif
{
public:
==.
};
{
}
class customer {
==.
};
{
return c.addr();
}
std=:vector
{
std=:vector rv;
LIFT(select_addr));
return rv;
}
●
Macro for a generic lambda for the access
#define LIFT(func) \
[](auto=& ==. p) \
{ \
return func(std=:forward(p)==.)); \
}

View Slide

class ipif
{
public:
==.
};
{
}
class customer {
==.
};
{
return c.addr();
}
std=:vector
{
std=:vector rv;
LIFT(select_addr));
return rv;
}
●
Macro for a generic lambda for the access
#define LIFT(func) \
[](auto=& ==. p) \
{ \
return func(std=:forward(p)==.)); \
}
+ Fairly easy to use
- Macros are evil

View Slide

Live demo!

View Slide

✔optional (and extension)
✔Managing overload sets

View Slide

Domain specific functions
●
ip_matches(ip, mask)
●
select_address(ipif)
●
select_gateway(ipif)
●
select_state(ipif)
●
set_state(ipif&)
Composed domain specific functions
●
address_matches(ip)
●
state_is(state_type)
Generic library functions
●
equals(value) ...
●
compose(function...)
●
if_then(pred,action)
●
when_all(predicate...)
●
when_none(predicate...)
●
when_any(predicate...)
●
do_all(action...)
●
LIFT(overload_set)

View Slide

https://github.com/rollbear/lift
●
equals(value) ...
●
●
●
●
●
●
do_all(action...)
●
LIFT(overload_set)
●
●
●
●
select_state(ipif)
●
set_state(ipif&)
●
address_matches(ip)
●

View Slide

●
equals(value) ...
●
●
●
●
●
●
do_all(action...)
●
LIFT(overload_set)
●
●
●
●
select_state(ipif)
●
set_state(ipif&)
●
address_matches(ip)
●
As of Boost 1.67.0 (April 14th, 2018)
boost::hof (higher order functions)
https://www.boost.org/doc/libs/1_68_0/libs/hof/

View Slide

Take away messages
●
Write functions that uses auto return type to create lambdas

View Slide

Take away messages
●
●
Write functions that access or modify your state

View Slide

Take away messages
●
●
●
Compose functions
●
And give names to the compositions

View Slide

Take away messages
●
●
●
Compose functions
●
●
Functional extensions to optional and expected
removes the need for many conditionals

View Slide

Take away messages
●
●
●
Compose functions
●
●
Functional extensions to optional and expected
removes the need for many conditionals
●
Overloads can be a bit of a bother.

View Slide

Resources
Pacific++ 2018: Toby Allsopp
“Surfacing Composition”
www.youtube.com/watch?v=_x1EvX-q3QU
CppCon 2018: Simon Brand
“Overloading: The Bane of All Higher-Order Functions”
www.youtube.com/watch?v=L_QKlAx31Pw
https://www.boost.org/doc/libs/1_68_0/libs/hof/
Functional Programming in C++
Ivan Čukić
ISBN 1617293814

View Slide

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

View Slide

MeetingC++ : Higher order functions for ordinary C++ developers

MeetingC++ : Higher order functions for ordinary C++ developers

Björn Fahller

More Decks by Björn Fahller

Other Decks in Programming

Featured

Transcript