[plt-scheme] Lazy evaluation and tail calls

From: Matthias Felleisen (matthias at ccs.neu.edu)
Date: Mon Feb 9 08:42:48 EST 2009

On Feb 9, 2009, at 4:38 AM, James Coglan wrote:

> 2009/2/9 Matthias Felleisen <matthias at ccs.neu.edu>
> On Feb 8, 2009, at 7:53 PM, James Coglan wrote:
>>  I've since moved onto implementing continuations, and I had  
>> enough trouble getting my head around the applicative order  
>> version that I think trying to implement continuations for normal  
>> order would make my head explode...
> James, just for the record from a semanticist: the terms  
> 'applicative order' and 'normal order' make NO SENSE whatsoever in  
> the world of PLs. Period. -- Matthias
> Could you elaborate? These are terms I picked up learning Scheme  
> from SICP but have also seen any number of confusing descriptions  
> of various calling semantics.

Normal order and applicative order are failed attempts to explain the  
nature of call-by-name programming languages and call-by-value  
programming languages as models of the lambda calculus. Each  
describes a so-called _reduction strategy_, which is an algorithm  
that picks the position of next redex BETA that should be reduced. By  
1972, it was clear that instead you want different kind of calculi  
for different calling conventions and evaluation strategies (to the  
first outermost lambda, not inside).  That is, you always reduce at  
the leftmost-outermost point in a program but you use either BETA- 
NAME or BETA-VALUE. Non-PL people were confused (and still are)  
because BETA-NAME looks like BETA but nearly 40 years later, everyone  
should figure this out. SICP was written when the majority of people  
were still confused. -- Matthias

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.racket-lang.org/users/archive/attachments/20090209/e0735b0c/attachment.html>

Posted on the users mailing list.