What are and how to use Function References

A REFERENCE to a function is a type of data that, instead of simply containing data, contains a link to a specific function in memory.

At first, the concept might be surprising because when you start programming you get used to having variables with data on one side, and functions that manipulate them on the other.

But when we talked about variables, we said that a variable is “a box” that could contain different things. Or as Peter Griffin would say… “a box can have anything… even a boat!”

Now, this includes containing functions, not just data.

What are the advantages of being able to assign a function to a variable? That now we can treat a function as an object that can be assigned, passed as an argument, returned as a result, or stored in a data structure.

Function References

Let’s translate what we’ve said into some code (don’t worry too much about the syntax, we’ll see concrete examples later. For now, it’s just an excuse to understand each other).

What I was saying is that we are normally used to having,

That is, something like this,

// a variable with data
const my_variable = 10

// a function
function DoSomething()
{
}

DoSomething() // invoke the function

Now let’s see how to combine both things, a variable that contains a REFERENCE to the function. In this case, it would look something like this,

// a function
function DoSomething()
{
}

// a variable that contains a function
const my_variable = DoSomething;

my_variable() // invoke a function through the variable

Instead of calling the function by its original name, we can use our REFERENCE to the function to invoke it.

// this assigns the function to the variable
var my_variable = DoSomething;

// this invokes the function and assigns the result to the variable
var my_variable = DoSomething();

Examples of function references in different languages

Let’s see an example of how to make a reference to a function in different languages. For the example, we’ll create a sum function that takes two parameters a and b and returns the sum.

Then we’ll create a variable sum_function that contains a reference to the function. Then we invoke this function through the variable, instead of using its name.

This is how this example would look in different programming languages.

// Definition of the sum function
int Sum(int a, int b)
{
	return a + b;
}

void Main(string[] args)
{
	// Assigning the function to a delegate
	Func<int, int, int> sum_function = Sum;

	// Invoking the function through the delegate
	Console.WriteLine(sum_function(3, 4)); // Prints: 7
}

// Definition of the sum function
int sum(int a, int b) {
    return a + b;
}

int main() {
    // Assigning the function to a function pointer
    int (*sum_function)(int, int) = sum;

    // Invoking the function through the pointer
    std::cout << sum_function(3, 4) << std::endl; // Prints: 7
}

// Definition of the sum function
function sum(a, b) {
    return a + b;
}

// Assigning the function to a variable
const sum_function = sum;

// Invoking the function through the variable
console.log(sum_function(3, 4)); // Prints: 7

# Definition of the sum function
def sum(a, b):
    return a + b

# Assigning the function to a variable
sum_function = sum

# Invoking the function through the variable
print(sum_function(3, 4)) # Prints: 7

As we can see, apart from syntax differences, the concepts and even the usage are basically identical.

Internal Operation Advanced

The operation of function references is implemented in different ways depending on the programming language. However, broadly speaking, we can give a common explanation of how they work.

When a function is defined in a programming language, its code is stored in a specific memory location. This location is identified by a unique memory address.

A function reference is simply a type of data that contains this memory address. When we pass a function as a reference to another function or store it in a variable, what we are really doing is storing this memory address.

When we use a function reference to invoke the referenced function, the program accesses the memory address stored in the reference and executes the code stored at that location.

Furthermore, this allows the program to dynamically invoke the referenced function at runtime, which provides flexibility and dynamism to the code.