The section Function describes how to define a function. In this chapter we describe functions that give information about functions, and various utility functions used either when defining functions or calling functions.
5.1 Information about a function
NameFunction(
func ) F
returns the name of a function. For operations, this is the name used in
their declaration. For functions, this is the variable name they were
first assigned to. (For some internal functions, this might be a name
different from the name that is documented.)
If no such name exists, "unknown"
is returned.
gap> NameFunction(SylowSubgroup); "SylowSubgroup" gap> Blubberflutsch:=x->x;; gap> NameFunction(Blubberflutsch); "Blubberflutsch" gap> a:=Blubberflutsch;; gap> NameFunction(a); "Blubberflutsch" gap> NameFunction(x->x); "unknown" gap> NameFunction(NameFunction); "NAME_FUNC"
NumberArgumentsFunction(
func ) F
returns the number of arguments the function func accepts. For
functions that use arg
to take a variable number of arguments, as well
as for operations, -1 is returned. For attributes, 1 is returned.
gap> NumberArgumentsFunction(function(a,b,c,d,e,f,g,h,i,j,k)return 1;end); 11 gap> NumberArgumentsFunction(Size); 1 gap> NumberArgumentsFunction(IsCollsCollsElms); 3 gap> NumberArgumentsFunction(Sum); -1
5.2 Calling a function with a list argument that is interpreted as several arguments
CallFuncList(
func,
args ) F
returns the result, when calling function func with the arguments given in the list args, i.e. args is ``unwrapped'' so that args appears as several arguments to func.
gap> CallFuncList(\+, [6, 7]); 13 gap> #is equivalent to: gap> \+(6, 7); 13
A more useful application of CallFuncList
is for a function g that is
called in the body of a function f with (a sublist of) the arguments of
f, where f has been defined with a single formal argument arg
(see function); see the following code fragment.
f := function ( arg ) CallFuncList(g, arg); ... end;
In the body of f the several arguments passed to f become a list
arg
. If g were called instead via g
( arg )
then g would see a
single list argument, so that g would, in general, have to ``unwrap''
the passed list. The following (not particularly useful) example
demonstrates both described possibilities for the call to g.
gap> PrintNumberFromDigits := function ( arg ) > CallFuncList( Print, arg ); > Print( "\n" ); > end; function( arg ) ... end gap> PrintNumberFromDigits( 1, 9, 7, 3, 2 ); 19732 gap> PrintDigits := function ( arg ) > Print( arg ); > Print( "\n" ); > end; function( arg ) ... end gap> PrintDigits( 1, 9, 7, 3, 2 ); [ 1, 9, 7, 3, 2 ]
The following functions return fixed results (or just their own argument).
They can be useful in places when the syntax requires a function, but
actually no functionality is required. So ReturnTrue
is often used as
family predicate in InstallMethod
(see InstallMethod in ``Programming in GAP'').
ReturnTrue( ... ) F
This function takes any number of arguments, and always returns true
.
ReturnFalse( ... ) F
This function takes any number of arguments, and always returns false
.
ReturnFail( ... ) F
This function takes any number of arguments, and always returns fail
.
IdFunc(
obj ) F
returns obj.
Functions are GAP objects and thus have categories and a family.
IsFunction(
obj ) C
is the category of functions.
IsOperation(
obj ) C
is the category of operations. Every operation is a function, but not vice versa.
FunctionsFamily V
is the family of all functions.
[Top] [Up] [Previous] [Next] [Index]
GAP 4 manual
May 2002