Re: [Axiom-developer] Unions in Spad

[Ralf Hemmecke]

> > It looks as if one also could do
> >
> >    if u case MachineInteger then ...
> >
> > with the current Aldor compiler, I just don't know how to type
> > "MachineInteger" since the compiler immediately takes the *type*
> > MachineInteger and not the *tag* MachineInteger.

> Use quotes like this?
>
>  'MachineInteger'
>
> That makes in a member of an Enumeration. Maybe that is what Aldor expects?

I should have told that I, of course, had already considered that option.

woodpecker:~/scratch>aldor -laldor -fx aaa.as
"aaa.as", line 13:         if u case 'MachineInteger' then {
                   ..................^
[L13 C19] #1 (Error) Argument 2 of `case' did not match any possible 
parameter type.
    The rejected type is Join(
                 with
                    ==  add ()
  ....
    Expected one of:
      -- Enumeration(machInt: Type)
      -- Enumeration(sStr: Type)

But, of course it must fail.

  'MachineInteger'

is nothing else than

  Enumeration(MachineInteger: Type)

but what I need is an element of this enumeration type.

> > Anyway, that usage of MachineInteger is not specified in the AUG so
> > maybe one better does not use it that way.

> I have become quite confident that Aldor takes the most general road
> whenever possible inspite of what might or might not be written in the
> user's guide, so I am inclined to think that you are right.
> 'Union(Integer,String)' might very well be acceptible to the Aldor
> compiler, we just need to intuit the proper usage.

It seems that MachineInteger is rather special. Look at the following 
session.

Ralf

woodpecker:~/scratch>aldor -gloop
     AA  L      DDDD      OOO    RRRR
    A A  L      D   D    O   O   R   R
   A  A  L      D    D  O     O  R   R
  AAAAA  L      D    D  O     O  RRRR
 A    A  L      D   D    O   O   R  R
A     A  LLLLL  DDDD      OOO    R   R

(c) Numerical Algorithms Group Ltd 1995-2001
Release: Aldor(C) version 1.0.3 for LINUX(glibc2.3) (debug version)
Type "#int help" for more details.
%1 >> #include "aldor"
                                           Comp: 190 msec, Interp: 50 msec
%2 >> #include "aldorinterp"
                                           Comp: 80 msec, Interp: 0 msec
%3 >> MyDom: with == add;
Defined MyDom @
 with
    ==  add ()

                                           Comp: 10 msec, Interp: 0 msec
%4 >> MyDom
  () @
 with
    ==  add ()

                                           Comp: 0 msec, Interp: 0 msec
%5 >> import from 'MyDom'
                                           Comp: 0 msec, Interp: 0 msec
%6 >> MyDom
      ^
[L6 C1] #1 (Error) Have determined 2 possible types for the expression.
        Meaning 1:
                 with
                    ==  add ()
       ...
        Meaning 2: Enumeration(MyDom: Type)

%7 >> MachineInteger
  () @ Join(
PrimitiveType with
        0: %
        1: %
        -: (%, %) -> %
        bytes: %
        coerce: SInt -> %
        coerce: % -> SInt
        integer: Literal -> %
        min: %
        max: %
        odd?: % -> Boolean
        zero?: % -> Boolean
    ==  add ()
,
Join(CopyableType, IntegerType) with
        mod+: (%, %, %) -> %
        mod-: (%, %, %) -> %
        mod*: (%, %, %) -> %
        mod/: (%, %, %) -> %
        mod^: (%, %, %) -> %
        modInverse: (%, %) -> %
        export to IntegerSegment(%)
    ==  add ()
,
 with
    ==  add ()
)
                                           Comp: 0 msec, Interp: 0 msec
%8 >> import from 'MachineInteger'
                                           Comp: 10 msec, Interp: 0 msec
%9 >> MachineInteger
  () @ Join(
PrimitiveType with
        0: %
        1: %
        -: (%, %) -> %
        bytes: %
        coerce: SInt -> %
        coerce: % -> SInt
        integer: Literal -> %
        min: %
        max: %
        odd?: % -> Boolean
        zero?: % -> Boolean
    ==  add ()
,
Join(CopyableType, IntegerType) with
        mod+: (%, %, %) -> %
        mod-: (%, %, %) -> %
        mod*: (%, %, %) -> %
        mod/: (%, %, %) -> %
        mod^: (%, %, %) -> %
        modInverse: (%, %) -> %
        export to IntegerSegment(%)
    ==  add ()
,
 with
    ==  add ()
)
                                           Comp: 0 msec, Interp: 0 msec


But try to compile

---BEGIN aaa.as
#include "aldor"
#include "aldorio"
macro I == MachineInteger;
M1: with == add;
main(): () == {
        U == Union(M1, String);
        import from String;
        import from U;
        import from 'M1';
        s: String := "I am a string";
        u: U := union s;
        if u case M1 then {
                stdout << "Integer: " << newline;
        } else {
                stdout << "String: " << newline;
        }
}

main();
---END aaa.as

woodpecker:~/scratch>aldor -laldor -fx aaa.as
Compiler bug...Bug: gen0UnionCaseIndex: branch not in union

Cool!