C++ Binding and Currying

There is one more technique that we’re likely to find useful, and that is the ability to manipulate and bind the arguments of functions that already exist.

Binding and std::bind

Binding is a useful technique to deal with scenarios where you already have a function that almost meets your needs, but the arguments are not quite right.

This standard library provides two useful helpers for this: std::bind and std::placeholders are both available within <functional>

Let’s take a look at bind in isolation first. For example, let's imagine we already have a function that returns a boolean if a given Character is alive:

1#include <functional>
2
3using std::bind;
4
5class Character {
6public:
7  bool isAlive() const {
8    return true;
9  }
10};
11
12Character PlayerCharacter;
13
14bool isAlive(const Character& Character) {
15  return Character.isAlive();
16}
17

We now need to create a function that returns true if the character the current player is controlling is alive. We could create a new function in the normal way:

1bool isPlayerCharacterAlive() {
2  return isAlive(PlayerCharacter);
3}
4

But, we could also just use the existing function if we bind its argument to the value we want. We can do that using std::bind which will return a new callable, which we can invoke as needed:

1auto isPlayerCharacterDead {
2  bind(isAlive, PlayerCharacter)
3};
4
5isPlayerCharacterDead();
6

As an extension of this idea, we’ll also often want to only bind some of the arguments to a function. This is called partial application.

Partial Application

Previously, we’ve always provided a function with all the arguments it needs upfront.

Partial application is the idea that we don’t necessarily need to do that. For example, imagine we have a function that accepts two arguments.

Rather than providing both arguments, we provide only one. This action returns another callable, which we might call a “partially applied function”. We can then later call that function, with the remaining arguments.

If we do not provide all the function arguments when using std::bind, we get this behavior by default:

1#include <iostream>
2#include <functional>
3
4using std::cout, std::endl;
5
6int Add(int x, int y) {
7  return x + y;
8}
9
10int main() {
11  // We provide the first argument - 5 - here
12  auto Add5 { bind(Add, 5) };
13  
14  // And the second argument - 1 - here
15  cout << Add5(1) << endl;
16
17  // Add5 is a "partially applied function"
18  // We can keep using it:
19  cout << Add5(5) << endl;
20  cout << Add5(20) << endl;
21}
22

This program logs out:

16
210
325
4

In the first line of our main function, we are creating a new callable called Add5. When invoked, this function will call our Add function with two arguments. The first argument will be 5, and the second argument will come from the first argument on each invocation of Add5

Partial application is useful when we are going to call a function many times throughout our code base, but one or more of the arguments is going to be the same in most, or every invocation.

This is particularly problematic if determining what that argument should be has a large performance cost.

Rather than repeatedly calculating and providing that same argument, we can provide it just once to create a partially applied function. We can then call the partially applied function as many times as needed.

std::placeholders

Behind the scenes, std::bind is leaving placeholders for future arguments, using std::placeholders. For simple cases, the default behavior is exactly what we want, but we can also make this explicit:

1auto Add5 { bind(Add, 5, placeholders::_1) };
2

We also have access to placeholders::_2, placeholders::_3, and so on. The benefit of using std::placeholders directly is it lets us define the mapping between the arguments of the partially applied function, and the arguments of the bound function.

For example, if we wanted to provide the 1st and 3rd arguments to a function, but leave the 2nd as a placeholder, we’d need to use std::placeholders

1using std::string, std::cout, std::bind, std::placeholders;
2
3void LogStrings(
4  string Start, string Middle, string End
5) {
6  cout << Start << Middle << End;
7}
8
9auto SayHello {
10  bind(
11    LogStrings,
12    "Hello ",
13    placeholders::_1, ",
14    Welcome Back!"
15  );
16}
17
18SayHello("Ryan");
19

1Hello Ryan, Welcome Back!
2

A More Complex Example

Let’s go back to our Party.every code to see a more complex example that is closer to real problems we’re likely to solve by partial application. Let's imagine we want to check if every character in our party is ready to start an epic quest:

1int main() {
2  Quest EpicQuest;
3  Party Fellowship;
4  bool canStartQuest {
5    Fellowship.every(/* TODO: Pass a function here */);
6  }
7}
8

We may already have a function that checks if a specific Character is ready to start a specific Quest:

1bool canStartQuest(
2  const Character& Character, const Quest& Quest
3) {
4  // ...
5}
6

This existing function almost meets our needs, the only problem is that our Party.every expects to receive a function that accepts a const Character& as its only argument, whereas our current function has a second const Quest& argument.

Rather than creating a new function, let's use bind and placeholders to solve the problem:

1int main() {
2  Quest EpicQuest;
3  Party Fellowship;
4  auto Predicate {
5    bind(canStartQuest, placeholders::_1, EpicQuest)
6  };
7  bool canStartQuest {
8    Fellowship.every(Predicate)
9  };
10}
11

So, Predicate is now exactly in the form that Party::every wants - a function that accepts a single const Character& argument and returns a bool.

Every time Predicate is called, canStartQuest is going to be called with two arguments. The first argument will be the first argument passed to Predicate, for which we have left a placeholder for using placeholder::_1. The second argument will always be the same - a const reference to EpicQuest.

Partial application, and this style of programming in general, can be very confusing. It’s normal to be struggling at this point. Familiarity with these concepts, and recognizing where they can be used, just comes with practice and experience.

As a final example, let's see a slightly simpler, but more niche use of std::placeholders:

Changing Argument Order with std::placeholders

Another option available to us using std::placeholders is the ability to change the order of arguments. For example, we can put placeholders::_2 before placeholders::_1:

1#include <iostream>
2#include <functional>
3
4using std::cout, std::bind, std::placeholders;
5
6int Subtract(int x, int y) {
7  return x - y;
8}
9
10int main() {
11  cout << Subtract(5, 2) << "\n";
12  auto InvertedSubtract {
13    bind(Subtract, placeholders::_2, placeholders::_1)
14  };
15  cout << InvertedSubtract(5, 2) << "\n";
16}
17

This program logs out the following:

13
2-3
3