{"id":5854,"date":"2020-02-17T12:01:10","date_gmt":"2020-02-17T12:01:10","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/c-20-functional-patterns-with-the-ranges-library\/"},"modified":"2023-09-27T16:55:16","modified_gmt":"2023-09-27T16:55:16","slug":"c-20-functional-patterns-with-the-ranges-library","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c-20-functional-patterns-with-the-ranges-library\/","title":{"rendered":"C++20: Functional Patterns with the Ranges Library"},"content":{"rendered":"

My last post C++20: The Ranges Library<\/a>, gave you the first impression of the ranges library. Today’s post is about functional patterns: function composition and lazy evaluation. They become first-class citizens in C++20.<\/p>\n

<\/p>\n

\"\"<\/p>\n

The Standard Template Library (STL) algorithms are sometimes a little inconvenient. They need a beginning and an end iterator. This is often more than you want to write.<\/p>\n

\n
#include <numeric><\/span>\n#include <iostream><\/span>\n#include <vector><\/span>\n\nint<\/span> main<\/span>() {\n    \n    std::<\/span>vector<<\/span>int<\/span>><\/span> myVec{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>, 6<\/span>, 7<\/span>, 8<\/span>, 9<\/span>};\n    auto<\/span> res =<\/span> std::<\/span>accumulate(std::<\/span>begin(myVec), std::<\/span>end(myVec), 0<\/span>); \n    \/\/ std::accumulate(myVec, 0);                                      \/\/ (1)<\/span><\/span>\n    std::<\/span>cout <<<\/span> res <<<\/span> std::<\/span>endl;      \/\/  45 <\/span>\n    \n}\n<\/pre>\n<\/div>\n
Would it be nice if std::accumulate<\/span> could be executed directly on the container, such as in line (2)?<\/p>\n
Direct on the Container<\/h2>\n
The following program creates direct views on the keys (line 1) and the values (line\u00a0 3) of the std::unordered_map<\/span>.<\/p>\n
\n
\/\/ rangesEntireContainer.cpp<\/span>\n\n#include <iostream><\/span>\n#include <ranges><\/span>\n#include <string><\/span>\n#include <unordered_map><\/span>\n\n\nint<\/span> main<\/span>() {\n    \n    std::<\/span>unordered_map<<\/span>std::<\/span>string, int<\/span>><\/span> freqWord{ {\"witch\"<\/span>, 25<\/span>}, {\"wizard\"<\/span>, 33<\/span>}, {\"tale\"<\/span>, 45<\/span>},\n                                                   {\"dog\"<\/span>, 4<\/span>}, {\"cat\"<\/span>, 34<\/span>}, {\"fish\"<\/span>, 23<\/span>} };\n    \n    std::<\/span>cout <<<\/span> \"Keys\"<\/span> <<<\/span> std::<\/span>endl;\n    auto<\/span> names =<\/span> std::<\/span>views::<\/span>keys(freqWord);                                            \/\/ (1)<\/span>\n    for<\/span> (const<\/span> auto<\/span>&<\/span> name :<\/span> names){ std::<\/span>cout <<<\/span> name <<<\/span> \" \"<\/span>; };\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\n    for<\/span> (const<\/span> auto<\/span>&<\/span> name :<\/span> std::<\/span>views::<\/span>keys(freqWord)){ std::<\/span>cout <<<\/span> name <<<\/span> \" \"<\/span>; };   \/\/ (2)<\/span>\n    \n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n    \n    std::<\/span>cout <<<\/span> \"Values: \"<\/span> <<<\/span> std::<\/span>endl;\n    auto<\/span> values =<\/span> std::<\/span>views::<\/span>values(freqWord);                                          \/\/ (3)<\/span>\n    for<\/span> (const<\/span> auto<\/span>&<\/span> value :<\/span> values){ std::<\/span>cout <<<\/span> value <<<\/span> \" \"<\/span>; };\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\n    for<\/span> (const<\/span> auto<\/span>&<\/span> value :<\/span> std::<\/span>views::<\/span>values(freqWord)){ std::<\/span>cout <<<\/span> value <<<\/span> \" \"<\/span>; } \/\/ (4)<\/span>\n                           \n}\n<\/pre>\n<\/div>\n
Of course, the keys and values can be displayed directly (lines 2 and line 4). The output is identical.<\/p>\n
\"rangesEntireContainer\"<\/p>\n
Working directly on the container is not revolutionary, but function composition and lazy evaluation are.<\/p>\n
Function Composition<\/h2>\n
In my following example, I use std::map<\/span> because the ordering of the keys is crucial.<\/p>\n
\n
\/\/ rangesComposition.cpp<\/span>\n\n#include <iostream><\/span>\n#include <ranges><\/span>\n#include <string><\/span>\n#include <map><\/span>\n\n\nint<\/span> main<\/span>() {\n    \n    std::<\/span>map<<\/span>std::<\/span>string, int<\/span>><\/span> freqWord{ {\"witch\"<\/span>, 25<\/span>}, {\"wizard\"<\/span>, 33<\/span>}, {\"tale\"<\/span>, 45<\/span>},\n                                                   {\"dog\"<\/span>, 4<\/span>}, {\"cat\"<\/span>, 34<\/span>}, {\"fish\"<\/span>, 23<\/span>} };\n                                                \n    std::<\/span>cout <<<\/span> \"All words: \"<\/span>;                     \/\/ (1)<\/span>\n    for<\/span> (const<\/span> auto<\/span>&<\/span> name :<\/span> std::<\/span>views::<\/span>keys(freqWord)) { std::<\/span>cout <<<\/span> name <<<\/span> \" \"<\/span>; };                                               \n                                                   \n    std::<\/span>cout <<<\/span> std::<\/span>endl;\n    \n    std::<\/span>cout <<<\/span> \"All words reverse: \"<\/span>;             \/\/ (2)<\/span>\n    for<\/span> (const<\/span> auto<\/span>&<\/span> name :<\/span> std::<\/span>views::<\/span>keys(freqWord) |<\/span> std::<\/span>views::<\/span>reverse) { std::<\/span>cout <<<\/span> name <<<\/span> \" \"<\/span>; };  \n     \n    std::<\/span>cout <<<\/span> std::<\/span>endl;\n    \n    std::<\/span>cout <<<\/span> \"The first 4 words: \"<\/span>;             \/\/ (3)<\/span>\n    for<\/span> (const<\/span> auto<\/span>&<\/span> name :<\/span> std::<\/span>views::<\/span>keys(freqWord) |<\/span> std::<\/span>views::<\/span>take(4<\/span>)) { std::<\/span>cout <<<\/span> name <<<\/span> \" \"<\/span>; }; \n    \n    std::<\/span>cout <<<\/span> std::<\/span>endl;\n                                \n    std::<\/span>cout <<<\/span> \"All words starting with w: \"<\/span>;     \/\/ (4)<\/span>\n    auto<\/span> firstw =<\/span> [](const<\/span> std::<\/span>string&<\/span> name){ return<\/span> name[0<\/span>] ==<\/span> 'w'<\/span>; };\n    for<\/span> (const<\/span> auto<\/span>&<\/span> name :<\/span> std::<\/span>views::<\/span>keys(freqWord) |<\/span> std::<\/span>views::<\/span>filter(firstw)) { std::<\/span>cout <<<\/span> name <<<\/span> \" \"<\/span>; };\n    \n    std::<\/span>cout <<<\/span> std::<\/span>endl;\n                                                     \/\/ (5)<\/span>\n    auto<\/span> lengthOf =<\/span> [](const<\/span> std::<\/span>string&<\/span> name){ return<\/span> name.size(); };\n    auto<\/span> res =<\/span> ranges::<\/span>accumulate(std::<\/span>views::<\/span>keys(freqWord) |<\/span> std::<\/span>views::<\/span>transform(lengthOf), 0<\/span>);\n    std::<\/span>cout <<<\/span> \"Sum of words: \"<\/span> <<<\/span> res <<<\/span> std::<\/span>endl;\n   \n}\n<\/pre>\n<\/div>\n
In this case, I’m only interested in the keys. I display all of them (line 1), all of them reversed (line 2), the first four (line 3), and the keys starting with the letter ‘w’ (line 4). Line (5) sums up all the lengths of all words.<\/p>\n
The pipe symbol | is syntactic sugar<\/a> for function composition. Instead of C(R)<\/span>, you can write R | C<\/span>. Consequentially, the following two lines are equivalent.<\/p>\n
\n
auto<\/span> <\/span>rev2<\/span><\/span> =<\/span> <\/span>std::views::reverse(ranges::views::keys(freqWord));<\/span><\/span>\nauto<\/span> rev =<\/span> std::<\/span>views::<\/span>keys(freqWord) |<\/span> ranges::<\/span>views::<\/span>reverse; \n<\/pre>\n<\/div>\n
Finally, here is the output of the program.\"rangesComposition\"<\/p>\n
Lazy Evaluation<\/span><\/h2>\n
I use in my example std::views::iota<\/a>. This function is a range factory for creating a sequence of elements by successively incrementing an initial value. This sequence can be finite or infinite. The following example fills a std::vector<\/span> with ten int’s<\/span>, starting with 0.<\/p>\n
\n
\/\/ rangesIota.cpp<\/span>\n\n#include <iostream><\/span>\n#include <numeric><\/span>\n#include <ranges><\/span>\n#include <vector><\/span>\n\nint<\/span> main<\/span>() {\n    \n    std::<\/span>cout <<<\/span> std::<\/span>boolalpha;\n    \n    std::<\/span>vector<<\/span>int<\/span>><\/span> vec;\n    std::<\/span>vector<<\/span>int<\/span>><\/span> vec2;\n    \n    for<\/span> (int<\/span> i:<\/span> std::<\/span>views::<\/span>iota(0<\/span>, 10<\/span>)) vec.push_back(i);                      \/\/ (1)         <\/span>\n         \n    for<\/span> (int<\/span> i:<\/span> std::<\/span>views::<\/span>iota(0<\/span>) |<\/span> std::<\/span>views::<\/span>take(10<\/span>)) vec2.push_back(i);  \/\/ (2)<\/span>\n    \n    std::<\/span>cout <<<\/span> \"vec == vec2: \"<\/span> <<<\/span> (vec ==<\/span> vec2) <<<\/span> '\\n'<\/span>; \/\/ true<\/span>\n    \n    for<\/span> (int<\/span> i:<\/span> vec) std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;                \/\/ 0 1 2 3 4 5 6 7 8 9<\/span>\n                           \n}\n<\/pre>\n<\/div>\n
The first iota<\/span> call (line 1) creates all numbers from 0 to 9, incremented by 1. The second iota<\/span> call (line 2) creates an infinite data stream, starting with 0 and incremented by 1. std::views::iota(0)<\/span> is lazy. I only get a new value if I ask for it. I asked for it ten times. Consequentially, both vectors are identical.<\/p>\n
Now,\u00a0 I want to solve a small challenge. I want to find the first 20 prime numbers, starting with 1000000.<\/p>\n
\n
\/\/ rangesLazy.cpp<\/span>\n\n#include <iostream><\/span>\n#include <ranges><\/span>\n\n\nbool<\/span> isPrime<\/span>(int<\/span> i) {\n    for<\/span> (int<\/span> j=<\/span>2<\/span>; j*<\/span>j <=<\/span> i; ++<\/span>j){\n        if<\/span> (i %<\/span> j ==<\/span> 0<\/span>) return<\/span> false<\/span>;\n    }\n    return<\/span> true<\/span>;\n}\n\nint<\/span> main<\/span>() {\n                                        \/\/ (1)<\/span>\n    std::<\/span>cout <<<\/span> \"Numbers from 1000000 to 1001000 (dispayed each 100th): \"<\/span> <<<\/span> std::<\/span>endl;\n    for<\/span> (int<\/span> i:<\/span> std::<\/span>views::<\/span>iota(1000000<\/span>, 1001000<\/span>)) {\n        if<\/span> (i %<\/span> 100<\/span> ==<\/span> 0<\/span>) std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;  \n    }\n    \n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n                                        \/\/ (2)<\/span>\n    auto<\/span> odd =<\/span> [](int<\/span> i){ return<\/span> i %<\/span> 2<\/span> ==<\/span> 1<\/span>; };\n    std::<\/span>cout <<<\/span> \"Odd numbers from 1000000 to 1001000 (displayed each 100th): \"<\/span> <<<\/span> std::<\/span>endl;\n    for<\/span> (int<\/span> i:<\/span> std::<\/span>views::<\/span>iota(1000000<\/span>, 1001000<\/span>) |<\/span> std::<\/span>views::<\/span>filter(odd)) {\n         if<\/span> (i %<\/span> 100<\/span> ==<\/span> 1<\/span>) std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;  \n    }\n    \n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n                                         \/\/ (3)<\/span>\n    std::<\/span>cout <<<\/span> \"Prime numbers from 1000000 to 1001000: \"<\/span> <<<\/span> std::<\/span>endl;\n    for<\/span> (int<\/span> i:<\/span> std::<\/span>views::<\/span>iota(1000000<\/span>, 1001000<\/span>) |<\/span> std::<\/span>views::<\/span>filter(odd) \n                                                   |<\/span> std::<\/span>views::<\/span>filter(isPrime)) {\n        std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;  \n    }\n    \n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n                                         \/\/ (4)<\/span>\n    std::<\/span>cout <<<\/span> \"20 prime numbers starting with 1000000: \"<\/span> <<<\/span> std::<\/span>endl;\n    for<\/span> (int<\/span> i:<\/span> std::<\/span>views::<\/span>iota(1000000<\/span>) |<\/span> std::<\/span>views::<\/span>filter(odd) \n                                          |<\/span> std::<\/span>views::<\/span>filter(isPrime) \n                                          |<\/span> std::<\/span>views::<\/span>take(20<\/span>)) {\n        std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;  \n    }\n\n}\n<\/pre>\n<\/div>\n
Here is my iterative strategy:<\/p>\n
    \n
  1. Of course, I don’t know when I have 20 primes greater than 1000000. To be on the safe side, I create 1000 numbers. For obvious reasons, I displayed only each 100th.<\/li>\n
  2. I’m only interested in the odd numbers; therefore, I removed the even numbers.<\/li>\n
  3. Now, it’s time to apply the next filter. The predicate isPrime<\/span> returns if a number is a prime. As you can see in the following screenshot, I was too eager. I got 75 primes.<\/li>\n
  4. Laziness is a virtue. I use std::iota<\/span> as an infinite number factory, starting with 1000000, and ask precisely for 20 primes.<\/li>\n<\/ol>\n
    \"rangesLazy\"<\/p>\n
    What’s next?<\/h2>\n
    Python has many very nice functions, such as range<\/span>, map<\/span>, filter<\/span>, reduce, <\/span>and zip.<\/span>\u00a0And, of course, there is also the slice operator and list comprehension. These functions are eager in Python 2, but map<\/span>, filter<\/span>, and reduce<\/span> are lazy in Python 3. I will try an experiment in my next post.<\/a> Which functions can I implement with similar functionality in C++ by using the ranges library?<\/p>\n","protected":false},"excerpt":{"rendered":"
    My last post C++20: The Ranges Library, gave you the first impression of the ranges library. Today’s post is about functional patterns: function composition and lazy evaluation. They become first-class citizens in C++20.<\/p>\n","protected":false},"author":21,"featured_media":8380,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[375],"tags":[413],"class_list":["post-5854","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-20","tag-ranges"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5854","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=5854"}],"version-history":[{"count":2,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5854\/revisions"}],"predecessor-version":[{"id":8391,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5854\/revisions\/8391"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/8380"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5854"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5854"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5854"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}