[Aldor-l] question about set! in streams

[Martin Rubey]

Dear all,

I'm just attempting to solve the initial values problem. However I stepped on
an Aldor problem.

Can somebody explain the output of the attached program to me?

WARNING: it enters an infinite loop.

The output begins with
-------------------------------------------------------------------------------
set!01
set!end
Hi
set!01
coeff0
coeff0
coeff0
coeff0
coeff0
-------------------------------------------------------------------------------

and goes on with coeff0 forever...

Short explanation: The following program works as expected. Its output is
simply

-------------------------------------------------------------------------------
set!01
-------------------------------------------------------------------------------

i.e., coefficient is never called.

#include "aldor"
#include "aldorio"


define GeneratingSeriesCategory: Category == with {
        0: %;
        coefficient: (%, Integer) -> Integer;
        set!: (%, Integer, Integer) -> Integer;
}
GeneratingSeries: GeneratingSeriesCategory == add {
        Rep == Stream Integer;
        import from Integer, Rep, MachineInteger;
        0: % == per stream(0);
        coefficient(x: %, n: Integer): Integer == {
                stdout << "coeff" << n << newline;      
                (rep x).(machine n);
        }
        set!(x: %, n: Integer, v: Integer): Integer == {
                stdout << "set!" << n << v << newline;  
                set!(rep x, machine n, v);
        }
}
test(): () == {
        import from Integer;
        g: GeneratingSeries;
        set!(g, 0, 1);
}
test();

-------------------------------------------------------------------------------
-------------------------------------------------------------------------------

The story is different for the following program, where some recursion is
taking place. Note that generatingSeries$MyList is defined in terms of
itself. Still, I don't understand why coefficient is called. Is there a way to
modify generatingSeries$MyList without having coefficient called?

!!!PLEASE HELP!!!

Martin

-------------------------------------------------------------------------------
#include "aldor"
#include "aldorio"

define GeneratingSeriesCategory: Category == with {
        0: %;
        coerce: Stream Integer -> %;
        coefficient: (%, Integer) -> Integer;
        set!: (%, Integer, Integer) -> Integer;
        +: (%, %) -> %;
        *: (%, %) -> %; 
}
GeneratingSeries: GeneratingSeriesCategory == add {
        Rep == Stream Integer;
        import from Integer, Rep, MachineInteger;
        0: % == per stream(0);
        coerce(s: Stream Integer): % == per s;
        coefficient(x: %, n: Integer): Integer == {
                stdout << "coeff" << n << newline;      
                (rep x).(machine n);
        }
        set!(x: %, n: Integer, v: Integer): Integer == {
                stdout << "set!" << n << v << newline;  
                z := set!(rep x, machine n, v);
                stdout << "set!end" << newline; 
                z;
        }
        
        (x: %) + (y: %): % == per stream(0$I, (n:MachineInteger):Integer 
                                              +-> (rep x).n + (rep y).n);

        (x: %) * (y: %): % == {
                local coeffTimes(nMI: MachineInteger): Integer == {
                        local n       : Integer := nMI::Integer;
                        local startIdx: Integer := 0;
                        local endIdx  : Integer := n;       
  
--                      if zero? ( coefficient( x, 0 ) ) then
--                      {
--                              startIdx := 1;
--                      }

                        z: Integer := 0;
                        for k in startIdx .. endIdx repeat {
                                z := z + coefficient( x, k ) 
                                       * coefficient( y, (n-k) );
                        }
                        z;
                }               
                per stream(0$MachineInteger, coeffTimes);
        }
}

define CombinatorialSpecies(L: PrimitiveType): Category == with {
        generatingSeries: GeneratingSeries;
}

CharacteristicSpecies(n:Integer)(L:PrimitiveType): CombinatorialSpecies L == 
    add {
        Rep == Set L;
        nn: MachineInteger == machine n;
        nth(k: MachineInteger): Integer == if k = nn then return 1 else 0;
        import from Rep;
        generatingSeries: GeneratingSeries == {
                import from Stream Integer;
                stream(0, nth, next nn, 0) :: GeneratingSeries;
        }
}


1(L: PrimitiveType): CombinatorialSpecies L == 
        CharacteristicSpecies(0$Integer)(L);

X(L: PrimitiveType): CombinatorialSpecies L == 
        CharacteristicSpecies(1$Integer)(L);

(+)(
    F: (T: PrimitiveType) -> CombinatorialSpecies(T),
    G: (T: PrimitiveType) -> CombinatorialSpecies(T)
): (L: PrimitiveType) -> CombinatorialSpecies(L) == (L: PrimitiveType):
    CombinatorialSpecies(L) +-> add {
        generatingSeries: GeneratingSeries == generatingSeries$F(L) +
    generatingSeries$G(L);
}

(*)(
    F: (T: PrimitiveType) -> CombinatorialSpecies(T),
    G: (T: PrimitiveType) -> CombinatorialSpecies(T)
): (L: PrimitiveType) -> CombinatorialSpecies(L) == (L: PrimitiveType):
    CombinatorialSpecies(L) +-> add {
        generatingSeries: GeneratingSeries == {
                import from Stream Integer;
                coerce stream( 0$MachineInteger, 
                    (n:MachineInteger):Integer +-> 
                              coefficient(generatingSeries$F(L) *
                                          generatingSeries$G(L), n::Integer) );
        }
}

MyList(L: PrimitiveType): CombinatorialSpecies L == ( 1 + X*MyList*MyList)(L);

testMyList(): () == {
        import from Integer, String, MyList String;
        h: GeneratingSeries := 0;
        set!(h, 0, 1);
        g: GeneratingSeries := generatingSeries;
        stdout << "Hi" << newline; -- until here everything works just fine     
        set!(g, 0, 1);
}
testMyList();

-------------------------------------------------------------------------------