check for a procedure
type(expr, 'procedure[rtype](type1, type2, ...)')
rtype, type1, type2, ...
any Maple types
The first form of this command performs a surface type test for expressions of type procedure. This includes both builtin and library- or user-defined procedures. See procedure for more information about the definition and use of procedures.
Note the distinction between an expression of type procedure and one of type function, which might be better called a ``function call''. In Maple it is the ``procedure'' type, rather than ``function'' that corresponds to what one thinks of as a ``mathematical function''.
The second form of test is a structured type test for procedures whose arguments and (optionally) return types are ``declared'' to have a given type. (The term ``declared'' is a misnomer, since one of Maple's strengths is its complete lack of type declarations. However, for the purpose of dynamic type checking, it is useful to think of argument type specifier and return type assertion annotations in this way.)
A ``declared'' return type may be tested for by enclosing the type specifier rtype (which may be an arbitrary Maple type) for the return type in brackets immediately after the symbol procedure. Procedures that do not have a return type assertion are considered to have a declared return type of anything.
Explicitly ``declared'' parameter types may be tested for by enclosing the types in parentheses. The names of parameters are not considered, only their ``declared'' types. A procedure p has type procedure(T1, T2, ..., Tn), where T1, T2, ..., Tn are types, if it has exactly n ``declared'' parameters and the i-th parameter is ``declared'' to have type Ti, for each i. In other words, p must have been defined by a procedure definition of the form p := proc(t1::T1, t2::T2, ..., tn::Tn). A parameter whose type is not specified is considered to have been ``declared'' to have type anything.
Note that argument types and return types are both optional and may be tested independently of one another.
Currently, argument and return types must match exactly the types found in the procedure data structure. Subtype relationships are not computed.
Note that no builtin procedure has either return type assertions or ``declared'' parameter types.
type/appliable, type/atomic, type/last_name_eval
The first few examples try to illustrate the sometimes confusing relationship between procedures and functions.
Here are some examples of various kinds of procedures, and some non-examples.
f := proc(x) x^2 end proc;
g ≔ t→sin⁡tcos⁡t:
These examples illustrate the use of the structured procedure type.
p := proc( a::algebraic, n::integer)::algebraic; a^n end proc:
p := proc( a::algebraic, n::integer) a^n end proc: # no return type assertion
Download Help Document
What kind of issue would you like to report? (Optional)