[Axiom-developer] [#209 The function |Domain| is undefined] correct bug in coercion to OutputForm

[Bill Page]

Changes http://wiki.axiom-developer.org/209TheFunctionDomainIsUndefined/diff
--

??changed:
-This domain (renamed from AldorDomain) written in Aldor by Peter
This domain (based on AldorDomain) written in Aldor by Peter

??changed:
-\begin{aldor}[aldordom]
\begin{aldor}[domain]

??changed:
-Domain: BasicType with {
-       make: (T: BasicType) -> %;
-
-       theIntegerType: () -> %;
-       map: (%, %) -> %;
-       integerMod: PositiveInteger -> %;
-       
-       coerce: % -> OutputForm;
-
-       name: % -> SExpression;
-
-       lookup: (%, String, %) -> SExpression;
-
-       hashCode: % -> Integer;
Domain: SetCategory with {
        make: (T: BasicType) -> %;

        theIntegerType: () -> %;
        map: (%, %) -> %;
        integerMod: PositiveInteger -> %;

        coerce: % -> OutputForm;

        name: % -> SExpression;

        lookup: (%, String, %) -> SExpression;

        hashCode: % -> Integer;

??changed:
-       import {
-               BOOT_:_:DNameToSExpr: SExpression -> SExpression;
-               BOOT_:_:hashString: SExpression -> SExpression;
-       } from Foreign Lisp;
-       
-       Rep  ==> Type;
-       Rep2 ==> Record(v: Record(domType: SExpression -> SExpression, 
-                                 domName: SExpression -> SExpression,
-                                 notUsed: SExpression -> SExpression,
-                                 lookup:  (SExpression, SExpression, 
SExpression, 
-                                           SExpression, SExpression, 
SExpression,
-                                           SExpression) -> SExpression,
-                                 hashCode: SExpression -> SExpression,
-                                 unknown: SExpression -> SExpression),
-                       o: SExpression);
-       
-       import from Rep2;
-
-       make(T: BasicType): % == per T;
-[52 more lines...]
        import {
                BOOT_:_:hashString: SExpression -> SExpression;
                BOOT_:_:devaluate: SExpression -> SExpression;
        } from Foreign Lisp;

        Rep  ==> Type;
        Rep2 ==> Record(v: Record(domType: SExpression -> SExpression,
                                  domName: SExpression -> SExpression,
                                  notUsed: SExpression -> SExpression,
                                  lookup:  (SExpression, SExpression, 
SExpression,
                                            SExpression, SExpression, 
SExpression,
                                            SExpression) -> SExpression,
                                  hashCode: SExpression -> SExpression,
                                  unknown: SExpression -> SExpression),
                        o: SExpression);

        import from Rep2;

        make(T: BasicType): % == per T;
        theIntegerType(): % == per Integer;
        integerMod(p: PositiveInteger): % == per(IntegerMod p);

        map(arg: %, ret: %): % == {
                per( (rep arg) -> (rep ret));
        }


        (a: %) = (b: %): Boolean == {
                import from Integer;
                hashCode(a) = hashCode(b)
        }


        coerce(t: %): OutputForm == {
                import from String;
                name(t)::OutputForm
        }

        name(t: %): SExpression == {
                dom := t pretend SExpression;
                devaluate(dom);
        }

        -- nb: cf. interop.boot, basicLookup
        lookup(t: %, name: String, type: %): SExpression == {
                -- lookup takes the following arguments:
                -- domain rep, domain, operation, conspair, flag, lookupFn
                import from List SExpression;
                dom := t pretend Rep2;
                box: SExpression := convert [convert ""];
                lookupFn :=  dom.v.lookup;
                nil := convert [];
                lookupFn(dom.o,
                         dom pretend SExpression,
                         hashString(convert name),
                         convert hashCode(type),
                         box,
                         nil, lookupFn pretend SExpression);
        }

        hashCode(t: %): Integer == {
                dom := t pretend Rep2;
                integer((dom.v.hashCode)(dom.o))
        }

        local devaluate(s: SExpression): SExpression == {
                BOOT_:_:devaluate(s);
        }

        local hashString(s: SExpression): SExpression == {
                BOOT_:_:hashString(s);
        }

--
forwarded from http://wiki.axiom-developer.org/address@hidden