{"id":5138,"date":"2017-01-21T10:53:47","date_gmt":"2017-01-21T10:53:47","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/functional-in-c-17-and-c-20\/"},"modified":"2023-06-26T12:26:18","modified_gmt":"2023-06-26T12:26:18","slug":"functional-in-c-17-and-c-20","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/functional-in-c-17-and-c-20\/","title":{"rendered":"Functional in C++17 and C++20"},"content":{"rendered":"

Which functional feature can we expect with C++17, and for which functional feature can we hope with C++20? This is precisely the question I will concisely answer in this post.<\/p>\n

<\/p>\n

 <\/p>\n

With C++17 we get fold expressions<\/span> and the new container std::optional.<\/span> Even more thrilling becomes C++20. Concepts, the ranges library, and improved futures support new concepts in C++.<\/p>\n

\"timeline.FunktionalInCpp17Cpp20Eng\"<\/p>\n

At first, to the near future. I will start in the next post with my systematic description of functional programming in C++. Therefore, I will be concise in this post. This post is only intended to make you more appetite.<\/p>\n

C++17<\/h2>\n

Fold expressions<\/h3>\n

C++11 has Variadic Templates<\/a>. These are templates that can get an arbitrary number of arguments. The arbitrary number is bound in a parameter pack. New is with C++17 that you can directly reduce a parameter pack with a binary operator. Therefore, you can directly implement Haskell’s function family foldl, foldr, foldl1,<\/span> and foldr1, <\/span>which reduce a list to a value. <\/span><\/p>\n

\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38\r\n39<\/pre>\n<\/td>\n
\n
\/\/ foldExpression.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\ntemplate<\/span><typename<\/span>... Args>\r\nbool<\/span> all(Args... args) { return<\/span> (... && args); }\r\n\r\ntemplate<\/span><typename<\/span>... Args>\r\nbool<\/span> any(Args... args) { return<\/span> (... || args); }\r\n\r\ntemplate<\/span><typename<\/span>... Args>\r\nbool<\/span> none(Args... args) { return<\/span> not(... || args); }\r\n\r\n\r\nint<\/span> main(){\r\n    \r\n  std::cout << std::endl;\r\n\r\n  std::cout << std::boolalpha;\r\n\r\n  std::cout << \"all(true): \"<\/span> << all(true) << std::endl;\r\n  std::cout << \"any(true): \"<\/span> << any(true) << std::endl;\r\n  std::cout << \"none(true): \"<\/span> << none(true) << std::endl;\r\n  \r\n  std::cout << std::endl;\r\n\r\n  std::cout << \"all(true, true, true, false): \"<\/span> << all(true, true, true, false) << std::endl;\r\n  std::cout << \"any(true, true, true, false): \"<\/span> << any(true, true, true, false) << std::endl;\r\n  std::cout << \"none(true, true, true, false): \"<\/span> << none(true, true, true, false) << std::endl;\r\n  \r\n  std::cout << std::endl;\r\n  \r\n  std::cout << \"all(false, false, false, false): \"<\/span> << all(false, false, false, false) << std::endl;\r\n  std::cout << \"any(false, false, false, false): \"<\/span> << any(false, false, false, false) << std::endl;\r\n  std::cout << \"none(false, false, false, false): \"<\/span> << none(false, false, false, false) << std::endl;\r\n  \r\n  std::cout << std::endl;\r\n  \r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
The function templates all,<\/span> any,<\/span> and none<\/span> return at compile-time true,<\/span> or false<\/span>. I will have a closer look at the function template any<\/span> in lines 5 and 6. The parameter pack (…) is unpacked on the binary operator (… && args<\/span>). The three dots define (ellipse) the parameter pack.<\/p>\n
For the program’s output, I use the online compiler on cppreference.com<\/a>.<\/p>\n
\"foldExpressions\"<\/p>\n
Haskell has the maybe monad<\/a>, and C++17 will get std::optional.<\/span><\/p>\n<\/p>\n
std::optional<\/h3>\n
std::optional<\/span> stands for a calculation that maybe have a value. A find algorithm or a query of a hash table must deal with the fact that no value is available. Often, you use special values to indicate that you get no result. In short, a non-results. Often null pointers, empty strings, or special integer values are used for non-results. This is inconvenient and error-prone because you have to deal especially with non-result, and you have to distinguish the non-result from a regular result. In case of a non-result, you get with std::optional<\/span> no value. <\/p>\n
\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33<\/pre>\n<\/td>\n
\n
\/\/ optional.cpp<\/span>\r\n\r\n#include <experimental\/optional><\/span>\r\n#include <iostream><\/span>\r\n#include <vector><\/span>\r\n\r\nstd::experimental::optional<int<\/span>> getFirst(const<\/span> std::vector<int<\/span>>& vec){\r\n  if<\/span> ( !vec.empty() ) return<\/span> std::experimental::optional<int<\/span>>(vec[0]);\r\n  else<\/span> return<\/span> std::experimental::optional<int<\/span>>();\r\n}\r\n\r\nint<\/span> main(){\r\n    \r\n    std::vector<int<\/span>> myVec{1,2,3};\r\n    std::vector<int<\/span>> myEmptyVec;\r\n    \r\n    auto<\/span> myInt= getFirst(myVec);\r\n    \r\n    if<\/span> (myInt){\r\n        std::cout << \"*myInt: \"<\/span>  << *myInt << std::endl;\r\n        std::cout << \"myInt.value(): \"<\/span> << myInt.value() << std::endl;\r\n        std::cout << \"myInt.value_or(2017):\"<\/span> << myInt.value_or(2017) << std::endl;\r\n    }\r\n    \r\n    std::cout << std::endl;\r\n    \r\n    auto<\/span> myEmptyInt= getFirst(myEmptyVec);\r\n    \r\n    if<\/span> (!myEmptyInt){\r\n        std::cout << \"myEmptyInt.value_or(2017):\"<\/span> << myEmptyInt.value_or(2017) << std::endl;\r\n    }\r\n   \r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
std::optional<\/span> is currently in the namespace experimental.<\/span> That will change with C++17. If it exists, the function getFirst will return the first element (line 8). If not, a std::optional<int><\/span> object. I use in the main function two vectors. The calls getFirst<\/span> in lines 17 and 27 return a std::optional<\/span> object. In the case of myInt (line 19), the object has a value; in the case of myEmptyInt<\/span> (line 29), no value. Now, I can display the value of myInt<\/span> (lines 20 – 22). The method value_or<\/span> in lines 22 and 30 will return a value if std::optional-object <\/span>has a value if not a default value.<\/p>\n
\"optinal\"<\/h2>\n
The impact of functional programming in C++ – particularly Haskell – increases significantly with C++20. Of course, it’s a little bit risky to predict C++20. I made a mistake once and said that the following features are part of C++17, which is, of course, not true.<\/p>\n
C++20<\/h2>\n
Promised, the details of concepts, the ranges library, and the improved futures will follow in future posts.<\/p>\n
Concepts<\/h3>\n
Type classes<\/a> in Haskell are interfaces for similar types. If a type is a member of a type class, it will have specific properties. Type classes play in generic programming a similar role as interfaces in object-oriented programming. Inspired by type classes, you can specify requirements for the template parameters. The new functionality has the name concepts<\/a>. For example, the sort algorithm requires that a template argument be sorted. <\/span><\/p>\n
\n
template<\/span><typename<\/span> Cont>\r\n  requires Sortable<Cont>()\r\nvoid<\/span> sort(Cont& container){...}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
What are the benefits of concepts? At first, the template declaration states which properties must hold for the template arguments. Therefore, the compiler can detect the break of the contract and display an unambiguous error message.<\/p>\n
\n
std::list<int<\/span>> lst = {1998,2014,2003,2011};\r\nsort(lst); \/\/ ERROR: lst is no random-access container with <<\/span>\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The C++ community waits at least as eagerly for concepts as for the new ranges library<\/a> from Eric Niebler.<\/p>\n
Ranges library<\/h3>\n
From the birds-eye perspective, the ranges library empowers you to apply the Standard Template Library algorithms directly on the whole container. But under the hood, we get new programming techniques.<\/p>\n