The AddFunction command defines an equivalent in a target language for a Maple function with name fname and function signature signature. The AddFunctions command defines multiple targets in a single calling sequence.

The GetFunction command returns a previously defined target language equivalent for fname.

The optional parameter libs is an equation of the form library=l, where l is a string or list of strings corresponding to libraries needed for translation to function properly in the target language.  This is identical in effect to writing translation as a procedure, and including AddLibrary commands for each of the libraries in l in the body of translation.

A function signature is an expression which is either a type, a expression of the form $\[\mathrm{type1},...,\mathrm{typen}\]::\mathrm{type0}$, or an expression of the form anything::type0.  The meaning associated with each of these is as follows.

A type - This indicates that fname is a special constant (for example, Pi) with type signature.

An expression of the form $\[\mathrm{type1},...,\mathrm{typen}\]::\mathrm{type0}$ - This indicates that fname is a function accepting $n$ arguments, with types given by type1 to typen respectively, with return type type0.

An expression of the form anything::type0 - This indicates that fname is a function accepting an arbitrary number of arguments of any type, with return type type0.

There can be multiple function signatures for a function name fname. If so, CodeGeneration attempts to match a given function call with the most appropriate signature, based on context.

Note: Maple uses the set of recognized type signatures in its type deductions, so it is useful to include as many type signatures as possible, even when one type signature is a special case of another. For example, suppose an implementation of abs function can accept both integer and float input (returning integer or float output respectively). This is equivalent to the function signatures $\left[\mathrm{integer}\right]::\mathbb{Z}$ and $\left[\mathrm{numeric}\right]::\mathrm{numeric}$.  To avoid needless type coercions, both of these type signatures should be explicitly specified in the language definition.

$\mathrm{with}\left(\mathrm{CodeGeneration}\right)\:$

$\mathrm{Printer}≔\mathrm{LanguageDefinition}\left[\mathrm{DefaultPrinter}\right]\left(\right)\:$

$\mathrm{Printer}:-\mathrm{AddFunction}\left(''sin''\,\left[\mathrm{numeric}\right]::\mathrm{numeric}\,''sin''\right)$

$\left[''sin''\,\varnothing \right]$

Printer:-AddFunction("csc", [numeric]::numeric,
    proc(a) Printer:-Print("1.0/sin(",a,")") end proc, numeric='double');

$\left[\mathbf{proc}\left(a\right)\mathrm{Printer}:-\mathrm{Print}\left(''1.0/sin(''\,a\,'')''\right)\mathbf{end\; proc}\,\varnothing \right]$