axiom-developer
[Top][All Lists]

## Re: [Axiom-developer] Bug in Tuple

 From: Ralf Hemmecke Subject: Re: [Axiom-developer] Bug in Tuple Date: Tue, 28 Feb 2006 10:40:40 +0100 User-agent: Thunderbird 1.5 (X11/20051201)

```On 02/27/2006 09:57 PM, Bill Page wrote:
```
```Ralf,

On February 25, 2006 4:22 PM you wrote:
```
```Can someone explain that?

Ralf

(6) -> Tuple(Integer) has coerce: Tuple(Integer)->PrimitiveArrayInteger

(6)  false
```
Type: Boolean
```
I presume what you meant to write was:

Tuple(Integer) has coerce:Tuple(Integer)->PrimitiveArray(Integer)

and that something like this might be possible in Aldor, right?
```
```
Well, I should have written something like

Tuple(Integer) has with {length: % -> MachineInteger}

```
but that doesn't work in Axiom either. And the reason in my eyes is that I cannot remember that there exists a description of SPAD/Axiom that covers something like http://www.aldor.org/docs/HTML/chap7.html#9.
```
But try in Aldor...

aldor -gloop
#include "aldor"
#include "aldorinterp"
%3 >> Tuple Integer
() @ Join(
with
,
with
element: (%, MachineInteger) -> AldorInteger
dispose!: % -> ()
length: % -> MachineInteger
tuple: (MachineInteger, Pointer) -> %
)
T%4 >> Tuple(Integer) has with {length: % -> MachineInteger}
T @ Boolean

```
```However the result the Axiom interpreter returns is still 'false'.
```
```
```
```So far as I can tell from the available Axiom documentation the
'has' expression only allows categories and axioms on the right
hand side (rhs). So we can write:

Tuple(Integer) has CoercibleTo(OuputForm)

and

Integer has commutative("*")

but almost anything else on the rhs returns either 'false' or
an error message. You might have expected to be able to write:

(14) -> Tuple(Integer) has with Tuple(Integer)->PrimitiveArray(Integer)
Internal Error
Unexpected error in call to system function pf2Sex1

but that apparently doesn't work either. :(
```
```
Well, you probably meant:

Tuple(Integer) has with coerce: %->PrimitiveArray(Integer)

However, you agree, that the "with" expression *is* a category.

```
```Just as in Aldor different things might be possible in SPAD, but
```
```
```
Right, Axiom is a bit weak here. But since we are (hopefully) agree to take Aldor for further development, then this is not such a big problem. The only point is that Axiom (as interpreter) should behave according to the Aldor language specification.
```
BTW, you cannot simply write something like

define MyCat: Category == with {
+: (%, %) -> %;
Commutative(+);
}

```
in Aldor, since that "commutative" is interpreted as a function with one argument and it should return a category. So you would have to write another category
```
define Commutative(f: (%, %) -> %): Category == with;

But that doesn't work since it is not clear what % refers to.

But you can at least compile the following:
--BEGIN
#include "aldor"
define Commutative(T: Type, f: (T, T) -> T): Category == with;
define CommutativePlus: Category == with {
+: (%, %) -> %;
Commutative(%, +);
}
--END

What is the problem here? Look at the definition of "Commutative".
Shouldn't Aldor allow me to write something like

--BEGIN
#include "aldor"
define Commutative(T: Type, f: (T, T) -> T): Category == {
n: Integer := 1\$Integer; while n>0 repeat n:=n+1;
with;
}
define PlusCat: Category == with {
+: (%, %) -> %;
*: (%, %) -> %;
Commutative(%, +);
}

(x: %) + (y: %): % == x;
(x: %) * (y: %): % == y;
}

main(): () == {
import from Dom;
import from TextWriter, String, Character;
b: Boolean == Dom has Commutative(Dom, +\$Dom);
stdout << "Dom has Commutative(Dom, +) = " << b << newline;
c: Boolean == Dom has Commutative(Dom, *\$Dom);
stdout << "Dom has Commutative(Dom, *) = " << c << newline;
}
main();
--END

Yes, this file compiles and runs successfully.
aldor -grun -laldor comm.as
Dom has Commutative(Dom, +) = T
Dom has Commutative(Dom, *) = T

```
How could this program stop? In fact, already the compiler has to perform an evaluation of "Commutativive(%, +)", so it could never have produced the program. And why T is returned for "*"?
```
Very strange. Can somebody explain?

Ralf

```