[plt-scheme] praise to PLT

From: jos.koot at tiscali.nl (jos.koot at tiscali.nl)
Date: Tue May 16 21:02:46 EDT 2006

<<<< 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

<<<< 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, 
> >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)])

* 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 
                  http://www.barzilay.org/                 Maze is 

Posted on the users mailing list.