[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

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:

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


(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

But try in Aldor...

aldor -gloop
#include "aldor"
#include "aldorinterp"
%3 >> Tuple Integer
  () @ Join(
    ==  add ()
        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)


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

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:
#include "aldor"
define Commutative(T: Type, f: (T, T) -> T): Category == with;
define CommutativePlus: Category == with {
  +: (%, %) -> %;
  Commutative(%, +);

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

#include "aldor"
define Commutative(T: Type, f: (T, T) -> T): Category == {
  n: Integer := 1$Integer; while n>0 repeat n:=n+1;
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;

Yes, this file compiles and runs successfully.
aldor -grun -laldor
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?


reply via email to

[Prev in Thread] Current Thread [Next in Thread]