MOO provides a large number of useful functions for performing a wide variety of operations; a complete list, giving their names, arguments, and semantics, appears in a separate section later. As an example to give you the idea, there is a function named `length' that returns the length of a given string or list.
The syntax of a call to a function is as follows:
name(expr-1, expr-2, ..., expr-N)
where name is the name of one of the built-in functions. The
expressions between the parentheses, called arguments, are each
evaluated in turn and then given to the named function to use in its
appropriate way. Most functions require that a specific number of arguments
be given; otherwise,
E_ARGS is raised. Most also require that
certain of the arguments have certain specified types (e.g., the
length() function requires a list or a string as its argument);
E_TYPE is raised if any argument has the wrong type.
As with list construction, the splicing operator `@' can precede
any argument expression. The value of such an expression must be a
E_TYPE is raised otherwise. The elements of this list
are passed as individual arguments, in place of the list as a whole.
Verbs can also call other verbs, usually using this syntax:
expr-0:name(expr-1, expr-2, ..., expr-N)
Expr-0 must return an object number;
E_TYPE is raised otherwise.
If the object with that number does not exist,
E_INVIND is raised. If
this task is too deeply nested in verbs calling verbs calling verbs, then
E_MAXREC is raised; the default limit is 50 levels, but this can be
changed from within the database; see the chapter on server assumptions about
the database for details. If neither the object nor any of its ancestors
defines a verb matching the given name,
E_VERBNF is raised.
Otherwise, if none of these nasty things happens, the named verb on the given
object is called; the various built-in variables have the following initial
values in the called verb:
thisin the calling verb
All other built-in variables (
dobj, etc.) are initialized
with the same values they have in the calling verb.
As with the discussion of property references above, I said "usually" at the beginning of the previous paragraph because that syntax is only allowed when the name follows the rules for allowed variable names. Also as with property reference, there is a syntax allowing you to compute the name of the verb:
expr-0:(expr-00)(expr-1, expr-2, ..., expr-N)
The expression expr-00 must return a string;
E_TYPE is raised
The splicing operator (`@') can be used with verb-call arguments, too, just as with the arguments to built-in functions.
In many databases, a number of important verbs are defined on
system object. As with the `$foo' notation for properties on
#0, the server defines a special syntax for calling verbs on
$name(expr-1, expr-2, ..., expr-N)
(where name obeys the rules for variable names) is an abbreviation for
#0:name(expr-1, expr-2, ..., expr-N)