The following builtin functions can be overridden by object methods:

The andmap (and ormap and xormap) method expects two or more arguments:

export andmap::static := proc( p::appliable, self )
   ...
end proc:

The p argument is the procedure to be applied to each element of the object, and is expected to return true, false, or FAIL. The method should check the validity of the return value. When p returns false in andmap, the method should immediately return false. Likewise, when p returns true in ormap, the method should immediately return true.

If a container object does not export andmap (or ormap or xormap), and one of these functions is called with such an object as the second argument, Maple will attempt to use either the object's ModuleIterator method if it exists, or its lowerbound, upperbound, and ?[] methods to iterate over the object, calling p on the object's behalf, just as if the function had been called on a built-in container (such as a list).

A convert method needs to be able to deal with three possibilities: converting to the object from another type, converting from an object to another type, and applying a conversion where the object is an extra parameter (the third or later argument).

A diff method needs to handle three possibilities: differentiating an object, differentiating with respect to an object, or both.

If an object exports a diff method, it should also export a has method.  Maple uses has to determine if an expression contains the variable of differentiation.  If has returns false, 0 is returned immediately.  The built-in version of has does not look inside of objects, and thus will return false.

The entries and indices methods should return a sequence of the entries and indices of a container object respectively. There should be a one-to-one correspondence between the indices and the entries, that is, the i-th index should yield the i-th element when passed to the ?[] method.

Each element of the sequence must be a list containing the actual entry or index. The nolist option of these builtins is handled automatically by Maple, and need not be considered when implementing these methods.

In order for the pair option of indices and/or entries to work with an object, both methods must be implemented. Again, Maple itself handles this option; the methods need not consider it.

The indexorder option of entries and indices is not supported.

There are two calling sequences for the built-in eval.

eval( expr );

eval( expr, substitutions );

An object's eval method only overrides the second calling sequence.

As eval works recursively, if expr contains an object that implements eval, that object's eval method will be called.

In the second calling sequence of the built-in eval, the substitutions can be specified in various ways.  The eval method will have each equation passed as a separate argument.

An evalf method should convert the object into a floating-point value.

The evalf method is often called with an index (evalf[digits]) to specify the number of digits the expression should be evaluated to.  When the object method is called, the value of the Digits environment variable will have been set if a value was given.

Implementing an evalhf method allows an object to be used in Maple's evalhf subsystem.  An evalhf method should convert the object into one of the types that evalhf can manipulate.  For the best performance, one of the following should be returned:

A hardware float

An hfarray

A Maple procedure that does not use lexical scoping

The has method checks to see if an object contains an expression, if an expression contains an object, or if one object is contained in another.

When declaring an object that exports a has method that uses the object name as a type, the named object syntax

module Obj()
   ...
end module:

Obj := module()
   ...
end module:

These three can be used together to implement iteration over an object, as an alternative to implementing a ModuleIterator procedure. See ModuleIterator for more details, and object,operators for special considerations when implementing `?[]`.

The map, map2 and map[n] functions are all overridden by a single map method.  The calling sequence of the map method is:

export map::static := proc( oindex::integer, inplace::truefalse, func )
   ...
end proc:

If the parameter declaration given above is used, then the special sequence _rest are the arguments to be passed to func and the element _rest[oindex] is the element to be mapped over.  If e is an element of _rest[oindex] then the mapped value should be:

func( _rest[..oindex-1], e, _rest[oindex+1..] )

To override the max and min routines, export methods with the following declaration:

export max::static := proc( definedOnly::truefalse, a, b:=NULL, $ )
   ...
end proc;

export min::static := proc( definedOnly::truefalse, a, b:=NULL, $ )
   ...
end proc;

In Maple the max and min routines work on a combination of containers and elements. To handle these cases, the corresponding methods must be able to handle the case where b is NULL, indicating that it should return the maximum (or minimum) value stored in container object a, or a itself if it is not a container. In the general case, a and b will have a value and at least one of a or b will be an object. If the object is a container, then the maximum (or minimum) value between the elements in the container and the other argument should be returned.  Otherwise the maximum (or minimum) value of a and b should be returned.

If a container object is empty, the max or min method should return NULL, not -infinity or infinity, as the container may be nested in other containers having values that are not numeric (e.g. strings). Maple will convert the final value of the initial call of max or min into the appropriate infinity if no values were found at all in any of the arguments.

Likewise, if a container object contains only empty sub-containers (either similar objects, or ordinary lists, sets, or Arrays), the result should be NULL as well. This is best achieved using the nodefault index option when recursively calling max or min on these sub-containers.

If an object does not define min or max, Maple will assume it represents a value instead of a container, and will attempt to determine the correct element using an overloaded < (less than) operator, if it is defined.

The member method determines if a container contains a value.  If the container does contain the value, member should return the index that can be used by ?[] to retrieve that element.  If the container does not contain the value, 0 should returned.

If an object wants to implement member but does not implement the ?[] method, it should return undefined if the value is in the container, and 0 if it is not.

More information on the consequences of implementing ?[] can be found in object,operators.

Evaluating an expression of the form $a\in b$ can result in a call to member. More details can be found in object,operators.

The normal method has the following signature:

export normal::static := proc( self, { expanded::truefalse = false }, $ )
   ...
end proc:

The select and remove methods have the following signature:

export select::static := proc( inplace::truefalse, fn, self )

export remove::static := proc( inplace::truefalse, fn, self )

export selectremove::static := proc( inplace::truefalse, fn, self )

Any additional arguments to select, remove, or selectremove will be passed as additional arguments to the corresponding method, and can be accessed via _rest.

The sort method has the following signature:

export sort :: static := proc( inplace::truefalse, self )
   ...
end proc:

Any additional arguments to sort will be passed as additional arguments to the sort method, and can be accessed via _rest.

The subs method has the following signature:

export subs :: static := proc( inplace::truefalse, eqns::{list,MyObject}, expr::anything, $ )
   ...
end proc:

If eqns is a list, then the third argument (expr) is the object whose subs method was invoked.  If the second argument is an object with a subs method, then the third parameter can be anything.

Objects can be used directly as types and an Object can define a ModuleType method to further refine this test.  However, this does not allow an object to be tested by types that are not aware of the object. You can accomplish this by overriding the type method.

When the first argument of a call to type is an object that exports a type method and the second argument is not a module type and not the name `module`, then the type override will be called.

export type :: static := proc( self::MyObject, t, $ )
   :-type( self:-value, t )
end proc:

The first argument is the object, the second argument is the given type.

The type override should return one of three values:

true : the object does match the given type

false : the object does not match the given type

NULL : undecided, the type checking continues as if the type override had not been written.