{"id":5863,"date":"2020-03-11T21:34:39","date_gmt":"2020-03-11T21:34:39","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/c-20-pythons-map-function\/"},"modified":"2023-09-27T17:01:41","modified_gmt":"2023-09-27T17:01:41","slug":"c-20-pythons-map-function","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c-20-pythons-map-function\/","title":{"rendered":"C++20: Python’s map Function"},"content":{"rendered":"

Today, I finish my experiment writing beloved Python functions in C++. So far, I have implemented the Python functions filter<\/span>, range<\/span>, and xrange<\/span>. Today, I have a closer look at the map<\/span> function and combine the functions map<\/span> and filter<\/span> into one function.<\/p>\n

<\/p>\n

\"\"<\/p>\n

It was implemented in my last post, “C++20: Pythons range Function, the Second<\/a>” a lazy variant of range<\/span>: xrange.<\/span>\u00a0A few of my German readers complain that xrange<\/span> does not behave, such as Python 2 xrange<\/span> function. My xrange function requires constant expressions for the created numbers’ beginning and end.<\/p>\n

\n
auto<\/span> res =<\/span> xrange<<\/span>1<\/span>, 10<\/span>><\/span>();                    \nfor<\/span> (auto<\/span> i:<\/span> res) std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;  \/\/ 1 2 3 4 5 6 7 8 9<\/span>\n<\/pre>\n<\/div>\n
In the example, 1 and 10 are constant expressions. This means an expression such as the following one would not compile.<\/p>\n
\n
int<\/span> begin =<\/span> 1<\/span>;\nint<\/span> end =<\/span> 10<\/span>;\n\nauto<\/span> res =<\/span> xrange<<\/span>begin, end><\/span>();                    \n<\/pre>\n<\/div>\n
I assume you know what that means?<\/p>\n
Pythons range<\/span> Function, the Third<\/h2>\n
Thanks to my German reader Clocktown, I can present the final version of xrange<\/span>. The function xrange<\/span> is lazy and can also accept arguments for the boundaries, which are not constant expressions.<\/p>\n
\n
\/\/ xrange2.hpp<\/span>\n\n#include <stdio.h><\/span>\n#include <range\/v3\/all.hpp><\/span>\n \nnamespace<\/span> view =<\/span> ranges::<\/span>views;\n\nauto<\/span> xrange<\/span>(long<\/span> long<\/span> begin, long<\/span> long<\/span> end, long<\/span> long<\/span> step =<\/span> 1<\/span>) {\n    if<\/span>(step ==<\/span> 0<\/span>) {\n        throw<\/span> std::<\/span>invalid_argument(\"Step cannot be 0\"<\/span>);\n    }\n    auto<\/span> Step =<\/span> begin <<\/span> end ?<\/span> step :<\/span> -<\/span>step;\n    auto<\/span> Begin =<\/span> std::<\/span>min(begin, end);\n    auto<\/span> End =<\/span> Step <<\/span> 0<\/span> ?<\/span> Begin :<\/span> std::<\/span>max(begin, end);\n    return<\/span> view::<\/span>iota(Begin, End)\n    |<\/span> view::<\/span>stride(std::<\/span>abs(Step))\n    |<\/span> view::<\/span>transform([begin, end](std::<\/span>size_t<\/span> i){\n        return<\/span> begin <<\/span> end ?<\/span> i :<\/span> end -<\/span> (i -<\/span> begin);\n    });\n}\n\nauto<\/span> xrange<\/span>(long<\/span> long<\/span> end) {\n    return<\/span> xrange(0<\/span>, end, 1<\/span>);\n}                   \n<\/pre>\n<\/div>\n
The key idea of his implementation is that view::transform<\/span>\u00a0eventually transforms the calculation into a reverse variant. xrange<\/span> can be invoked with one, two, or three arguments. The default for the first argument is 0, and for the third argument is 1. Let’s try it out. I replaced the xrange<\/span> implementation of my last post with this new implementation.<\/p>\n
\n
\/\/ range2.cpp<\/span>\n\n#include \"xrange2.hpp\"<\/span>\n\n#include <iostream><\/span>\n#include <range\/v3\/all.hpp><\/span>\n#include <vector><\/span>\n\n        \nint<\/span> main<\/span>() {\n    \n    std::<\/span>cout <<<\/span> std::<\/span>endl;\n\n    auto<\/span> res =<\/span> xrange(1<\/span>, 10<\/span>);\n    for<\/span> (auto<\/span> i:<\/span> res) std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;\n    \n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n    \n    res =<\/span> xrange(1<\/span>, 50<\/span>, 5<\/span>);\n    for<\/span> (auto<\/span> i:<\/span> res) std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;\n    \n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n    \n    auto<\/span> res2 =<\/span> xrange(20<\/span>, 10<\/span>, -<\/span>1<\/span>);\n    for<\/span> (auto<\/span> i:<\/span> res2) std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;\n    \n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n    \n    res2 =<\/span> xrange(50<\/span>, 10<\/span>, -<\/span>5<\/span>);\n    for<\/span> (auto<\/span> i:<\/span> res2) std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;\n    \n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n    \n    res =<\/span> xrange(1<\/span>, 1'<\/span>000'<\/span>000'<\/span>000'<\/span>000'<\/span>000'<\/span>000<\/span>);\n    \/\/ for (auto i: res) std::cout << i << \" \";<\/span>\n    \n    for<\/span> (auto<\/span> i:<\/span> res |<\/span> ranges::<\/span>views::<\/span>take(10<\/span>)) std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;\n    \n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n    \n    for<\/span> (auto<\/span> i:<\/span> res |<\/span> ranges::<\/span>views::<\/span>drop_while([](int<\/span> i){ return<\/span> i <<\/span> 1'<\/span>000'<\/span>000<\/span>; })\n                     |<\/span> ranges::<\/span>views::<\/span>take_while([](int<\/span> i){ return<\/span> i <<\/span> 1'<\/span>000'<\/span>010<\/span>; })){\n        std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;\n    }\n    \n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\n    \n}\n<\/pre>\n<\/div>\n
As expected, I got the same result.<\/p>\n
\"xrange\"<\/p>\n
So far, nothing new. But here are the new use cases. begin<\/span>\u00a0and end<\/span> are not constant expressions, and xrange<\/span>\u00a0supports one argument.<\/p>\n
\n
int<\/span> main<\/span>() {\n\n  int<\/span> begin =<\/span> 3<\/span>;\n  int<\/span> end =<\/span> 7<\/span>;\n\n  for<\/span>(auto<\/span> x:<\/span> xrange(end)) {\n      std::<\/span>cout <<<\/span> x <<<\/span> \" \"<\/span>;  \/\/ 0 1 2 3 4 5 6<\/span>\n  }\n\n  for<\/span>(auto<\/span> x:<\/span> xrange(begin, end)) {\n      std::<\/span>cout <<<\/span> x <<<\/span> \" \"<\/span>;  \/\/ 3 4 5 6<\/span>\n\n  for<\/span>(auto<\/span> x:<\/span> xrange(end, begin, -<\/span>2<\/span>)) {\n      std::<\/span>cout <<<\/span> x <<<\/span> \" \"<\/span>;  \/\/ 7 5<\/span>\n  }\n  \n}\n<\/pre>\n<\/div>\n
Now, I’m done with the function range<\/span> and xrange<\/span>. Let me continue with the function map<\/span>.<\/p>\n
map<\/span><\/h2>\n
First, here is my simplified definition of Pythons 2 map<\/span> function. I restrict map<\/span> to one sequence<\/p>\n