Programming Language for Old Timers

Previous page   Table of Contents   Next page

Method Heads

A method head is used in the defun and defprotocol definition statements and in the require statement to identify a method. It specifies a function name and a parameter list, generally with types declared for some or all of the parameters. The syntactic type method-head is defined in the compiler module for this purpose. It parses into a parameter-list object with a function name.

A method head can be written either in the form of a function call using a parenthesized argument list or in the form of a prefix or infix operator or macro call. Thus a method head can resemble any of the ways that a function invocation can be written.

An assignment right-hand-side parameter can be appended using :=. This modifies the function name.

A result type can be appended using is (not used with :=).

Note that when using a parenthesized argument list, if the function is defined as an operator or a macro its name must be denatured with \.

When an assignment is specified the right-hand-side parameter is appended to the parameter list as an additional required parameter (no optional or keyword parameters are allowed) and the name becomes the function name concatenated with :=. This is the normal function of the := operator.

There is a special rule for the case where an assignment is specified, the right-hand-side parameter's type is unspecified or is anything, and the parameter-list contains a rest parameter. In this case, the right-hand-side parameter is discarded. The method is assumed to use the last element of the value of the rest parameter as a new value to be assigned, and to use the remaining elements of the value of the rest parameter as part of the specification of where to make the assignment. This is the only case where an assignment can be specified and the parameter list can contain other than required parameters.

There is no separate syntax for method-head. Instead the method-head parser parses any expression and disassembles the resulting P-expression as follows:

• The P-expression must be an invocation and the function being invoked must be a name, or a syntax error has occurred.
• If the function being invoked is the is operator, use the second argument as the result type and apply the remaining rules to the first argument, which must be an invocation of a name.
• The function being invoked is the name for the method head. Note that when the := operator is used the function name will get := appended during parsing.
• Process the arguments of the invocation into parameters as follows:
• An argument expression that is a quotation of a name introduces the optional, keyword, or rest parameters section. The name must be one of the three names optional, key, and rest. Such a quotation would typically be parsed from one of the keywords optional:, key:, or rest:.
• An argument expression that is an invocation of the = operator specifies an optional or keyword parameter with a default value. The second argument is the default value expression. Apply the remaining rules to the first argument.
• An argument expression that is an invocation of the is operator specifies a type restriction. The second argument is the type. Apply the remaining rules to the first argument.
• An argument expression that is a name becomes a parameter by that name.
• An argument expression that is an invocation must be a destructuring. The details are explained in the Destructuring section.
• Anything else as an argument expression is a syntax error.

A parameter list can only contain one rest parameter. As a special case, if there is one more argument expression after the rest parameter, that argument is simply a name, and the function name ends in ":=", the special rule for assignment applies and the extra argument is ignored.

Examples of method heads:

f(x)
f(x is integer)
f(x) is integer
f(x is integer, optional: y is integer = 0)
f(x, y, optional: z = 100) is list or false
f(x, rest: y)
f(x, optional: y, key: a, b, c)
f(x, y) := z
f(x is integer, y is list) := z is sequence

-(x is integer) is integer

(x is integer) + (y is integer) is integer

(x is dictionary)[key, key: default]

\is(object, type is class) is boolean

Previous page   Table of Contents   Next page