6.9 How Axiom Determines What Function to Use
What happens if you define a function that has the same name as a
library function? Well, if your function has the same name and number
of arguments (we sometimes say arity) as another function in the
library, then your function covers up the library function. If you
want then to call the library function, you will have to package-call
it. Axiom can use both the functions you write and those that come
from the library. Let's do a simple example to illustrate this.
Suppose you (wrongly!) define sin in this way.
Type: Void
The value is returned for any argument.
Compiling function sin with type Float -> Float
Type: Float
If you want the library operation, we have to package-call it
(see ugTypesPkgCall
for more information).
Type: Float
Type: Float
Even worse, say we accidentally used the same name as a library
function in the function.
Compiled code for sin has been cleared.
1 old definition(s) deleted for function or rule sin
Type: Void
Then Axiom definitely does not understand us.
AXIOM cannot determine the type of sin because it cannot analyze
the non-recursive part, if that exists. This may be remedied
by declaring the function.
Again, we could package-call the inside function.
1 old definition(s) deleted for function or rule sin
Type: Void
Compiling function sin with type Float -> Float
+++ |*1;sin;1;G82322| redefined
Type: Float
Of course, you are unlikely to make such obvious errors. It is more
probable that you would write a function and in the body use a
function that you think is a library function. If you had also
written a function by that same name, the library function would be
invisible.
How does Axiom determine what library function to call? It very much
depends on the particular example, but the simple case of creating the
polynomial will give you an idea.
-
The is analyzed and its default type is
Variable(x).
- The is analyzed and its default type is
PositiveInteger.
- The is analyzed and its default type is
PositiveInteger.
- Because the arguments to ``/'' are integers, Axiom
gives the expression a default target type of
Fraction(Integer).
- Axiom looks in PositiveInteger for ``/''.
It is not found.
- Axiom looks in Fraction(Integer) for ``/''.
It is found for arguments of type Integer.
- The and are converted to objects of type
Integer (this is trivial) and ``/'' is applied,
creating an object of type Fraction(Integer).
- No ``+'' for arguments of types Variable(x) and
Fraction(Integer) are found in either domain.
- Axiom resolves
resolve
(see ugTypesResolve )
the types and gets Polynomial (Fraction (Integer)).
- The and the are converted to objects of this
type and + is applied, yielding the answer, an object of type
Polynomial (Fraction (Integer)).