axiom-developer
[Top][All Lists]
Advanced

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

Re: [Axiom-developer] aldor stream oddities


From: Ralf Hemmecke
Subject: Re: [Axiom-developer] aldor stream oddities
Date: Thu, 09 Aug 2007 18:08:22 +0200
User-agent: Thunderbird 2.0.0.6 (X11/20070728)

Hello,

I was about to finish my answer, (see below) but the "_"-trick is by far better.

Ralf

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


Hi Franz,

On 08/09/2007 04:07 PM, Franz Lehner wrote:
> Hello,
>
> is there a way to get hold of generate$Stream using the aldor
> compiler? I spent quite some time until figuring out that generate
> is probably a keyword in aldor (I could not check as the aldor
> site seems to be down) and this causes strange error messages.

generate is a keyword in Aldor.

> =================================================
> #include "axiom"
>
> teststream: with {
>         zerostream:()->Stream Integer;
> } == add {
>         zerostream():Stream Integer == {
>                 import from Integer;
>                 generate((x:Integer):Integer +-> 
address@hidden,address@hidden);
> }
> }
> =================================================

I think you are out of luck here.

The definition in stream.spad is

    generate f    == delay concat(f(), generate f)
    gen:(S -> S,S) -> %
    gen(f,s) == delay(ss:=f s; concat(ss, gen(f,ss)))
    generate(f,s)==concat(s,gen(f,s))

which could mean that you could try to define your own
"mygenerate" instead of "generate". The tricky thing then is "delay".
That is yet another keyword (unused though) in Aldor.

The definition of "delay" in that file is

    delay(fs:()->%) == [NonNullStream, fs pretend %]

So you have to give a definition for "mydelay", as well.

The hardest part is "NonNullStream". It's definition is

    NonNullStream: S := _$NonNullStream$Lisp pretend S

But the following works in Axiom. As you see, lot's of "pretend"s. So don't try that at home.

Say

)co aaa.as
zerostream()

---BEGIN aaa.as
#include "axiom"

MyStream(S: Type): with {
  mygenerate: (() -> S) -> %;
  mygenerate: (S -> S,S) -> %;
} == Stream S add {
  Rep == Record(firstElt: S, restOfStream: %);
  macro st x == x pretend Stream S;
  import from Rep;
  s: S == (1$Integer) pretend S; -- we need an element that we never access
  ls: List S == [s]; -- auxiliary
  import from Integer, StreamTaylorSeriesOperations Integer;
  import from Stream Integer;
  REC == Record(firstElt: S, restOfStream: Stream S);
  import from REC;
  NonNullStream: S == ((rst integers 0) pretend REC).firstElt;
  mydelay(fs:()->%): % == per [NonNullStream, fs pretend %];
  mygenerate(f: ()->S): % == {
          fs(): % == concat(f(), st mygenerate f) pretend %;
          mydelay fs;
  }
  gen(f: S -> S, s: S): % == {
          fs(): % == {ss := f s; concat(ss, st gen(f, ss)) pretend %};
          mydelay fs;
  }
  mygenerate(f: S->S, s: S): % == concat(s, st gen(f, s)) pretend %
}

MyStreamPackage(S: Type): with {
  mygenerate: (() -> S) -> Stream S;
  mygenerate: (S -> S,S) -> Stream S;
} == add {
  mygenerate(f: ()->S): Stream S == {
    (mygenerate(f)$MyStream(S)) pretend Stream(S);
  }
  mygenerate(f: S->S, s: S): Stream S == {
    (mygenerate(f, s)$MyStream(S)) pretend Stream(S);
  }
}


TestStream: with {
  zerostream:()->Stream Integer;
} == add {
  zerostream():Stream Integer == {
    import from Integer, MyStreamPackage(Integer);
    mygenerate(():Integer +-> address@hidden);
  }
  onestream():Stream Integer == {
    import from Integer, MyStreamPackage(Integer);
    mygenerate(():Integer +-> address@hidden);
  }
}
---END aaa.as





reply via email to

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