Chapter 3. Methods & Generic functions

Table of Contents

parameters & parameter Lists
Return Values
Bare Methods
Local Methods
Generic functions
Keyword Arguments

Dylan methods correspond roughly to the functions found in C and Pascal. They take zero or more named parameters, but also return zero or more named return values. A minimal Dylan method might look like the following:

define method hello-world()
  puts("Hello, world!");

This method has no parameters and an unspecified return value. It could return any number of values of any type. In order to make the above code more clear, the function could be rewritten as follows:

define method hello-world() => ();
  puts("Hello, world!");
end method;

There have been two changes. The function now officially returns no value whatsoever. Also note that end has been replaced by end method which could in turn be rewritten as end method hello-world. In general, Dylan permits all the obvious combinations of keywords and labels to follow an end statement.

parameters & parameter Lists

Dylan methods declare parameters in fashion similar to that of conventional languages, except for the fact that parameters may optionally be untyped. Both of the following methods are legal:

define method foo(x :: <integer>, y) end;
define method bar(m, s :: <string>) end;

Both foo and bar have one typed and one untyped parameter, but neither has a well-defined return value (or actually does anything). As in C, each typed parameter must have its own type declaration; there's no syntax for saying “the last three parameters were all integers”.

Functions with variable numbers of parameters include the #rest keyword at the end of their parameter lists. Thus, the declaration for C's printf function would appear something like the following in Dylan:

define method printf(format-string :: <string>, #rest arguments) => ();
  // Print the format string, extracting
  // one at a time from "arguments". Note
  // that Dylan actually allows us to
  // verify the types of variables,
  // preventing those nasty printf errors,
  // such as using %d instead of %ld.
  // ...
end method printf;

For an actual implementation of a lightweight printf function, see Appendix A.

Note that Dylan makes no provision for passing variables by reference in the Pascal sense, or for passing pointers to variables. parameter names are simply bound to whatever values are passed, and may be rebound like regular variables. This means that there's no way to write a swap function in Dylan (except by using macros). However, the following function works just fine, because it modifies the internal state of another object:

define method sell(car :: <car>, new-owner :: <string>) => ();
  if (credit-check(new-owner))
    car.owner = new-owner;
    error("Bad credit!");

If this sounds unclear, reread the chapter on variables and expressions.