[plt-scheme] praise to PLT

Hi, 
<<<< is me.

----Oorspronkelijk bericht----
Van: eli at barzilay.org
Datum : 17/05/2006 2:15
Aan: "jos.koot at tiscali.nl"<jos.koot at tiscali.nl>
Onderw: Re: [plt-scheme] praise to PLT

On May 16, jos.koot at tiscali.nl wrote:
>  Did you talk to Mattias Felleisen or the other Mattias I frequently
> see on the PLT list too? Anyway, cary my regards to Matthias
> Felleisen when you may happen to meet him, please.

Yes, I talked to Matthias Felleisen -- I'm working with him in
Northeastern.  This morning I talked to him about this problem and
mentioned your name -- and he went and pulled out the Little Lisper
and showed me the back...

<<<< Well, what can I say? It is nice to be remembered. Please give 
him my regards, for he tought me a lot. I owe him and Danial Friedman a 
lot. I hope you dont mind me ccing this message to the PLT list so 
Matthias receives it too. Best wishes to you, Matthias.!

> When I saw the problem of order of lazy evaluation for the first
> time I asked myself whether or not it could be desirable to have
> such a tricky evaluator as I made. I did post a request on the PLT
> list forpointers to info about this subject, but got no response.

Well, sometimes things are heavy enough that you wouldn't get any
responses...

<<<< I understand that. No hard feelings.

> >  (define a 1)
> >  (define b 2)
> >  (set! b (cons 2 a))
> >  (set! a (cons 1 b))
> >  b
> >
> >Under the real-lazy version, the result is an infinite list of
> >alternating 2-1-2-1..., under the new set! version that I have, 
this
> >will be (2 . 1), and with your version my guess is that you'll get
> >(2 1 . 2).
> 
>  That's right. May be I ought to adapt one of my lazy interpreters
> for the current PLT version I use (PLT-FULL-301.14\)

We've talked about it more, and got to a conclusion that:

* The fully-lazy set!, the one that returns an infinite list for the
  above expressions, is one that is not too useful because you can
  always reorganize the code and use a letrec instead.  For example,
  the above is done with

    (letrec ([b (cons 1 a)]
             [a (cons 1 b)])
      b)

* The set! that I have now is more useful since it cannot be mimicked
  with a letrec as the above.

* The set! that you have, is similar to a few attempts at making it
  possible to evaluate a letrec in a strict language in an order of
  evaluation that will always succeed -- for example, in

    (letrec ([a (add1 b)]
             [b (* 5 d)]
             [c (sub1 a)]
             [d (/ 8 2)])
      ...)

  you want to evaluate d first, then b, a, and c.  Perhaps you can
  apply your method there...

<<<< That is a nice challenge. I'll try. Buit now it is past midnight 
here in Spain, where I live. (yes my account is a dutch one. I am a 
duch person living in Spain for about half a year now) So the next 12 
hours or so I will off line. But I will be very pleased to contact you 
again tomorrow or at the last the day after tomorrow.

Kind regards to Eli and Matthias, Jos Koot
-- 
          ((lambda (x) (x x)) (lambda (x) (x x)))          Eli 
Barzilay:
                  http://www.barzilay.org/                 Maze is 
Life!