A Programming Language Manual

8.1 About functions

You have already used one function in all your programs. It's the main function, that is the start point of our programs. So why use more functions?

Imagine you have to do some calculation that depends on some input data. And you have to do it at different points in your program and with differnet values for the input data. Of course you can write the code each time you need it, but what if it's a complex calculation or if you have to use it pretty often? And what if later, you want to adjust it a little bit? You will have to go through all your program and that can be really difficult. So, to avoid these ugly situations, you group some parts of your program into functions.

To declare a function, you must write the key word func followed by it's name, the function parameters names inside brackets ( ), separated by commas, and then the instructions block enclosed in braces { }.

func name( parameter1, parameter2, ... )

If a function has no parameters, like the main function, then nothing will be written inside the brackets. You can't declare a function inside other function and you can't declare two functions with the same name. Choosing names for functions is similar to choosing names for variables. In a function, you can declare a variable with the same name as another variable from another function. They will not be mistaken, because such variables are considered local variables, each in it's function.

To use a function, you must call it, from another function. Meaning you expect the processor to jump to the called function, execute all it's instructions starting with the first one, and then return and continue the execution from where it was, after the call instruction. To call a function, just write it's name and give values for the expected parameters inside brackets.

 Let's have an example (copy all the following code into the "program.txt" file).

The function AddTwoNumbers expects to receive two parametsrs, named a and b. Those parameters are like local variables and can be usable only inside the function. Their values come from the caller function and they are 1 and 2 for the first call, and 10 and 20 for the second.

 The parameters (also called arguments) types must match their purpose in the function where they are send to. If a function expects an numeric parameter, sending a table instead will produce a bad argument type error. It's like when you must add some numbers that someone dictates you on the phone, and suddenly he starts telling you some people's names instead the numbers you're expecting. You will not be able to add them to your sum, would you?

8.2 Returned values

As said before, after finishing to execute all instructions from a function, the processor returns to the caller function, from where it left. You can force the processor to return before it reaches the last instruction from the current function, using the return instruction. Using return in the main function will cause the program to exit right at that point, since there's no other higher function to return to.

Another smart thing functions can do, is to return a result to the caller function.To do so, use the return instruction, followed by the constant value or the variable who's value you want to return. To use such a result, in the caller function you must store it in a variable, use it in an expresion, or give it to another function as a parameter.

Since the returned value have it's own type, we say that the function returns that specific type and it can be received only in a variable of the same type.

 Here is an example of a function with two parameters that returns their sum.

As you see above, before a function call, all parameters are evaluated, and only then they are sent to the function.

  GS9 language supports returning multiple values that can be used in a multiple assign operation. The returned values are matched with the variables in the assign operation providing additional ZERO values if needed or discarding unneeded values.

 Take great care when calling functions from themselfs. It's called recursion and it's a pretty useful but quite advanced technique, that if not used correctly, may lead to a program crash named stack overflow. Make sure you always have a returning condition, before the self call. Here is a bad example:

8.3 More about parameters

In GS9 all parameters are sent as "duplicates" except for strings and tables. This means that if you send an numeric parameter to a function and inside that function the parameter is changed, this will not affect the original value.

However if you send a table as a parameter and change it inside the function, the original table will change too. This is done for performance purposes, to prevent duplicating the whole table each time it's sent to a function. Same thing with strings, though since you can't actually change their content this is not very obvious.

 Here is an example of changing content of a table.

You can also handle situations when parameters can come with different types, using the typeof operator, or you can even have some missing paramters, that will be filled in as zeros.

 Here is an example of handling different types of parameters: