![\"CharakteristikRecursionEng\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/02\/CharakteristikRecursionEng.png\")
<\/p>\nThe remaining three characteristics of functional programming are told quite quickly: Recursion, manipulation of lists, and lazy e Ihop valuation.<\/p>\n
<\/p>\n
<\/p>\n
Pure functional languages support no mutable data. Instead of a loop, they use recursion. The meta-function from Pure Functions<\/a> showed it already. At compile time, I use recursion instead of loops. The factorial function in C++<\/p>\n can be written quite easily in Haskell:<\/p>\n <\/p>\n LIS<\/strong>t P<\/strong>rocessing (LISP) is a characteristic of functional programming languages. The list is the foundation of the potent function composition in a functional language because it is the general data structure.<\/p>\n The processing of lists follows a simple pattern:<\/p>\n Because list processing is so idiomatic in functional programming, there exist special names for the first element and the rest of the list: (x, xs), (head, tail), or (car, cdr).<\/p>\n The pattern for processing the list is directly applicable in Haskell and C++.<\/p>\n Firstly, the concise version of C++. The function mySum<\/span> sums up the numbers from 1 to 5.<\/p>\n <\/p>\n And here is the C++ version.<\/p>\n <\/p>\n The Haskell version is relatively easy to get. Or? But the C++ version is quite heavyweight. The C++ syntax requires that the primary, also called the general template, must be declared. Line 4 to line 7 is the fully specialized template (meta-metafunction) used for the empty argument list. If at least one template argument is used, the partially specialized class template (lines 9 – 12) kicks in. Let me say a few words to the three dots, the so-called ellipse. That is why the class in line 14 can take an arbitrary number of arguments. The three dots in lines 1 and 9 pack the template parameter pack; the three dots in lines 10 and 11 unpack the function parameter pack.<\/p>\n Haskell and C++ apply pattern matching to use the right function.<\/p>\n There is a subtle difference between Haskell and C++. Haskell’s matching strategy is the first match. That’s the reason you have to define the particular case first. C++ matching strategy is the best to match. You can use pattern matching to define the multiplication of two numbers by successively applying addition.<\/p>\n For the sake of elegance, C++ first.<\/p>\n Lines 7 – 10 show the enrolled multiplication of the two numbers, 3 and 2. Line 1 is applied if m == 0<\/span> holds. If m == 1<\/span> holds, line 2 is used. The general case is line 3.<\/p>\n C++ applies a similar strategy. The difference is that the C++ version is more verbose, and I must first define the general case.<\/p>\n <\/p>\n The story about lazy evaluation in C++ is relatively short. That will change in C++20 with the ranges library from Eric Niebler. Lazy evaluation is the default in Haskell. Lazy evaluation means that an expression is only evaluated when needed. This strategy has two benefits.<\/p>\n The following code snippet shows three impressive examples in Haskell:<\/p>\n <\/p>\n\ntemplate<\/span> <int<\/span> N>\nstruct<\/span> Fac{\n static<\/span> int<\/span> const<\/span> value= N * Fac<N-1>::value;\n};\n\ntemplate<\/span> <>\nstruct<\/span> Fac<0>{\n static<\/span> int<\/span> const<\/span> value = 1;\n};\n<\/pre>\n<\/div>\nfac 0=<\/span> 1<\/div>\nfac n=<\/span> n * fac (n-1)<\/div>\nBut, there is a small difference between the recursive factorial function in Haskell and C++. To be precise, the C++ version is not recursive. Each invocation of the general class template with the template argument N instantiates a new class template with the template argument N-1. The graphic shows the process.<\/div>\n<\/div>\n![\"TemplateInstantiation\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/02\/TemplateInstantiation.png\")
<\/div>\n<\/div>\nYou can create powerful functions using recursion with lists and pattern matching. But that only holds partially for C++.<\/div>\n<\/div>\nManipulation of lists<\/h2>\n
\u00a0
![\"CharakteristikListManipulationEng\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/02\/CharakteristikListManipulationEng.png\")
<\/h2>\n\n
\nmySum []<\/span> =<\/span> 0\nmySum (x:<\/span>xs) =<\/span> x + mySum xs\nmySum [1,2,3,4,5] -- 15<\/span>\n<\/pre>\n<\/div>\n\n\n\n
\n \n 1\n 2\n 3\n 4\n 5\n 6\n 7\n 8\n 9\n10\n11\n12\n13\n14<\/pre>\n<\/td>\n
\n template<\/span><int<\/span> ...> \nstruct<\/span> mySum;\n\ntemplate<\/span><>\nstruct<\/span> mySum<>{\n static<\/span> const<\/span> int<\/span> value= 0;\n};\n\ntemplate<\/span><int<\/span> head, int<\/span> ... tail>\nstruct<\/span> mySum<head,tail...>{\n static<\/span> const<\/span> int<\/span> value= head + mySum<tail...>::value;\n};\n\nint<\/span> sum= mySum<1,2,3,4,5>::value; \/\/ 15<\/span>\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\nPattern matching<\/h3>\n
\n\n\n
\n \n 1\n 2\n 3\n 4\n 5\n 6\n 7\n 8\n 9\n10<\/pre>\n<\/td>\n
\n mult n 0 =<\/span> 0\nmult n 1 =<\/span> n\nmult n m =<\/span> (mult n (m - 1)) + n\n\n\n\nmult 3 2 =<\/span> (mult 3 (2 - <\/span>1)) + 3\n =<\/span> (mult 3 1 ) + 3\n =<\/span> 3 + 3\n =<\/span> 6\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n\n\n\n
\n \n 1\n 2\n 3\n 4\n 5\n 6\n 7\n 8\n 9\n10\n11\n12\n13\n14\n15<\/pre>\n<\/td>\n
\n template<\/span> <int<\/span> N, int<\/span> M>\nstruct<\/span> Mult{\nstatic<\/span> const<\/span> int<\/span> value= Mult<N, M-1>::value + N;\n};\ntemplate<\/span> <int<\/span> N>\nstruct<\/span> Mult<N, 1> {\nstatic<\/span> const<\/span> int<\/span> value= N;\n};\n\ntemplate<\/span> <int<\/span> N>\nstruct<\/span> Mult<N, 0> {\nstatic<\/span> const<\/span> int<\/span> value= 0;\n};\n\nstd::cout << Mult<3, 2>::value << std::endl; \/\/ 6<\/span>\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\nLazy evaluation<\/h2>\n
![\"CharakteristikLazyEvaluationEng\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/02\/CharakteristikLazyEvaluationEng.png\")
<\/p>\n\n
\n