Thinking in Functions

Thinking In Functions
Alex Bolboacă,  @alexboly,  alex.bolboaca@mozaicworks.com
February 2019

Last year…
CppEurope
Video available: https://www.youtube.com/watch?v=7L6oryyzZXc

About This Talk
• A practical approach to use functional programming in C++
• Focused on essentials and the mindset
• Not purist
• No maths
• Not touching on performance
• My Goal: You should ﬁnd at least one technique you can use in your
code

Two Fundamental Ideas
• Immutability
• Functions are data

Why Immutability?
The more obstacles one places in the translation between code and
behavior, the more mistakes (aka bugs) we can make and the least effective
we are as programmers.

Example of Mutable Code
How many implementation options exist?
int add(int& first, int& second){
...
}

Option 1
return first + second;
}

Option 2
return first += second;
}

Option 3
return second += first;
}

What’s the Semantics?
int add(int first, int second)
int add(int first, int& second)
int add(int& first, int second)
int add(int& first, int& second)
int add(int first, int* second)
int add(int& first, int* second)
int add(int* first, int* second)
int add(int* first, int second)
int add(int* first, int& second)

Immutable Code
// If standalone function
int add(const int& first, const int& second)
// If part of a class
int add(const int& first, const int& second) const
How many implementation options?

Immutable Code
// If standalone function
int add(const int& first, const int& second){
}
// If part of a class
int add(const int& first, const int& second) const{
}

Why Immutability?
Immutability simpliﬁes our translation effort, allowing your brain to focus on
adding more behavior.

Not a New Idea In C++
• Function pointers
• Functors

Let’s Represent Functions As Data
// Lambda variable
auto add = [](int first, int second){
};
More details: http://en.cppreference.com/w/cpp/language/lambda

Careful: Lambdas can be mutable
// Mutable
auto increment = [](int& value){return ++value};
int aValue = 42;
int incremented = increment(42);
assert(incremented == 43);
assert(aValue == 43)

Careful: Immutable Lambda
• Function call operator is const
• Parameters use their own speciﬁer
// Immutable
auto incrementImmutable = [](const int& value){
return value + 1;
};
int aValue = 42;
int incremented = increment(42);
assert(incremented == 43);
assert(aValue == 42)

Type Inference
// Does not compile
auto add(auto first, auto second){
}
// Works for any two values that have operator+ defined
auto add = [](const auto& first, const auto& second){
};

Value Capture
Lambdas can capture values from the context.
TEST_CASE(”type inference with lambdas”){
int first = 5;
auto add = [=](const auto& second){
};
CHECK_EQ(42, add(37));
CHECK_EQ(42.5, add(37.5));
}

Consequences
Functions are data.
We can do operations on data.
We can do operations on functions!

What is an Operation on Functions?
Any operation that takes one (or more functions) and returns a new function.
• Partial Application
• Functional Composition
• Currying
• Higher level functions

Partial Application
A function with n-1 parameters is obtained from a function with n
parameters by binding one parameter to a value.
using namespace std::placeholders;
auto divide = [](const auto& first, const auto& second){
return first/second;
};
int specialValue = 10;
auto divideSpecialValue = bind(divide, specialValue, _1);
// Equivalent with
// auto divideSpecialValue = [](const auto& second) {
// return 10 / second
// };

Functional Composition
Create a function h(x) from two functions f(y) and g(z), such that for any
value of x, h(x) = f(g(x)).
C++ doesn’t yet have a functional composition operator, so we have to write
our own function:
template<typename F, typename G>
auto compose(F f, G g){
return [f, g](auto x){
return f(g(x));
};
}

Example
auto increment = [](const auto& value){
return value + 1;
};
auto incrementTwice = compose(increment, increment);
/* Equivalent with:
auto incrementTwice = [&](const auto& value){
return increment(increment(value));
};
*/
CHECK_EQ(3, incrementTwice(1));

Currying
Decompose a function with N arguments into N functions with one argument
auto curriedAdd = [](const auto& first){
return [first](const auto& second){
};
};

Currying in C++
Unfortunately, there’s no operator that supports currying.
In pure functional languages, curry is done by default, and linked with
partial application. For example:
auto divide = [](const auto& first, const auto& second){
return first/second;
};
divide(5) => a new function that takes second as parameter, equ

Interesting Fact
Curry. Haskell Curry

Pass Functions as Parameters
TEST_CASE(”pass functions as parameters”){
vector<int> values{42, 1, 55, 23};
vector<int> expected{1, 23, 42, 55};
auto compare = [](const auto& first, const auto& second){
return (first < second);
};
sort(values.begin(), values.end(), compare);
CHECK_EQ(expected, values);
}

Short list of higher level functions
Find them in or
• ﬁnd_if
• transform
• reduce / accumulate
• count_if
• all_of / any_of / none_of
• …
See examples on https://github.com/MozaicWorks/functionalCpp

Conclusions
We can create functions from other functions through partial application,
composition, currying.
We can understand better the functions we write due to immutability.

Applying Functional Programming

Problem: TicTacToe Result
Given a TicTacToe board that’s either empty or already has moves, print out
the result of the game if the game ended or that the game is still in progress.

Approach
1. Clearly deﬁne the input; give examples
2. Clearly deﬁne the output; give examples
3. Identify a chain of functional transformations you can apply on the
input data to turn it into the output data

Clearly Define the Output
• Game not started
• Game in progress
• X won
• O won
• Draw

Clearly Define the Input
Empty Board:
_ _ _
_ _ _
_ _ _
X won by line:
X X X
O O _
_ _ _
etc.

Turns out that …
X wins if
• any line is filled with X OR
• any column is filled with X OR
• the main diagonal is filled with X OR
• the secondary diagonal is filled with X

Transformations
board ->
collection(all lines, all columns, all diagonals) ->
if any(collection, filledWithX) ->
X won
where
filledWithX(line|column|diagonal L) =
all(token on L equals 'X')

Remove duplication with functional operators
• Functions with the same parameter? Partial application! Or classes!
• Functions with the same structure? Higher level functions!
• Chained calls? Function composition!

Refactoring code through Immutability
Premise:
• Any program can be written as Input -> Pure Functions -> State change
(either UI or storage)
• This property of the code applies on multiple levels, even on a single
function

Refactoring Method
• Take a complex piece of code:
• extract a small piece of it as another method
• extract everything mutable as parameter
• until the method is immutable
• check by making everything const and compiling
• then decompose the long immutable function into smaller immutable
functions
• then recombine the functions into classes, based on the parameters
they use

We End Up With Functional OOP
• Data structures with set / get or public data
• “Processor” objects that receive data and return other data
• “Run and forget” objects: initialize, execute operations, throw it away
• Separate, pluggable, input / output objects

Hypothesis
Unconﬁrmed Hypothesis: this type of refactoring is safe even without tests.
(Or, we can easily generate tests for the immutable function with
property-based testing)

Conclusion
Immutability and functions as data can simplify programming
I invite you to try them out. Pick one and try it.

Learn more
Functional programming in C++: https:
//www.slideshare.net/alexboly/functional-programming-in-c-88970494
Hidden loops: https://www.slideshare.net/alexboly/hidden-loops
Removing structural duplication:
https://www.slideshare.net/alexboly/removing-structuralduplication

Learn more at Mozaic Works workshops
https://mozaicworks.com/training/c-plus-plus/

Pre-order my book!
Hands-on Functional Programming In C++ - http://bit.ly/FProgCpp

Thinking in Functions

More Related Content

What's hot (17)

Similar to Thinking in Functions (20)

More from Alexandru Bolboaca (20)

Recently uploaded (20)

Thinking in Functions