Declaring Functions

All of a module's public functions must be declared. A function declaration in Limbo is similar to a function prototype in C and C++. It provides type information about the arguments and the function's return values. This allows the compiler to perform type-checking that ensures type safety at run-time.

The general form of a Limbo function declaration is:

	function_name: fn(arguments) : return_type;

Functions that are not declared by the module are private. They cannot be accessed by external modules. The compiler still performs type-checking against the function call(s) and the function definition.

The following example is a module that contains two functions, the public init function and a private function.

Program Listing 2-3 funcx.b

1. implement Command;
3. include "sys.m";
4. include "draw.m";
6. sys: Sys;
8. Command: module {
9. init: fn (nil: ref Draw->Context, argv: list of string);
10. };
12. init (nil: ref Draw->Context, argv: list of string) {
13. sys = load Sys Sys->PATH;
15. for (i := 1; i <= 10; i++) {
16. sys->print(" %2d %4d\n", i, sqr(i));
17. }
19. sqr (n: int): int {
20. return (n*n);
21. }

The function definition in Lines 19 through 21 is the private function. It is not declared in the module declaration.

The use of public and private functions is of greater consequence with respect to modules that are intended to be loaded by other modules. This is discussed more in Modules in Chapter 3.