[Aldor-l] Re: [Axiom-developer] Bug in Tuple

[Ralf Hemmecke]

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
     ==  add ()
,
  with
         element: (%, MachineInteger) -> AldorInteger
         dispose!: % -> ()
         length: % -> MachineInteger
         tuple: (MachineInteger, Pointer) -> %
     ==  add ()
)
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
> I was't able to find any documentation about this.

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(%, +);
}

Dom: PlusCat == add {
	(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