My previous talk on New Tools for a More Functional C++ ran into some audio issue during the meetup. I did not upload the video back then because it had no audio what-so-ever. I finally got around to record the audio track for the talk and I mixed it with the video. So here is the final video. Have fun with FP in C++!
If you don't have 35 minutes, checkout the partial video transcripts below.
Functional Programming Tools in C++ from Sumant Tambe on Vimeo.
If you don't have 35 minutes, checkout the partial video transcripts below.
Functional Programming Tools in C++ from Sumant Tambe on Vimeo.
Video Transcripts
00:16
We’re going to talk about functional [programming] tools in
C++ and what new capabilities exist in modern C++.
2:00
I'm reviewing Functional
Programming in C++ book by Manning---a good book for C++ programmers to acquire beginner to
intermediate level knowledge of FP in C++.
2:30
Sum types and (pseudo) pattern matching in C++
5:00
Modeling a game of Tennis using std::variant
7:30
std::visit
spews blood when you miss a case in the visitor. See an example. Therefore, language-supported
pattern matching is much more preferable than library support for the same.
9:00
Passing overloaded lambdas to std::visit---the fancy way to
create a visitor. User-defined deduction guides for overloading from lambdas.
13:00
Algorithms implemented using pattern matching style tend to
concentrate the entire algorithm in a function as opposed to object-oriented
programming style where the algorithm is spread in multiple classes and
potentially multiple files.
15:00
Sharing state become much easier with inheritance as opposed
to std::variant based decomposition.
18:05
Too much ceremony in std::variant approach as you have to
call std::visit and pass a visitor to it. In object-oriented style, it is just
a call to a function and hence it’s very succinct.
19:00
Recursive std::variant is not possible without recursive_variant.
std::variant is a container not an abstraction. std::variant alone isn’t
sufficient to implement algebraic data types or the Composite design pattern.
21:00
std::variant disables fluent interfaces.
22:00
A summary of differences between inheritance and
std::variant –based modeling alternatives in C++.
23:00
Deep Immutability in C++. C++ const is shallow. A raw pointer does not forward
const-ness, propagate_const does. You can now implement deep Immutability in C++
using propagate_const.
26:00
A class containing propagate_const is not copy-assignable. This
is consistent with basic C++ rule that a pointer to const can’t be assigned to
pointer to non-const.
27:30
Mutable temporaries in C++. Yes, temporaries can be
modified. Modern C++ provides ways to control this. See why you may need std::move(*this);.
29:00
The Named Parameter Idiom---an example of fluent interface
in C++.
31:00
Avoid constructing unnecessary temporary objects when fluent
interfaces are used with immutable objects.
33:45
How to disambiguate between r-value reference qualified
functions and l-value reference qualified functions. *this in a r-value
qualified function is a l-value. The trick is to return a r-value reference to
*this. Hence std::move(*this),
which is a simply a cast.
35:00
Thank you!
Comments