In our current stage of development of smart output iterators, we have: some iterators, such as filter, transform, unzip or demux, the possibility to combine them: filter(pred) >>= transform(f) >>= unzip(back_inserter(output1), back_inserter(output2)) their usage as the output iterator of an STL algorithm: std::copy(begin(inputs), end(inputs), transform(f) >>= back_inserter(outputs)); What we’re going to work on today […]
We’ve been over a various set of smart output iterators over the past few weeks. Today we explore how to combine them and create expressive code. If you’re just joining our series on smart output iterators, you might want to check out this introductory post on smart output iterators. So far, we’ve been combining smart […]
If you’ve been reading Fluent C++ over the past few weeks, then you’ve noticed that we spent some time on smart output iterators. Those little components allow to write expressive code when it comes to applying operations on collections, and in particular when there are multiple outputs to those operations. When I was at the […]
Today we have a guest post from Andrey Karpov. Andrey is a co-founder of the PVS-Studio project. He is a Microsoft MVP in the nomination ‘Developer Technologies’ and an author of a large number of articles dedicated to the code quality and error patterns, that C++ developers make. Gradually and imperceptibly we get the situation […]
Do we need a special strong type library for collections? Or can we strongly type collections like we do for any object? If you’re joining us right now and haven’t read the previous articles on strong types, long story short, a strong type is a type used instead of another one in order to add […]
Constant values are an everyday tool to make code more expressive, by putting names over values. For example, instead of writing 10 you can write MaxNbDisplayedLines to clarify your intentions in code, with MaxNbDisplayedLines being a constant defined as being equal to 10. Even though defining constants is such a basic tool to write clear code, their definition […]
This is Part 2 of guest author Rafael Varago‘s series on composing nullable types. In this episode, Rafael presents us absent, a generic library to compose nullable types in C++. In the first part of this series, we saw how C++20’s monadic composition will help us to compose std::optional<T> in a very expressive way. Now […]
This week we have a series of two articles on composing nullable types written by Rafael Varago. Rafael is a Software Engineer at eGym GmbH, he’s been working with C++, Scala, Go, build systems (e.g Modern CMake), embedded applications, and distributed systems. He enjoys Declarative Programming and Modern C++. Rafael loves learning new technologies and […]
const is a feature that has been appreciated by C++ developers for decades of good services, to make code more robust by preventing accidental modifications. Smart pointers have been around for a long time too, and simplified the life cycle of many objects along with the life balance of many developers across the years. auto is a […]
I first wrote this post on Philippe Bourgeau’s blog, a continuous refactoring coach’s blog about refactoring your code and organization. Since the beginning 2018, I’ve had the position of a team lead/manager/dev lead, call this what you want, but I’m essentially in charge of a module as well as the team of developers that work on […]
