Monadic Operations in Modern
C++: A Practical Approach
2
About me
● Vitaly Fanaskov
● Senior software engineer at reMarkable
● 10+ years of C++ experience
● GIS, VFX, frameworks, and libraries
● Ph.D (CS)
3
Agenda
● Briefly about expected and optional
● Common use cases of expected
● Monadic operations in software development
● Tips and tricks
4
In this talk
● Less theory
● C++ only
● Practical examples
5
Where do examples come from?
6
Our internal framework
Library 1 Module 1 Bundle 1
Library 2 Module 2 Bundle 2
Library 3 Module 3 Bundle 3
… … …
Library N Module N Bundle N
7
User interface subsystem
● Collect windows and widgets from modules
● Use bindings to 3rd party libraries (e.g. Qt) to display them
● Navigation
8
Technologies we use
● C++ 20
● vcpkg
● Many 3rd-party libraries (e.g. ranges-v3, tl-expected, catch2 etc)
● Qt for UI on devices
9
Briefly about Qt
C++ code: QML code:
● Business logic ● UI-related things
● Integration
● System-level
10
Briefly about classes
11
std::optional
#include <optional> ● Contains a value
● …or doesn’t contain a value
● Close to std::pair<T, bool>
std::optional<int> optionalBox;
optionalBox = 42;
fmt::println(
"The value is: {}",
optionalBox.value());
12
std::optional as a return value
When an operation can fail, but it doesn't matter why:
template<class T>
[[nodiscard]]
std::optional<std::size_t> Vector<T>::indexOf(const T &element) const {
./ Do lookup...
return std::nullopt; ./ If not found
}
13
std::optional as a parameter
When you need to pass some auxiliary arguments:
Url resolveUrl(
std::string_view input,
std::optional<Configuration> configuration = std::nullopt)
{
./ Read configuration if any
./ Resolve
}
14
It’ll be iterable
C++ 26
The optional object is a view that contains either one element if it contains a value, or otherwise
zero elements if it does not contain a value. The lifetime of the contained element is bound to the
object.
15
std::expected
#include <expected> ● Either a value
● …or an error
● Close to std::variant<T, E>
std::expected<int, Error> expectedBox;
expectedBox = 42;
fmt::println(
"The value is: {}",
expectedBox.value());
16
std::expected as a return value
When an operation can fail and we need to know why:
std::expected<Widget, WidgetError> loadWidget()
{
./ If error
return std::unexpected(WidgetError{ .* ... ./ });
./ Actual result
return Widget{ .* ... ./ };
}
17
Where can I get it?
● std::*
● tl::* (via vcpkg or Conan)
18
Use cases
19
What do we use?
● std::expected (approximately 90% of all cases)
● Error handling
● To unify interface
20
Process std::expected
void loadWidget()
{
if (const auto widgetBox = getNewWidget(); widgetBox.has_value()) {
const auto widget = widgetBox.value();
./ Do something with the widget ...
} else {
const auto error = widgetBox.error();
./ Handle the error ...
}
}
21
That was not entirely bad example…
void loadWidgetV2()
{
const auto widgetBox = getNewWidget();
if (widgetBox.has_value()) {
./ Do something with the widget ...
} else {
const auto error = widgetBox.error();
log("Cannot get a new widget {}: {}.", widgetBox.value(), error);
}
}
22
How do we handle this?
23
Monadic operations: and_then
if (const auto widgetBox = getNewWidget(); widgetBox.has_value()) {
const auto widget = widgetBox.value();
./ Do something with the widget ...
}
getWidget().and_then(
[](const auto &widget) :> std::expected<Widget, WidgetError> {
./ Do something with the widget ...
return widget;
});
24
Monadic operations: transform
if (const auto widgetBox = getWidget(); widgetBox.has_value()) {
const auto widget = widgetBox.value();
return widget.id();
}
getWidget().transform([](const auto &widget) :> ID { return widget.id(); });
25
Monadic operations: or_else
if (const auto widgetBox = getWidget(); widgetBox.has_value()) {
./ ...
} else {
log(widgetBox.error());
}
getWidget().and_then(.* ... ./).or_else([](const auto& error){ log(error); });
26
Monadic operations: transfrom_error
if (const auto widgetBox = getWidget(); widgetBox.has_value()) {
./ ...
} else {
return fmt::to_string(widgetBox.error());
}
getWidget().and_then(.* ... ./).transform_error(&fmt::to_string<WidgetError>);
27
On the way to software development
28
Key parts
● People
● Design
● Start with small pieces
29
People
30
An example: widget ID – left or right?
std::expected<ID, WidgetError> loadWidget() std::expected<ID, WidgetError> loadWidget()
{ {
if (const auto widgetBox = getWidget()) { return getWidget()
const auto widget = widgetBox.value(); .* .and_then ... ./
.transform(&Widget::id);
./ Do something with the widget ... }
return widget.id();
} else {
return {};
}
}
31
Observations
● Functional programming is difficult for many
● Combining functions using “monadic operations” is not straightforward
● std::optional and std::expected is terra incognita
32
What should I do about this?
● Show practical benefits (e.g. less boilerplate code)
● Do more workshops
● Do design review
33
Design
34
You will not be doing purely functional programming
● There will be side effects
● There will be object-oriented-style parts of the existing code base
● There will be integration with 3rd-party libraries
● …
35
Try splitting functional-style code from the rest
● A part where we use “monadics” and apply the best practices of functional
programming
● A part where it can be difficult to do (or it doesn't make much sense)
○ Final logging output
○ Integration with UI libraries
○ Glue-code
○ ...
36
Where is the boundary?
● Class interface
● Library interface
37
Example: window layout class diagram
IWindowLayout UI::WindowLayout
WindowLayoutStack
38
Example: window layout
class IWindowLayout
{
public:
virtual core::Expected:> add(const window::Uri& windowUri) = 0;
};
./ ...
core::Expected:> WindowLayoutStack::add(const window::Uri& windowUri)
{
return loadWindow(windowUri, m_windowLoader)
.and_then(&addToLayout)
.and_then(&updateActiveWindow)
.or_else(&addWindowLayoutPrefix);
}
39
Example: window layout wrapper
./ Inside another namespace
class WindowLayout : public QObject
Q_OBJECT
Q_PROPERTY(QString activeWindow READ activeWindow NOTIFY activeWindowChanged)
./ ...
private:
std::shared_ptr<IWindowLayout> m_windowLayout;
};
40
Example: window layout wrapper
void WindowLayout::add(const window::Uri& windowUri)
{
m_windowLayout:>add(windowUri).or_else(&printError);
}
41
What did we achieve?
● Integration with the existing codebase
● Monadic interface
● Separation of functional and non-functional code
42
Small steps
43
General approach (assume you have OO-style code-base)
● Start with the implementation of the methods
● Partially change class interface
● Fully change class interface
● (Optionally) Drop the entire class
44
Example: add a window – initial state
std::shared_ptr<Window> loadWindow(
const window::Uri &windowUri, const window::Loader &loader);
./ ...
bool WindowLayoutStack::add(const window::Uri& windowUri)
{
if (auto window = loadWindow(windowUri, m_loader))
{
./ ...
}
return false;
}
45
Example: add a window – change implementation
core::Expected<std::shared_ptr<Window:> loadWindow(
const window::Uri &windowUri, const window::Loader &loader);
./ ...
bool WindowLayoutStack::add(const window::Uri &windowUri)
{
auto result = loadWindow(windowUri, m_loader)
.and_then(&addToLayout)
.* .and_then... ./;
./ ...
return result.has_value();
}
46
Example: add a window – change interface
core::Expected:> WindowLayoutStack::add(const window::Uri& windowUri)
{
return loadWindow(windowUri, m_loader)
.and_then(&addToLayout)
.* .and_then... ./;
}
47
Tips and Tricks
48
Assuming
● You’re at the very beginning of your journey
● There are not many well-defined practices for using monadic operations
● There are not too many functional programming libraries used in the project
49
Lambda functions
● Lambda functions are flexible and powerful tool
● With noisy syntax
● And this is yet another footgun
Use less:
● Nested lambda functions
● Long lambda functions
● Lambda functions assigned to local variables
50
Use less lambda functions
core::Expected:> WindowLayoutStack::add( core::Expected:> WindowLayoutStack::add(
const window::Uri& windowUri) const window::Uri& windowUri)
{ {
return loadWindow( const auto addToLayout =
windowUri, m_windowLoader) []( /**/ ) { /**/ };
.and_then(&addToLayout) const auto updateActiveWindow =
.and_then(&updateActiveWindow) []( /**/ ) { /**/ };
.or_else(&addWindowLayoutPrefix); const auto addWindowLayoutPrefix =
} []( /**/ ) { /**/ };
return loadWindow(
windowUri, m_windowLoader)
.and_then(addToLayout)
.and_then(updateActiveWindow)
.or_else(addWindowLayoutPrefix);
}
51
…and more free functions in general
● Small steps with names
● Easy to reuse
● Easy to test
52
Use bind_back/front
● There is already a function
● …used in many places
● …and you cannot easily change a signature
● A solution with lambda functions looks too cumbersome
● std::bind_front – C++20
● std::bind_back – C++23
53
bind_back/front
auto add = [](int a, int b) { return a + b; };
auto addOne = std::bind_back(add, 1);
fmt::println("{}", addOne(2)); ./ prints 3
auto inc = [](int &a, int v) { a += v; };
int a{};
auto incA = std::bind_front(inc, std::ref(a));
incA(2);
fmt::println("{}", a);
54
Possible implementation of bind_back
template<class F, class ::.BoundArgs>
auto bind_back(F :&f, BoundArgs :&::.boundArgs)
{
return [::.boundArgs = std::forward<BoundArgs>(boundArgs), f = f]
<class ::.RemainArgs>(RemainArgs :&::.remainArgs) {
return std::invoke(f, std::forward<RemainArgs>(remainArgs)::., boundArgs::.);
};
}
55
Example of using xostd::bind_back
core::Expected:> addWindowLayoutPrefix(
const std::string &errorString, std::string_view customPrefix)
return core::make_unexpected(fmt::format("{} {}", errorString, customPrefix));
};
//...
.or_else(std::bind_back(&addWindowLayoutPrefix, "[StackLayout]"));
56
Make all functions return expected/optional
● Easy to compose
● Doesn’t require additional libraries or helpers
core::Expected:> removeFromLayout(MapIt windowIterator, Map& windows, Stack& windowsStack)
{
windowsStack.erase(windowIterator:>second);
windows.erase(windowIterator);
return {};
}
57
Tuples your best friends
● No need to create extra structures
● Easy to pass several objects
core::Expected<std::tuple<Context, Component, QString:>
createComponent(QQmlEngine& engine, const QString& fileName, const QString& viewName)
{
./...
return std::make_tuple(std::move(context), std::move(component), viewName);
}
58
Don’t forget about transform_error
● 3rd-party libraries can have different error types
● Need to pass additional context
● Need to amend existing error (e.g. add a message prefix)
59
Explore 3rd-party libraries
● Get inspired
● Learn
● Use well-tested solutions
60
Thank you!
61
