{"id":6495,"date":"2023-01-08T10:24:56","date_gmt":"2023-01-08T10:24:56","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/partial-function-application\/"},"modified":"2023-08-20T14:35:37","modified_gmt":"2023-08-20T14:35:37","slug":"partial-function-application","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/partial-function-application\/","title":{"rendered":"Partial Function Application"},"content":{"rendered":"

Partial Function Application is a technique in which a function binds a few of its arguments and returns a function taking fewer arguments. This technique is related to a technique used in functional languages called currying.<\/p>\n

<\/p>\n

 \"GeneralIdioms\"<\/p>\n

A few weeks ago, I had a discussion with a few of my readers. One reader said that I should write about Partial Function Applications. Another reader mentioned that C++ does not support function applications. This is wrong. C++ supports Partial Function Application. Consequently, I am writing today about std::function<\/code>, std::bind<\/code>, std::bind_front<\/code>, lambdas, auto<\/code>, and currying.<\/p>\n

Let me start with a bit of theory.<\/p>\n

Currying<\/h2>\n

Partial Function application is quite similar to a technique called currying<\/a>. Currying is a well-known technique used in functional languages such as Haskell<\/a>. It stands for a technique in which a function that takes more than one argument will successively be transformed into a series of functions taking only one argument. Therefore, a programming language such as Haskell has only functions taking one argument. I hear your question. How is it possible to implement a function such as add<\/code> which needs two arguments? The magic is happening implicitly. Functions that need n arguments are transformed into functions returning a function that only needs n -1 arguments. The first element is evaluated in this transformation.<\/p>\n

The name currying is coined by the mathematician Haskell Curry <\/a>and Moses Sch\u00f6nfinkel.<\/a> Currying is named after the family name of Haskell Curry; Haskell after his first name. Sometimes, currying is also called sch\u00f6nfinkeln.<\/p>\n

Partial Function Application is more powerful than currying because you can evaluate arbitrary function arguments. Since C++11, C++ supports std::function<\/code> and std::bind<\/code>.<\/p>\n

std::bind<\/code><\/h2>\n

std::bind<\/code> enables you to create callables in various ways. You can<\/p>\n

    \n
  • bind function argument at arbitrary positions,<\/li>\n
  • reorder the sequence of the function arguments,<\/li>\n
  • introduce placeholders for function arguments,<\/li>\n
  • partially evaluate functions.<\/li>\n<\/ul>\n

    Furthermore, you can<\/p>\n

      \n
    • directly invoke the new callable,<\/li>\n
    • use the callable in an algorithm of the Standard Template Library (STL),<\/li>\n
    • store the callable in std::function<\/code>.<\/li>\n<\/ul>\n

      Before I show you an example, I have to introduce std::function<\/code>:<\/p>\n

        \n
      • std::function<\/code> is a polymorphic function wrapper. It can take arbitrary callables and give them a name. Callables are all entities that behave like a function. In particular, these are lambda expressions, function objects, or functions themselves. std::function<\/code> is required if you have to specify the type of a callable.<\/li>\n<\/ul>\n

        Now, I’m done with the theory and can show an example of Partial Function Application:<\/p>\n

        <\/p>\n

        \n
        \/\/ bindAndFunction.cpp<\/span>\r\n\r\n#include <functional><\/span>\r\n#include <iostream><\/span>\r\n\r\ndouble<\/span> divMe<\/span>(double<\/span> a, double<\/span> b){\r\n  return<\/span> double<\/span>(a\/<\/span>b);\r\n}\r\n\r\nusing<\/span> namespace<\/span> std::<\/span>placeholders;                                       \/\/ (1)<\/span><\/em>\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n  \/\/ invoking the function object directly<\/span>\r\n  std::<\/span>cout <<<\/span> \"1\/2.0= \"<\/span> <<<\/span> std::<\/span>bind(divMe, 1<\/span>, 2.0<\/span>)() <<<\/span> '\\n'<\/span>;          \/\/ (2)<\/span><\/em>\r\n\r\n  \/\/ placeholders for both arguments                                     \/\/ (3)<\/span>\r\n  std::<\/span>function<<\/span>double<\/span>(double<\/span>, double<\/span>)><\/span> myDivBindPlaceholder=<\/span> std::<\/span>bind(divMe, _1, _2);\r\n  std::<\/span>cout <<<\/span> \"1\/2.0= \"<\/span> <<<\/span> myDivBindPlaceholder(1<\/span>, 2.0<\/span>) <<<\/span> '\\n'<\/span>;\r\n\r\n  \/\/ placeholders for both arguments, swap the arguments                 \/\/ (4)<\/span>\r\n  std::<\/span>function<<\/span>double<\/span>(double<\/span>, double<\/span>)><\/span> myDivBindPlaceholderSwap=<\/span> std::<\/span>bind(divMe, _2, _1);\r\n  std::<\/span>cout <<<\/span> \"1\/2.0= \"<\/span> <<<\/span> myDivBindPlaceholderSwap(2.0<\/span>, 1<\/span>) <<<\/span> '\\n'<\/span>;\r\n\r\n  \/\/ placeholder for the first argument                                 \/\/ (5)<\/span>\r\n  std::<\/span>function<<\/span>double<\/span>(double<\/span>)><\/span> myDivBind1St=<\/span> std::<\/span>bind(divMe, _1, 2.0<\/span>);\r\n  std::<\/span>cout<<<\/span> \"1\/2.0= \"<\/span> <<<\/span> myDivBind1St(1<\/span>) <<<\/span> '\\n'<\/span>;\r\n\r\n  \/\/ placeholder for the second argument                                \/\/ (6)<\/span>\r\n  std::<\/span>function<<\/span>double<\/span>(double<\/span>)><\/span> myDivBind2Nd=<\/span> std::<\/span>bind(divMe, 1.0<\/span>, _1);\r\n  std::<\/span>cout <<<\/span> \"1\/2.0= \"<\/span> <<<\/span> myDivBind2Nd(2.0<\/span>) <<<\/span> '\\n'<\/span>;\r\n\r\n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
         <\/p>\n
        In order to use the simple notation _1, _2<\/code> for the placeholders std::placeholders::_1, std::placeholders::_2<\/code> in the source code, I have to introduce the namespace std::placeholders<\/code> in line 1.<\/p>\n
        I bind in line 2 in the expression std::bind(divMe, 1, 2.0)<\/code> the arguments 1<\/code> and 2.0<\/code> to the function divMe<\/code> and invoke them in place. Lines 3, 4, 5, and 6 follow a similar strategy, but I give the created callables a name using std::function<\/code>, and invoke them finally. A template signature like double(double, double)<\/code> (line 4) or double(double)<\/code> (lines 5 and 6) stands for the type of callable that std::function<\/code> accepts. double(double, double)<\/code> is a function taking two doubles and returning a double.<\/p>\n
        In particular, the last two examples (lines 5 and 6) in which std::function<\/code> gets a function of arity two<\/strong> and returns a function of arity one<\/strong> is quite astonishing. The arity of a function is the number of arguments a function gets. std::bind<\/code> evaluates in both calls only one argument and uses for the non-evaluated one a placeholder. This technique is called Partial Function Application.<\/p>\n
        In the end, here is the output of the program.<\/p>\n
         \"bindAndFunction\"<\/p>\n
        There is another way in C++11 to use Partial Function Application: lambda expressions.<\/p>\n<\/p>\n
        Lambda Expressions<\/h2>\n
        std::bind<\/code> and std::function<\/code> are almost superfluous with C++11. You can use lambda expressions instead of std::bind<\/code>,  and almost always auto<\/code> instead of std::function<\/code>. Here is the equivalent program based on auto<\/code>, and lambda expressions.<\/p>\n
        <\/p>\n
        \n
        \/\/ lambdaAndAuto.cpp<\/span>\r\n\r\n#include <functional><\/span>\r\n#include <iostream><\/span>\r\n\r\ndouble<\/span> divMe<\/span>(double<\/span> a, double<\/span> b){\r\n  return<\/span> double<\/span>(a\/<\/span>b);\r\n}\r\n\r\nusing<\/span> namespace<\/span> std::<\/span>placeholders;\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n  \/\/ invoking the function object directly<\/span>\r\n  std::<\/span>cout <<<\/span> \"1\/2.0= \"<\/span> <<<\/span> [](int<\/span> a, int<\/span> b){ return<\/span> divMe(a, b); }(1<\/span>, 2.0<\/span>) <<<\/span> '\\n'<\/span>;\r\n\r\n  \/\/ placeholders for both arguments<\/span>\r\n  auto<\/span> myDivBindPlaceholder=<\/span> [](int<\/span> a, int<\/span> b){ return<\/span> divMe(a, b); };\r\n  std::<\/span>cout <<<\/span> \"1\/2.0= \"<\/span> <<<\/span> myDivBindPlaceholder(1<\/span>, 2.0<\/span>) <<<\/span> '\\n'<\/span>;\r\n\r\n  \/\/ placeholders for both arguments, swap the arguments<\/span>\r\n  auto<\/span> myDivBindPlaceholderSwap=<\/span> [](int<\/span> a, int<\/span> b){ return<\/span> divMe(b, a); };\r\n  std::<\/span>cout <<<\/span> \"1\/2.0= \"<\/span> <<<\/span> myDivBindPlaceholderSwap(2.0<\/span>, 1<\/span>) <<<\/span> '\\n'<\/span>;\r\n\r\n  \/\/ placeholder for the first argument<\/span>\r\n  auto<\/span> myDivBind1St=<\/span> [](int<\/span> a){ return<\/span> divMe(a, 2.0<\/span>); };\r\n  std::<\/span>cout<<<\/span> \"1\/2.0= \"<\/span> <<<\/span> myDivBind1St(1<\/span>) <<<\/span> '\\n'<\/span>;\r\n\r\n  \/\/ placeholder for the second argument<\/span>\r\n  auto<\/span> myDivBind2Nd=<\/span> [](int<\/span> b){ return<\/span> divMe(1<\/span>, b); };\r\n  std::<\/span>cout <<<\/span> \"1\/2.0= \"<\/span> <<<\/span> myDivBind2Nd(2.0<\/span>) <<<\/span> '\\n'<\/span>;\r\n\r\n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
         <\/p>\n
        Let me say write a few words about the lambda expressions. The expression [](int a, int b){ return divMe(a, b); }(1, 2.0)<\/code> defines a lambda exepression that executes divMe<\/code>. The trailing braces invoke the lambda expression just in place using the arguments 1<\/code> and 2.0<\/code>. On the contrary, the remaining lambda expressions are invoked in the subsequent lines. You can use a lambda expression to bind any argument of the underlying function.<\/p>\n
        So far, I have applied Partial Function application with std::bind<\/code> and lambda expressions. In C++20, there is a new variation of std::bind<\/code>:<\/p>\n
        std::bind_front<\/code><\/h2>\n
        std::bind_front <\/code>creates a callable. std::bind_front<\/code> can have an arbitrary number of arguments and binds its arguments to the front. You may wonder why we have std::bind_front<\/code> because we have since C++11 std::bind<\/code>, which can also bind to the front. Here is the point. First, std::bind_front<\/code> is easier to use because it does not need placeholders, and second,  std::bind_front<\/code> propagates an exception specification of the underlying callable.<\/p>\n
        The following program exemplifies that you can replace std::bind_front <\/code>with <\/code>std::bind,<\/code> or lambda expressions.<\/p>\n
        <\/p>\n
        \n
        \/\/ bindFront.cpp<\/span>\r\n\r\n#include <functional><\/span>\r\n#include <iostream><\/span>\r\n\r\nint<\/span> plusFunction<\/span>(int<\/span> a, int<\/span> b) {\r\n    return<\/span> a +<\/span> b;\r\n}\r\n\r\nauto<\/span> plusLambda =<\/span> [](int<\/span> a, int<\/span> b) {\r\n    return<\/span> a +<\/span> b;\r\n};\r\n\r\nint<\/span> main<\/span>() {\r\n    \r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n    \r\n    auto<\/span> twoThousandPlus1 =<\/span> std::<\/span>bind_front(plusFunction, 2000<\/span>);            \/\/ (1)<\/span><\/em>\r\n    std::<\/span>cout <<<\/span> \"twoThousandPlus1(20): \"<\/span> <<<\/span> twoThousandPlus1(20<\/span>) <<<\/span> '\\n'<\/span>;\r\n    \r\n    auto<\/span> twoThousandPlus2 =<\/span> std::<\/span>bind_front(plusLambda, 2000<\/span>);              \/\/ (2<\/em>)<\/span>\r\n    std::<\/span>cout <<<\/span> \"twoThousandPlus2(20): \"<\/span> <<<\/span> twoThousandPlus2(20<\/span>) <<<\/span> '\\n'<\/span>;\r\n    \r\n    auto<\/span> twoThousandPlus3 =<\/span> std::<\/span>bind_front(std::<\/span>plus<<\/span>int<\/span>><\/span>(), 2000<\/span>);        \/\/ (3)<\/span><\/em>\r\n    std::<\/span>cout <<<\/span> \"twoThousandPlus3(20): \"<\/span> <<<\/span> twoThousandPlus3(20<\/span>) <<<\/span> '\\n'<\/span>;\r\n    \r\n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\r\n    \r\n    using<\/span> namespace<\/span> std::<\/span>placeholders;\r\n    \r\n    auto<\/span> twoThousandPlus4 =<\/span> std::<\/span>bind(plusFunction, 2000<\/span>, _1);             \/\/ (4)<\/span><\/em>\r\n    std::<\/span>cout <<<\/span> \"twoThousandPlus4(20): \"<\/span> <<<\/span> twoThousandPlus4(20<\/span>) <<<\/span> '\\n'<\/span>;\r\n    \r\n    auto<\/span> twoThousandPlus5 =<\/span>  [](int<\/span> b) { return<\/span> plusLambda(2000<\/span>, b); };    \/\/ (5)<\/span><\/em>\r\n    std::<\/span>cout <<<\/span> \"twoThousandPlus5(20): \"<\/span> <<<\/span> twoThousandPlus5(20<\/span>) <<<\/span> '\\n'<\/span>;\r\n       \r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
         <\/p>\n
        Each call (lines 1 – 5) gets a callable taking two arguments and returns a callable taking only one argument because the first argument is bound to 2000<\/code>. The callable is a function (1), a lambda expression (2), and a predefined function object (line 3). _1<\/code> stands for the missing argument. With lambda expression (line 5), you can directly apply one argument and provide an argument b<\/code> for the missing parameter. Regarding readability, is std::bind_front<\/code> easier to use than std::bind<\/code>, or a lambda expression.<\/p>\n
        \"bindFront\"<\/p>\n
        What’s Next?<\/h2>\n
        Argument-Dependent Lookup (ADL), also known as Koening Lookup is a set of “magical” rules for the lookup of unqualified functions based on their function arguments.<\/p>\n
         <\/p>\n
         <\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
        Partial Function Application is a technique in which a function binds a few of its arguments and returns a function taking fewer arguments. This technique is related to a technique used in functional languages called currying.<\/p>\n","protected":false},"author":21,"featured_media":6493,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[379],"tags":[459],"class_list":["post-6495","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-patterns","tag-lambdas"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6495","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=6495"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6495\/revisions"}],"predecessor-version":[{"id":8106,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6495\/revisions\/8106"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/6493"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=6495"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=6495"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=6495"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}