When declaring a user-defined function, the function heading specifies the identifier (name) for the function, a list of the formal parameters (if any) within parentheses, and the function result type.   Parameters can also be referred to as Arguments.

Function declarations can be thought of as small multi-line programs.   The first line is always prefixed by the keyword Function, followed by a list of the parameters that are expected to be input, and lastly, the type for the single output result.    For a simple function, the subsequent lines contain the statement block – the body of the function that specifies how the function actually behaves.   Statement blocks start with the keyword begin, and finish with the keyword end.

Please also refer to User-defined Functions and Procedures.

Functions will always return a result value, as separate from any of the arguments. The data type of the result is specified in the declaration of the function, such as String below -

MyHowColdFunction( Arg1: integer) : string;

The following simple example declares the user-defined function called MyFunc.    The function has a single parameter called MyArg which is a piece of data that has been given a name.   This is called a named pair, a couplet, or a type pair. MyArg is defined as a string, and in this case the result will also be a string.   But the parameter types and result type do not have to be the same. 

The generated output will be assigned to the system variable known as Result. The statement block instructions say that the Result will be a new string by taking the value submitted by MyArg, prefixing it with three asterisks, and then place three asterisks as a suffix with no blank spaces between. 

function MyFunc(MyArg:string):string;
begin
Result := '***'+MyArg+'***';
end;

Or such as this example with the user-defined function WhatTemp, which takes temperature value in degrees fahrenheit as the parameter, and converts it to the equivalent degrees celsius by way of a calculation.

function WhatTemp(FahTemp:double):double;
begin
Result := (((FahTemp-32.00)/9.00)*5.00);
end;

A very useful user-defined function called BooleanAsString takes a boolean result, and converts it to a String, as shown below. The function can then be called within your script. Please see Testing For Null (empty or blank) Values for an example of the use of this particular function.

function BooleanAsString(b:boolean):string;
begin
if b then result := 'true' else result := 'false';
end;

If you were declaring a function that required more than one parameter of the same data type, the parameters are separated by a comma, and you can use parameter shorthand by declaring the function parameters as follows.  The function TheirMoniker creates a new string by joining the three string values together with an added space separating the three individual strings.

function TheirMoniker(Title,Christian,Surname:string):string;
begin
Result := Title+' '+Christian+' '+Surname;
end;

A function can also of course use multiple parameters of the same type to produce a result with a different data type.  The following is a basic example of a function called TotalCookies which takes several integer parameters and generates a calculated number that is then inserted into a string.   However, to insert the calculated value into the string, it is first converted into a string using the pre-defined function IntToStr.

function TotalCookies(NumPerBag,BagsPerBox,Boxes:integer):string;
begin
Result := 'There are '+IntToStr((NumPerBag*BagsPerBox)*Boxes)+' cookies.';
end;

Functions can use parameters of mixed data types, but there will always be some sort of conversion of one or more of the types involved.  In this example, the function ContactFunc is declared using string and integer parameters to generate a string result.   Notice the use of a semi-colon separating the two different data type parameters - it is only within the declaration as shown here, that parameters are separated with a semi-colon.    This example also includes the integer HomeNum which is converted into a string by using the pre-defined function called IntToStr.  Note the spaces that are intentionally included as part of each typed string.

function ContactFunc(CustName:string;HomeNum:integer):string;
begin
Result := 'Please contact '+CustName+' on '+IntToStr(HomeNum);
end;

While these examples all illustrate simple uncomplicated functions, functions can in fact be as complex and as powerful as you need them to be.   For instance, if we wanted to generate a function as a daily greeting, we would use a conditional statement block that tested whether the input parameters met certain criteria.  

In the following function called DailyHello, we pass in a name and birthday date as parameters, and test for whether the birthday date matches today’s date.   This function declaration uses several pre-defined functions as well as if-then-else to determine which message is returned as the result.   Several comments have also been added, identified by the double slashes at the beginning of the comments.   Anything following a double slash is ignored by the system, so comments can be appended to any line as long as the double slashes are used.

function DailyHello(StaffName:string;StaffBDay:TDateTime):string;
begin
//Check whether today's day and month match the birthday date
If ((DayOf(Now()))=DayOf(StaffBDay)) and (MonthOf(Now())=MonthOf(StaffBDay)) then
//TODAY is their birthday!
Result := 'Hello '+StaffName+'. Happy Birthday!'
else
//TODAY is NOT their birthday
Result := 'Hello '+StaffName+'. Have a happy day!';
end;