4.10 Function Calls

The function call has the effect of calling the function function-var. The precise semantics are as follows.

First GAP evaluates the function-var. Usually function-var is a variable, and GAP does nothing more than taking the value of this variable. It is allowed though that function-var is a more complex expression, such as a reference to an element of a list (see Chapter Lists) list-var[int-expr], or to a component of a record (see Chapter Records) record-var.ident. In any case GAP tests whether the value is a function. If it is not, GAP signals an error.

Next GAP checks that the number of actual arguments arg-exprs agrees with the number of formal arguments as given in the function definition. If they do not agree GAP signals an error. An exception is the case when there is exactly one formal argument with the name arg, in which case any number of actual arguments is allowed.

Now GAP allocates for each formal argument and for each formal local (that is, the identifiers in the local declaration) a new variable. Remember that a variable is a location in a GAP program that points to a value. Thus for each formal argument and for each formal local such a location is allocated.

Next the arguments arg-exprs are evaluated, and the values are assigned to the newly created variables corresponding to the formal arguments. Of course the first value is assigned to the new variable corresponding to the first formal argument, the second value is assigned to the new variable corresponding to the second formal argument, and so on. However, GAP does not make any guarantee about the order in which the arguments are evaluated. They might be evaluated left to right, right to left, or in any other order, but each argument is evaluated once. An exception again occurs if the function has only one formal argument with the name arg. In this case the values of all the actual arguments are stored in a list and this list is assigned to the new variable corresponding to the formal argument arg.

The new variables corresponding to the formal locals are initially not bound to any value. So trying to evaluate those variables before something has been assigned to them will signal an error.

Now the body of the function, which is a statement, is executed. If the identifier of one of the formal arguments or formal locals appears in the body of the function it refers to the new variable that was allocated for this formal argument or formal local, and evaluates to the value of this variable.

If during the execution of the body of the function a return statement with an expression (see Return) is executed, execution of the body is terminated and the value of the function call is the value of the expression of the return. If during the execution of the body a return statement without an expression is executed, execution of the body is terminated and the function call does not produce a value, in which case we call this call a procedure call (see Procedure Calls). If the execution of the body completes without execution of a return statement, the function call again produces no value, and again we talk about a procedure call.

gap> Fibonacci( 11 );
  # a call to the function `Fibonacci' with actual argument `11'
89

gap> RightCosets( G, Intersection( U, V ) );;
  # a call to the operation `RightCosets'
  # where the second actual argument is another function call

As well as passing arguments to a function, providing the mathematical input to its calculation, it is sometimes useful to supply ``hints'' suggesting to GAP how the desired result may be computed more quickly, or specifying a level of tolerance for random errors in a Monte Carlo algorithm.

Such hints may be supplied to a function-call and to all subsidiary functions called from that call using the options mechanism. Options are separated from the actual arguments by a colon : and have much the same syntax as the components of a record expression. The one exception to this is that a component name may appear without a value, in which case the value true is silently inserted.

gap> Size( fpgrp : hard, tcselection := "external" );
  # a call to `Size' passing the options `hard' (value `true') and 
  # `tcselection' (value the string "external")

Options supplied with function calls in this way are passed down using the global options stack described in chapter Options Stack, so that the call above is exactly equivalent to

gap> PushOptions( rec( hard := true, tcselection := "external") );
gap> Size( fpgrp );
gap> PopOptions( );

Note that any option may be passed with any function, whether or not it has any actual meaning for that function, or any function called by it. The system provides no safeguard against misspelled option names.

[Top] [Previous] [Up] [Next] [Index]