In mathematics, a function can represent an arbitrary calculation. More concretely, it is the function rule that expresses the calculation, while the function also has a name. Giving it a name makes it easy to refer to the function rule, and hence it makes the calculation easily reusable.

In programming, the concept of a function is similar, but more general. It represents a reuable piece of program code, or program, for short. The code may perform a mathematical calculation, and hence represent a mathematical function. It may equally well go beyond a calculation and instead perform a complex drawing operation on the canvas, involving loop and conditional statements. We have actually already encountered a few functions provided by TScript: print and alert, mathematical functions like math.sin and math.sqrt, as well as the various turtle and canvas commands. By writing functions ourselves, we can define our own commands, which are composed of elementary commands provided by the programming language.

Mathematical Functions

Let's start with a mathematical function like f(x) = x² + 3x + 2. This function has a name (it is called f) and a function rule or expression x² + 3x + 2 representing a calculation. We already know how to perform the calculation programmatically: x^2 + 3*x + 2. Binding the calculation to the name f works as follows: function f(x) { return x^2 + 3*x + 2; } This is a bit more text than in the mathematical definition, but it is still rather close. We see two new keywords: function and return.

Before we dive into the details, let's give it a try. Copy the above code over into the editor and print a few values, like f(0), f(5), f(-1) and f(0.5) using print: print(f(5)); You should see the correct result, namely f(5) = 5² + 3·5 + 2 = 42.

Let's have a closer look at what just happened:

First, we have declared a new function with the name f. This is conceptually similar to declaring a variable. No calculation is done at this point. We have only defined a function rule and made it known to TScript under a name.
Inside of the print statement, the function is called or invoked. Similar to control structures like loops and conditional statements, this has the effect that the program continues at a different position, namely inside of the function body.
Before the function body starts to execute, the function's parameters are initialized. Our function has a single parameter called x. Technically speaking, x is nothing but a variable. Since we have called the function as f(5), the variable is initialized to the value 5. The effect is the same as if we would write var x = 5; — with the decisive difference that we gain a lot of flexibility, since we can easily call the function multiple times with different parameter values.
It is finally time for the program inside of the function to execute. The program consists of a single command, which is a return statement. It tells the computer two things: it shall return from the function, and it shall return a specific value to the caller. This return value can be a simple value like 42, "Hello World!" or true, or it can be the result or a calculation, as it is the case here.
The function is left and the control flow is returned to the point from where the function was invoked. The result of calling the function is the value returned by the function. We can think of this process as replacing the function call f(5) with the returned value, in this case 42. This is no magic, but exactly what we would expect from a mathematical function, so that we can perform further calculations from there onwards, like in f(5) + 7, which would yield 49.
This value is then passed on to the print function as a parameter. The mechanisms is exactly the same as when calling our own function f. Of course, print is not a mathematical function which takes one or multiple arguments and returns the result of a calculation. It is a function as used in programming most of the time, namely an arbitrary piece of program. It outputs the value as a message in the message area and then returns to the caller.

In effect, the effect of calling a function is the same a copying the code inside of the function body to the location where the function was called. That may look like this: var x = 5; print(x^2 + 3*x + 2); Like in math, the benefit of using a function is that we no not need to write out the formula each time we want to perform the calculation. This makes the code inside of the function reusable. Importantly, we can turn this argument around: whenever we aim to reuse a piece of code, we can simply turn it into a function and invoke that function from multiple locations in our program.

Create a function cube(x). The function shall implement the mathematical function rule cube(x) = x³.