Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 16 Nov 88 14:27:55 EST
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA05980@BLOOM-BEACON.MIT.EDU>; Wed, 16 Nov 88 14:26:08 EST
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 16 Nov 88 18:59:15 GMT
From: jeschke@iuvax.cs.indiana.edu  (Eric Jeschke)
Organization: Indiana University CSCI, Bloomington
Subject: Re: Scheme Digest #9
Message-Id: <15089@iuvax.cs.indiana.edu>
References: <8811160652.AA19419@theory.LCS.MIT.EDU>, <8811161428.AA13775@toucan.LCS.MIT.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


Mark VandeWettering writes:
|
| I think (and my thesis work is evolving into this kind of
| argument) that Y is overlooked for trivial reasons.  Partial
| evaluation and smarter code generation could make an SK based
| compiler generate code which is equal in quality to that produced
| by supercombinator based compilation.
|
Bard Bloom points out the space problem:
|I thought that the reason for using supercombinators rather than S and K is
|space.  
| <stuff deleted>
|
|  In any event, the SK compiler has a lot of work to do before it can match
|even a fairly stupid supercombinator compiler, simply because it can be
|forced to produce incredibly long code.  My guess, and I gather the guess of
|many people who actually work on this, is that SK would lose.  I would be
|very interested in some proof that this guess was wrong.
|

    More specifically, the problem is not with the larger code image
produced by SK compilation (because memory size is typically not a
problem these days), but rather that the granularity of the
instructions is too fine.  Supercombinators have much coarser
granularity, and get more work done per `instruction'.

This is reminicent of the RISC vs. CISC arguments that are raging over
in comp.arch.  I think Mark is making a case that with a high enough
instruction bandwidth and more intelligent code
generation/optimization, SK reduction performance could approach
current supercombinator reduction performance.

I doubt it, especially with SK, but you might with a larger set of
fixed combinators, such as Turner's expanded set.  I think you will
also need hardware support to really approach/improve on
supercombinator performance.  Some fixed combinator machines have been
built, but I haven't heard of any that are close performance-wise to
the current breed of supercombinator implementations.

  In short, a number of people have looked into this already, and most
are opting in favor of supercombinators.  With the performance of
general-purpose architectures climbing steadily, the trend seems to be
moving away from building special purpose machines.  For the
forseeable future, fixed combinator implementations will be slower,
given the advanced state of supercombinator compilation techniques.

-- 
Eric   ------
  jeschke@iuvax.cs.indiana.edu		...{pyramid, rutgers}!iuvax!jeschke
------

Received: from toucan.LCS.MIT.EDU (TCP 2206400272) by MC.LCS.MIT.EDU 16 Nov 88 09:28:45 EST
Received: by toucan.LCS.MIT.EDU 
	id AA13775; Wed, 16 Nov 88 09:28:18 EST
Date: Wed, 16 Nov 88 09:28:18 EST
From: bard@theory.lcs.mit.edu
Message-Id: <8811161428.AA13775@toucan.LCS.MIT.EDU>
To: Scheme@MC.lcs.mit.edu
In-Reply-To: Automatic Scheme Digestifier's message of 16 NOV 88  00:11:14 EST <8811160652.AA19419@theory.LCS.MIT.EDU>
Subject: Scheme Digest #9 


> 
> Mark VandeWettering writes:
>
> I think (and my thesis work is evolving into this kind of
> argument) that Y is overlooked for trivial reasons.  Partial
> evaluation and smarter code generation could make an SK based
> compiler generate code which is equal in quality to that produced
> by supercombinator based compilation.

I thought that the reason for using supercombinators rather than S and K is
space.  Ordinary \-calculus expressions can be translated into SK-combinatory
expressions, but the combinatory version is exponentially longer than the SK
term.  Some sets of supercombinators give polynomial-length expansions; I
think some give linear expansions.
  Now, code size isn't usually much of a problem, in that we don't
usually care whether a program is 50K or 250K.  The difference between 50K
and  2^50K is significant.  I don't know if the translation has a decent
expected case or not.  

  In any event, the SK compiler has a lot of work to do before it can match
even a fairly stupid supercombinator compiler, simply because it can be
forced to produce incredibly long code.  My guess, and I gather the guess of
many people who actually work on this, is that SK would lose.  I would be
very interested in some proof that this guess was wrong.

-- Bard Bloom

Received: from kleph.ai.mit.edu (TCP 2212600254) by MC.LCS.MIT.EDU 16 Nov 88 05:07:56 EST
Received: by kleph.ai.mit.edu (5.59/1.5)
	id AA13091; Wed, 16 Nov 88 05:12:11 EST
Date: Wed, 16 Nov 88 05:12:11 EST
From: cph@kleph.ai.mit.edu (Chris Hanson)
Message-Id: <8811161012.AA13091@kleph.ai.mit.edu>
To: Scheme@mc.lcs.mit.edu
In-Reply-To: Automatic Scheme Digestifier's message of 16 NOV 88  00:11:14 EST
Subject: Scheme Digest #8, Efficiency of Y
Reply-To: cph@zurich.ai.mit.edu

   Date: Tue, 15 Nov 88 10:26:46 EST
   From: kranz@wheaties.ai.mit.edu (David Kranz)

   Edward Wang is correct that the time in the example is dominated by
   bignum arithmetic.  I changed the * in factorial to + and got the
   following result in T3.1:

I tried a similar experiment in MIT Scheme (using + instead of *,
except a smaller loop to account for smaller fixnums), with the
following results:

    (factorial-loop 100) -> 1.03 msec

    (factorial-rec 100) -> 1.0 msec

    (factorial-lfp 100) -> 2.74 msec

Bill Rozas has expended no small effort in the MIT Scheme compiler to
make the Y combinator produce good results, and these timings are
evidence of that.  Still not perfect, but I believe Bill claims that
he can make the output code identical given a bit more work.

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 15 Nov 88 22:12:46 EST
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA18920@BLOOM-BEACON.MIT.EDU>; Tue, 15 Nov 88 22:01:46 EST
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 16 Nov 88 01:26:34 GMT
From: zodiac!DUCHAMPS.ADS.COM!rar@ames.arpa  (Bob Riemenschneider)
Subject: To Y or not to Y?  That is the question!  (Was: Efficiency of Y)
Message-Id: <8811160126.AA02163@duchamps.ads.com>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

Apparently, I should have been more explicit about the point I was making
in my previous posting.  Let me take another shot at it.

When Joe Weening wrote that use of the Y combinator for definition of 
recursive functions "would be fairly inefficient", I took him to be making
a general claim that you shouldn't use Y.  (Maybe I was wrong about this.)
I decided to test this claim.  Like most Lisp programmers, the first recursive
function test I try when testing is factorial.  It turned out that bignum 
arithmetic performance dominated everything else in the computation.  
*That was the point I was trying to make.*  My conclusion was not that you 
can *always* use Y without performance penalty--I knew that was false based 
on the second experiment I tried (see below)--but that you can *sometimes* 
use Y without *significant* performance penalty.  For all I knew a priori,
(factorial-lfp N) would run [[N]] times as slowly as (factorial-rec N), so 
this seemed significant enough to post.  Given that Y makes for more
elegant code than letrec--it's nice for the same reasons that lambda is nice--
the experiment shows that there may be a role for Y in your Scheme toolkit.  
In particular, if you need to compute factorials (or Fibonacci numbers, or 
...), but you don't need to compute them often, feel free to use Y.  My 
statement that 

	I found performance of the three to be identical, leading 
	me to believe that, given current Scheme compiler technology, 
	there's no reason to avoid using Y.

would have been less misleading if I'd added "completely" at the end.  
But, based on the performance figures I've seen and my second experiment, 
I'm now willing to go a bit farther.

Here's the second experiment.

   1.	Build a moderately complicated test list.

		(define l '())

		(do ((i 0 (+ i 1))) 
		    ((> i 15) i) 
                    (set l (cons l l)))

	(15 was determined by trial and error using T on a Sun--I wanted
	the largest value that wouldn't cause a garbage collection during
	a test run.)

   2.	Define three procedures for computing the function flatten, one
	iterative:

		(define flatten-trec-aux 
		   (lambda (l l-aux l-acc)
		      (cond ((null? l-aux) 
		                (cond ((null? l) l-acc)
		                      ((atom? l) (cons l l-acc))
		                      (else      
                                         (flatten-trec-aux 
		                            (car l) (cdr l) l-acc))))
		            ((atom? l-aux) 
                                (flatten-trec-aux l '() (cons l-aux l-acc))) 
		            (else          
		                (flatten-trec-aux 
		                   (cons l (car l-aux)) 
		                   (cdr l-aux) 
		                   l-acc)))))
		
		(define flatten-trec 
		   (lambda (l) 
		      (flatten-trec-aux l '() '())))


	one recursive:

		(define flatten-rec 
		   (lambda (l)
                      (cond ((null? l) '())
                            ((atom? l) (list l))
                            (else      (append 
                                          (flatten-rec (car l)) 
                                          (flatten-rec (cdr l)))))))

	and one using Y:

		(define flatten-lfp 
		   (Y (lambda (f)
                         (lambda (l)
                            (cond ((null? l) '())
                                  ((atom? l) (list l))
                                  (else      (append 
                                                (f (car l)) 
                                                (f (cdr l)))))))))

   3.	Compute flatten of l using each of the three procedures, garbage 
	collecting between computations.

No bignums here, just basic list manipulation.  I found flatten-lfp to be
about half as fast as flatten-rec, and flatten-rec to be about half as fast
as flatten-trec.  (And I have a funny feeling flatten-trec-aux wasn't the
best choice of an auxiliary function for flatten-trec; it's just the first
thing that occurred to me.)

I'm still not sure I have a good handle on the efficiency of Y.  But, based 
on my two experiments and the other figures I've seen posted, I'll stick my
neck out and claim: 

	Y is *efficient enough* that using, say, 

		((Y (lambda (f) ... f ...)) --- )

	in place of 

		     (letrec ((f ...f...))
		         (f ---))

	where ...f... won't give you tail-recursion, is *never* bad
	programming; if efficiency is enough of a concern that Y
	shouldn't be used, you should come up with an iterative
	algorithm.
	
(Unlike my original claim, this *ought* to create some controversy!)


							-- rar

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 15 Nov 88 18:57:27 EST
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA15820@BLOOM-BEACON.MIT.EDU>; Tue, 15 Nov 88 18:54:52 EST
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 15 Nov 88 23:03:24 GMT
From: uoregon!markv@beaver.cs.washington.edu  (Mark VandeWettering)
Organization: University of Oregon, Computer Science, Eugene OR
Subject: The Paradoxical Combinator -- Y (LONG)
Message-Id: <3168@uoregon.uoregon.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

Newsgroups: comp.lang.scheme
Subject: The Paradoxical Combinator -- Y
Expires:
References:
Sender:
Reply-To: markv@drizzle.UUCP (Mark VandeWettering)
Followup-To:
Distribution: world
Organization: University of Oregon, Computer Science, Eugene OR
Keywords:


Alternatively entitled:
	"Y?  Why Not?" :-)

The discussion that has been going on in regards to the Y combinator as
the basic operation in implementing recursive functions are interesting.
The practical tests that people have made have shown that the Y
combinator is orders of magnitude slower for implementing recursion than
directly compiling it.

This is true for Scheme.  I hold that for an interesting set of
languages, (lazy languages) that this result will not necessarily hold.

The problem with Y isn't its complexity, it is the fact that it is an
inherently lazy operation.  Any implementation in Scheme is clouded by
the fact that Scheme is an applicative order evaluator, while Y prefers
to be evaluated in normal order.

	
(define Y
  (lambda (g)	
    ((lambda (h) (g (lambda (x) ((h h) x))))
     (lambda (h) (g (lambda (x) ((h h) x)))))))

(define fact
  (lambda (f)
    (lambda (n)
      (if (= n 1)
	  1
	(* n (f (- n 1)))))))


Evaluating (Y fact) 2 results in the following operations in
Scheme:

The argument is (trivially) evaluated, and returns two.
(Y fact) must be evaluated.  What is it?  Y and fact each evaluate
to closures.  When applied, Y binds g to fact, and executes the
body.

The body is an application of a closure to another closure.  The
operator binds h to the operand, and executes its body which....

Evaluates (g (lambda (x) ((h h) x))).  The operand is a closure,
which gets built and then returns.  g evaluates to fact.  We
substitute the closure (lambda (x) ((h h) x)) in for the function
f in the definition of fact, giving...

(lambda (n)
  (if (= n 1) 
      1
    (* n ((lambda (x) ((h h) x)) (- n 1)))))

Which we return as the value of (Y fact).  When we apply this to 2, we get

(* 2 ((lambda (x) ((h h) x)) 1))

We then have to evaluate
((lambda (x) ((h h) x)) 1)

or 
((h h) 1)

But remembering that h was (lambda (h) (g (lambda (x) ((h h) x)))), 
we have 

(((lambda (h) (g (lambda (x) ((h h) x))))
  (lambda (h) (g (lambda (x) ((h h) x)))))
 1) ....

So, we rebind h to be the right stuff, and evaluate the body, which is

((g (lambda (x) ((h h) x))) 1)

Which by the definition of g (still == fact) is just 1.

(* 2 1) = 2.

########################################################################

Summary:  If you didn't follow this, performing this evaluation
was cumbersome at best.  As far as compiler or interpreter is
concerned, the high cost of evaluating this function is related
to two different aspects:

It is necessary to create "suspended" values.  These suspended
values are represented as closures, which are in general heap
allocated and expensive.

For every level of recursion, new closures are created (h gets
rebound above).  While this could probably be optimized out by a
smart compiler, it does seem like the representation of suspended
evaluation by lambdas is inefficient.

	   
########################################################################

You can try to figure out how all this works.  It is complicated, I
believe I understand it.  The point in the derivation above is that in
Scheme, to understand how the implementation of Y works, you have to
fall back on the evaluation mechanism of Scheme.  Suspended values must
be represented as closures.  It is the creation of these closures that
cause the Scheme implementation to be slow.

If one wishes to abandon Scheme (or at least applicative order
evaluators of Scheme) one can typically do much better.  My thesis work
is in graph reduction, and trying to understand better the issues having
to do with implementation.

In graph reduction, all data items (evaluated and unevaluated) have the
same representation: as graphs in the heap.  We choose to evaluate using
an outermost, leftmost strategy.  This allows the natural definition of
(Y h) = (h (Y h)) to be used.  An application node of the form:

			    @
			   / \
			  /   \
			 Y     h

can be constructed in the obvious way:
                            @
			   / \
			  /   \
			 h     @
			      /	\
			     /   \
			    Y     h

costing one heap allocation per level of recursion, which is
certainly cheaper than the multiple allocations of scheme
closures above.  More efficiently, we might choose to implement
it using a "knot tying" version:


			      /\
                             / 	\
			    @	 |
			   / \ 	/
			  /   \/
			 h

Which also works quite well.  Y has been eliminated, and will
cause no more reductions.  

The basic idea is somehow that recursion in functional languages
is analogous to cycles in the graph in a graph reduction engine.
Therefore, the Y combinator is a specific "textual" indicator of
the graph.

The G-machine (excellently described in Peyton Jones' book "The
Implementation of Functional Programming Languages") also
described the Y combinator as being efficient.  He chose letrecs
as being a primitive in the extended lambda calculus.  His
methodology behind compiling these recursive definitions was
basically to compile fixed code which directly built these cyclic
structures, rather than having them built at runtime.

I think (and my thesis work is evolving into this kind of
argument) that Y is overlooked for trivial reasons.  Partial
evaluation and smarter code generation could make an SK based
compiler generate code which is equal in quality to that produced
by supercombinator based compilation.


This is too long already, ciao for now.

Mark VandeWettering

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 15 Nov 88 15:57:08 EST
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA12407@BLOOM-BEACON.MIT.EDU>; Tue, 15 Nov 88 15:51:22 EST
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 15 Nov 88 18:29:44 GMT
From: dweissfe@afit-ab.arpa  (David P. Weissfeld)
Organization: Air Force Institute of Technology; WPAFB, OH
Subject: Scheme available via ftp?
Message-Id: <722@afit-ab.arpa>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

We are using scheme here on a number of our mainframes.
We are looking for the latest version of scheme.
The question is, is the latest version of scheme available
via ftp and if so, what is the ftp address?

Thanks....

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 15 Nov 88 12:12:06 EST
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA08682@BLOOM-BEACON.MIT.EDU>; Tue, 15 Nov 88 12:08:30 EST
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 15 Nov 88 16:51:50 GMT
From: mike@arizona.edu  (Mike Coffin)
Organization: U of Arizona CS Dept, Tucson
Subject: Re: Efficiency of Y (Was: Limitation with lambda)
Message-Id: <7857@megaron.arizona.edu>
References: <8811142229.AA01756@duchamps.ads.com>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

From article <8811142229.AA01756@duchamps.ads.com> (Bob Riemenschneider):
> Here's a simple experiment you can perform using your favorite Scheme.
  [three definitions of a factorial function omitted: one
   iterative, one recursive, and one using the Y combinator]
>    3.	Compute the factorial of a number using each of the three procedures,
> 	timing the results.  Make the number large enough so that you can get
> 	a reasonably accurate timing.  (I found 100 worked well for MacScheme,
> 	and 1000 for T on my Sun 3.)
> 
> I found performance of the three to be identical, leading me to believe that,
> given current Scheme compiler technology, there's no reason to avoid using Y.

I tried this using T.  When I performed the experiment as stated, I
indeed got identical times for the three definitions:
> (time (factorial-loop 100))
  virtual time = 0.36 seconds
> (time (factorial-rec 100))
  virtual time = 0.36 seconds
> (time (factorial-lfp 100))
  virtual time = 0.36 seconds


However, when I instead calculated the factorial of a small number many
times, there was a huge difference --- more than a factor of 10 ---
between the times: 

> (time (factorial-loop 10) 1000)
  virtual time = 0.18 seconds
> (time (factorial-rec 10) 1000)
  virtual time = 0.2 seconds
> (time (factorial-lfp 10) 1000)
  virtual time = 2.58 seconds

I think the benchmark, as originally stated, mostly measures the speed
of longnum arithmetic, and not the efficiency of the various contol
constructs.

-- 
Mike Coffin				mike@arizona.edu
Univ. of Ariz. Dept. of Comp. Sci.	{allegra,cmcl2}!arizona!mike
Tucson, AZ  85721			(602)621-2858

Received: from shredded-wheat.ai.mit.edu (TCP 20015022041) by MC.LCS.MIT.EDU 15 Nov 88 10:26:32 EST
Received: by shredded-wheat.ai.mit.edu; Tue, 15 Nov 88 10:26:46 EST
Date: Tue, 15 Nov 88 10:26:46 EST
From: kranz@wheaties.ai.mit.edu (David Kranz)
Message-Id: <8811151526.AA00789@shredded-wheat.ai.mit.edu>
To: Scheme@mc.lcs.mit.edu
In-Reply-To: Automatic Scheme Digestifier's message of 15 NOV 88  00:10:57 EST <8811150617.AA29565@wheaties.ai.mit.edu>
Subject: Scheme Digest #8 , Efficiency of Y

Edward Wang is correct that the time in the example is dominated by bignum
arithmetic.  I changed the * in factorial to + and got the following result in
T3.1:

(factorial-loop 20000) -> .1 sec

(factorial-rec 20000) -> .22 sec

(factorial-lfp 20000) -> 1.32 sec

With *:

(factorial-rec 100) -> .42 sec

(factorial-rec 1000) -> 57.78 sec

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 14 Nov 88 23:26:56 EST
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA25957@BLOOM-BEACON.MIT.EDU>; Mon, 14 Nov 88 23:25:32 EST
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 15 Nov 88 02:55:51 GMT
From: edward@ucbarpa.berkeley.edu  (Edward Wang)
Organization: University of California, Berkeley
Subject: Re: Efficiency of Y (Was: Limitation with lambda)
Message-Id: <26809@ucbvax.BERKELEY.EDU>
References: <8811142229.AA01756@duchamps.ads.com>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

In article <8811142229.AA01756@duchamps.ads.com> you write:
>   3.	Compute the factorial of a number using each of the three procedures,
>	timing the results.  Make the number large enough so that you can get
>	a reasonably accurate timing.  (I found 100 worked well for MacScheme,
>	and 1000 for T on my Sun 3.)
>
>I found performance of the three to be identical, leading me to believe that,
>given current Scheme compiler technology, there's no reason to avoid using Y.

Wouldn't the time be dominated by bignum arithmetic?
A better test would be to go through the iterations without
actually computing the factorial.

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 14 Nov 88 19:11:59 EST
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA21863@BLOOM-BEACON.MIT.EDU>; Mon, 14 Nov 88 19:03:26 EST
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 14 Nov 88 22:29:54 GMT
From: zodiac!DUCHAMPS.ADS.COM!rar@ames.arpa  (Bob Riemenschneider)
Subject: Efficiency of Y (Was: Limitation with lambda)
Message-Id: <8811142229.AA01756@duchamps.ads.com>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

[Sorry this is so late; I'm behind on my correspondence.]

Awhile ago, Joe Weening asserted (in response to an article posted by 
Jonathan Dubman) that use of the Y combinator for definition of recursive 
functions "would be fairly inefficient".  Mark VandeWettering then questioned
this assertion in his response to Joe, saying that looking at the 
efficiency of Y was an element of his thesis work.

Here's a simple experiment you can perform using your favorite Scheme.

   1.	Define a fixed point combinator:

	   (define Y 
	      (lambda (g) 
	         ((lambda (h) (g (lambda (x) ((h h) x))))
		     (lambda (h) (g (lambda (x) ((h h) x)))))))


   2. 	Define three procedures for computing the factorial function, 
	one iterative:

		(define factorial-loop
		   (lambda (n)
		      (do ((i 1 (+ i 1))
		           (a 1 (* i a)))
		          ((> i n) a))))
             
	one recursive (but not tail-recursive, so introduction of an 
	accumulator is left up to the compiler):

		(define factorial-rec
		   (lambda (n)
		      (if (= n 0) 
		         1
		         (* n (factorial-rec (- n 1))))))

	and one using the combinator:

		(define factorial-lfp 
		    (Y (lambda (f)
		          (lambda (n) 
		             (if (= n 0) 
		                1 
		                (* n (f (- n 1))))))))

   3.	Compute the factorial of a number using each of the three procedures,
	timing the results.  Make the number large enough so that you can get
	a reasonably accurate timing.  (I found 100 worked well for MacScheme,
	and 1000 for T on my Sun 3.)

I found performance of the three to be identical, leading me to believe that,
given current Scheme compiler technology, there's no reason to avoid using Y.



							-- rar

Received: from cs.utah.edu (TCP 20033402025) by MC.LCS.MIT.EDU 11 Nov 88 19:01:12 EST
Received: from car.utah.edu by cs.utah.edu (5.59/utah-2.1-cs)
	id AA13214; Fri, 11 Nov 88 16:58:41 MST
Received: by car.utah.edu (5.59/utah-2.0-leaf)
	id AA00568; Fri, 11 Nov 88 16:58:19 MST
Date: Fri, 11 Nov 88 16:58:19 MST
From: carr%car@cs.utah.edu (Harold Carr)
Message-Id: <8811112358.AA00568@car.utah.edu>
To: scheme@mc.lcs.mit.edu
Subject: self duplicating code summary

Quite a number a people asked for copies of the self duplicating code
I requested.  Here it is in one swell foop.  If you have any self
duplicating code that is duplicated ( ;-) ) here I would like to see it.

Thanks for all the replies,
Harold

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

Summary-line:  7-Oct             stoller@morgan  #Re: self reproducing code
Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA25166; Fri, 7 Oct 88 13:56:07 MDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA06715; Fri, 7 Oct 88 13:56:00 MDT
Received: by morgan.utah.edu (5.54/utah-2.0-leaf)
	id AA04067; Fri, 7 Oct 88 13:55:56 MDT
Date: Fri, 7 Oct 88 13:55:56 MDT
From: stoller@morgan (Leigh B. Stoller)
Message-Id: <8810071955.AA04067@morgan.utah.edu>
To: carr@car
Cc: pass@cs, scheme@mc.lcs.mit.edu, shebs@apple.apple.com,
        mohammad%hpcllz2@sde.hp.com
In-Reply-To: Harold Carr's message of Fri, 7 Oct 88 13:30:30 MDT <8810071930.AA25143@car.utah.edu>
Subject: Re: self reproducing code

*** EOOH ***
Date: Fri, 7 Oct 88 13:55:56 MDT
From: stoller@morgan (Leigh B. Stoller)
To: carr@car
Cc: pass@cs, scheme@mc.lcs.mit.edu, shebs@apple.apple.com,
        mohammad%hpcllz2@sde.hp.com
In-Reply-To: Harold Carr's message of Fri, 7 Oct 88 13:30:30 MDT <8810071930.AA25143@car.utah.edu>
Subject: Re: self reproducing code

Date: Tue, 19 May 87 15:39:42 MDT
From: carr@orion.utah.edu (Harold Carr)
To: kessler@orion.utah.edu
Subject: Fun stuff
Cc: pass@orion.utah.edu

Here's one everyone has already probably seen, but I forgot about it.
What does the following evaluate to?


((lambda (x) (list x (list (quote quote) x)))
 (quote (lambda (x) (list x (list (quote quote) x)))))


Great problem for Bob's Lisp class.

Harold

Summary-line:  7-Oct         Alan@AI.AI.MIT.EDU  #self reproducing code
Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA25184; Fri, 7 Oct 88 14:11:43 MDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA07523; Fri, 7 Oct 88 14:10:26 MDT
Received: from QUESTION-AUTHORITY.AI.MIT.EDU by REAGAN.AI.MIT.EDU via CHAOS with CHAOS-MAIL id 141482; Fri 7-Oct-88 16:00:51 EDT
Date: Fri, 7 Oct 88 16:00 EDT
From: Alan Bawden <Alan@AI.AI.MIT.EDU>
Subject: self reproducing code
To: carr%car@cs
Cc: pass@cs, scheme@MC.LCS.MIT.EDU, shebs@apple.apple.com,
        mohammad%hpcllz2@sde.hp.com
In-Reply-To: <8810071930.AA25143@car.utah.edu>
Message-Id: <19881007200040.6.ALAN@QUESTION-AUTHORITY.AI.MIT.EDU>

*** EOOH ***
Date: Fri, 7 Oct 88 16:00 EDT
From: Alan Bawden <Alan@AI.AI.MIT.EDU>
Subject: self reproducing code
To: carr%car@cs
Cc: pass@cs, scheme@MC.LCS.MIT.EDU, shebs@apple.apple.com,
        mohammad%hpcllz2@sde.hp.com
In-Reply-To: <8810071930.AA25143@car.utah.edu>

    Date: Fri, 7 Oct 88 13:30:30 MDT
    From: carr%car@cs.utah.edu (Harold Carr)
    A couple of years ago I found an example of self reproducing code....
    in Common Lisp, ...

My favorite example:

  (let ((let '`(let ((let ',let))
		 ,let)))
    `(let ((let ',let))
       ,let))

I believe that Mike McMahon is the author of this variant.  It is
unfortunate that this isn't standard Scheme because of the use of 
LET as an identifier...

Summary-line:  7-Oct               sandra@defun  #Re: self reproducing code
Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA25206; Fri, 7 Oct 88 14:24:23 MDT
Received: by defun.utah.edu (5.54/utah-2.0-leaf)
	id AA16358; Fri, 7 Oct 88 14:24:21 MDT
From: sandra@defun (Sandra J Loosemore)
Message-Id: <8810072024.AA16358@defun.utah.edu>
Date: Fri, 7 Oct 88 14:24:20 MDT
Subject: Re: self reproducing code
To: carr@car (Harold Carr)
In-Reply-To: carr@car (Harold Carr), Fri, 7 Oct 88 14:19:26 MDT

*** EOOH ***
From: sandra@defun (Sandra J Loosemore)
Date: Fri, 7 Oct 88 14:24:20 MDT
Subject: Re: self reproducing code
To: carr@car (Harold Carr)
In-Reply-To: carr@car (Harold Carr), Fri, 7 Oct 88 14:19:26 MDT

Here's my contribution for the simplest piece of self-reproducing code:
    T

-Sandra  :-)
-------

Summary-line:  7-Oct        jar@void.ai.mit.edu  #self reproducing code
Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA25234; Fri, 7 Oct 88 14:40:52 MDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA08444; Fri, 7 Oct 88 14:40:40 MDT
Received: by void.ai.mit.edu (5.59/1.5)
	id AA03464; Fri, 7 Oct 88 16:43:05 EDT
Date: Fri, 7 Oct 88 16:43:05 EDT
From: jar@void.ai.mit.edu (Jonathan Rees)
Message-Id: <8810072043.AA03464@void.ai.mit.edu>
To: carr%car@cs
In-Reply-To: Harold Carr's message of Fri, 7 Oct 88 13:30:30 MDT <8810071930.AA25143@car.utah.edu>
Subject: self reproducing code
Reply-To: jar@zurich.ai.mit.edu

*** EOOH ***
Date: Fri, 7 Oct 88 16:43:05 EDT
From: jar@void.ai.mit.edu (Jonathan Rees)
To: carr%car@cs
In-Reply-To: Harold Carr's message of Fri, 7 Oct 88 13:30:30 MDT <8810071930.AA25143@car.utah.edu>
Subject: self reproducing code
Reply-To: jar@zurich.ai.mit.edu

This works in both common lisp and scheme.  You can expand the
backquotes into calls to list etc. if you like but I think this is
easier to understand.  (As evidenced by the fact that I could generate
it from memory.)

(let ((x '`(let ((x ',x)) ,x)))
  `(let ((x ',x)) ,x))

Summary-line:  7-Oct    michaelf@decwrl.dec.com  #Re: self reproducing code 
Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA25246; Fri, 7 Oct 88 14:45:29 MDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA08608; Fri, 7 Oct 88 14:45:19 MDT
Received: from saturn.pa.dec.com by decwrl.dec.com (5.54.5/4.7.34)
	id AA08422; Fri, 7 Oct 88 13:44:06 PDT
Received: from localhost by saturn.pa.dec.com (5.54.5/4.7.34)
	id AA09432; Fri, 7 Oct 88 13:44:16 PDT
Message-Id: <8810072044.AA09432@saturn.pa.dec.com>
To: carr%car@cs (Harold Carr)
Subject: Re: self reproducing code 
In-Reply-To: Your message of Fri, 07 Oct 88 13:30:30 -0600.
             <8810071930.AA25143@car.utah.edu> 
Date: Fri, 07 Oct 88 13:44:14 -0700
From: Michael A. Fetterman <michaelf@decwrl.dec.com>

*** EOOH ***
To: carr%car@cs (Harold Carr)
Subject: Re: self reproducing code 
In-Reply-To: Your message of Fri, 07 Oct 88 13:30:30 -0600.
             <8810071930.AA25143@car.utah.edu> 
Date: Fri, 07 Oct 88 13:44:14 -0700
From: Michael A. Fetterman <michaelf@decwrl.dec.com>

The traditional piece of code to do this is a very famous piece of lambda
calculus:

	((lambda (x) (x x)) (lambda (x) (x x)))

[Where the above is written in tradition lisp notation rather than in
lambda calculus notation].

The lambda calculus is very much like lisp or scheme, as you can tell.  To
translate this to scheme, you get:

((lambda (x) (list x `',x)) '(lambda (x) (list x `',x)))

where I'm using quasi-quote from scheme r3rs.

If you don't have quasi-quote in your scheme, try:

((lambda (x) (list x (list 'quote x))) '(lambda (x) (list x (list 'quote x))))

This same code should work fine in common lisp.

Summary-line:  7-Oct  stever@Riverside.SCRC.Sym  #self reproducing code
Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA25276; Fri, 7 Oct 88 15:39:05 MDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA10784; Fri, 7 Oct 88 15:38:51 MDT
Received: from HALEAKALA.S4CC.Symbolics.COM by IVORY.S4CC.Symbolics.COM via CHAOS with CHAOS-MAIL id 194006; Fri 7-Oct-88 17:04:11 EDT
Date: Fri, 7 Oct 88 17:04 EDT
From: stever@Riverside.SCRC.Symbolics.COM
Sender: Zippy@QUABBIN.SCRC.Symbolics.COM
Subject: self reproducing code
To: Harold Carr <carr%car@cs>
Cc: pass@cs, scheme@mc.lcs.mit.edu, shebs@apple.apple.com,
        mohammad%hpcllz2@sde.hp.com
In-Reply-To: <8810071930.AA25143@car.utah.edu>
Message-Id: <19881007210401.2.LISP-MACHINE@HALEAKALA.S4CC.Symbolics.COM>

*** EOOH ***
Date: Fri, 7 Oct 88 17:04 EDT
From: stever@Riverside.SCRC.Symbolics.COM
Sender: Zippy@QUABBIN.SCRC.Symbolics.COM
Subject: self reproducing code
To: Harold Carr <carr%car@cs>
Cc: pass@cs, scheme@mc.lcs.mit.edu, shebs@apple.apple.com,
        mohammad%hpcllz2@sde.hp.com
In-Reply-To: <8810071930.AA25143@car.utah.edu>

    Date: Fri, 7 Oct 88 13:30:30 MDT
    From: carr%car@cs.utah.edu (Harold Carr)

    It was an anonymous lambda application which, when evaluated in Common
    Lisp, would return the exact same for, which could then be evaluated
    again, always returning the same anonymous application.

((LAMBDA (TEMPLATE)
   (SETF (SECOND (SECOND TEMPLATE)) (COPY-TREE TEMPLATE))
   TEMPLATE)
 '((LAMBDA (TEMPLATE)
     (SETF (SECOND (SECOND TEMPLATE)) (COPY-TREE TEMPLATE))
     TEMPLATE)
   (QUOTE *PLACEHOLDER*)))

This will work.  I'm pretty sure there's a more elegant way to do it.
If anyone send you one, I'd appreciate a copy.

Thanks,

Stephen

Summary-line:  7-Oct        U09052@UICVM.BITNET  #
Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA25286; Fri, 7 Oct 88 15:55:29 MDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA11334; Fri, 7 Oct 88 15:54:39 MDT
Message-Id: <8810072154.AA11334@cs.utah.edu>
Received: from UICVM.BITNET by CC.UTAH.EDU; Fri, 7 Oct 88 15:55 MDT
Received: by UICVM (Mailer X1.25) id 3599; Fri, 07 Oct 88 16:51:39 CDT
Date: 7 October 1988 16:50:27 CDT
From: U09052@UICVM.BITNET
To: CARR%CAR@cs

*** EOOH ***
Date: 7 October 1988 16:50:27 CDT
From: U09052@UICVM.BITNET
To: CARR%CAR@cs

I am sending you by "snail-mail" an article I published in Creative
Computing in 1980 on "Self-reproducing programs".  It contains (at the end)
the Lisp code you are interested in.


Summary-line:  7-Oct    bard@theory.lcs.mit.edu  #self reproducing code
Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA25345; Fri, 7 Oct 88 17:05:33 MDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA13458; Fri, 7 Oct 88 17:05:18 MDT
Received: by toucan.LCS.MIT.EDU 
	id AA01684; Fri, 7 Oct 88 19:04:46 EDT
Date: Fri, 7 Oct 88 19:04:46 EDT
From: bard@theory.lcs.mit.edu
Message-Id: <8810072304.AA01684@toucan.LCS.MIT.EDU>
To: carr%car@cs
In-Reply-To: Harold Carr's message of Fri, 7 Oct 88 14:19:26 MDT <8810072019.AA25193@car.utah.edu>
Subject: self reproducing code

*** EOOH ***
Date: Fri, 7 Oct 88 19:04:46 EDT
From: bard@theory.lcs.mit.edu
To: carr%car@cs
In-Reply-To: Harold Carr's message of Fri, 7 Oct 88 14:19:26 MDT <8810072019.AA25193@car.utah.edu>
Subject: self reproducing code


My favorite is the PDP-11 machine code:

  MOV --(PC), (R0)++

which copies itself throughout the machine's memory.

But it ain't lisp.


Summary-line:  7-Oct    will@fog.cs.uoregon.edu  #Re: self reproducing code
Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA25363; Fri, 7 Oct 88 17:22:58 MDT
Received: from mist.math.uoregon.edu by cs.utah.edu (5.54/utah-2.0-cs)
	id AA14301; Fri, 7 Oct 88 17:22:51 MDT
Received: from fog.cs.uoregon.edu by mist.math.uoregon.edu; Fri, 7 Oct 88 16:18:46 PDT
Received: by fog.cs.uoregon.edu; Fri, 7 Oct 88 16:18:41 PDT
Date: Fri, 7 Oct 88 16:18:41 PDT
From: William Clinger <will@fog.cs.uoregon.edu>
Message-Id: <8810072318.AA25772@fog.cs.uoregon.edu>
To: carr%car@CS
Subject: Re: self reproducing code
In-Reply-To: <8810071930.AA25143@car.utah.edu>
Organization: University of Oregon, Computer Science, Eugene OR
Cc: 

*** EOOH ***
Date: Fri, 7 Oct 88 16:18:41 PDT
From: William Clinger <will@fog.cs.uoregon.edu>
To: carr%car@CS
Subject: Re: self reproducing code
In-Reply-To: <8810071930.AA25143@car.utah.edu>
Organization: University of Oregon, Computer Science, Eugene OR
Cc: 

In Scheme the code you are looking for might be something like

((lambda (x)
   (list x (list 'quote x)))
 '(lambda (x)
    (list x (list 'quote x))))

You can't write something like ((lambda (lambda) ... because
lambda is a reserved word in Scheme (although some implementations
remove this restriction).  On the other hand, I don't know why you'd
want to write it that way; "x" is shorter than "lambda".

A shorter self-reproducing expression is:

    0

Peace, Will

Summary-line:  8-Oct           FWHITE@G.BBN.COM  #Re: self reproducing code
Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA25791; Sat, 8 Oct 88 11:58:01 MDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA28938; Sat, 8 Oct 88 11:57:47 MDT
Date: 8 Oct 1988 13:56-EDT
Sender: FWHITE@G.BBN.COM
Subject: Re: self reproducing code
From: FWHITE@G.BBN.COM
To: carr%car@CS
Cc: fwhite@BBN.COM
Message-Id: <[G.BBN.COM] 8-Oct-88 13:56:28.FWHITE>
In-Reply-To: <19881007200040.6.ALAN@QUESTION-AUTHORITY.AI.MIT.EDU>

*** EOOH ***
Date: 8 Oct 1988 13:56-EDT
Sender: FWHITE@G.BBN.COM
Subject: Re: self reproducing code
From: FWHITE@G.BBN.COM
To: carr%car@CS
Cc: fwhite@BBN.COM
In-Reply-To: <19881007200040.6.ALAN@QUESTION-AUTHORITY.AI.MIT.EDU>

Or if cheating is allowed, how about (in Common Lisp):

      #1='#1#

Summary-line:  8-Oct  iku.dk!danvy@uunet.UU.NET  #Re: self reproducing code
Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA25849; Sat, 8 Oct 88 16:15:13 MDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA02854; Sat, 8 Oct 88 16:15:05 MDT
Received: from uunet.UU.NET (TCP 30003106601) by MC.LCS.MIT.EDU  8 Oct 88 17:54:32 EDT
Received: from mcvax.UUCP by uunet.UU.NET (5.59/1.14) with UUCP 
	id AA22266; Sat, 8 Oct 88 17:53:02 EDT
Received: by mcvax.cwi.nl; Sat, 8 Oct 88 22:23:48 +0100 (MET)
Received: from diku.dk
	by dkuug.dk (3.2/smail2.5/ease)
	id AA07492; Sat, 8 Oct 88 17:15:36 +0100
Received: by diku.dk (5.51/smail2.5/ease)
	id AA14951; Sat, 8 Oct 88 17:15:22 +0100
Date:  Sat, 8 Oct 88 17:15:22 +0100
From: mcvax!diku.dk!danvy@uunet.UU.NET (Olivier Danvy)
Message-Id:  <8810081615.AA14951@diku.dk>
To: Alan@ai.ai.mit.edu, carr%car@cs
Subject: Re: self reproducing code
Cc: carr%car@cs, mohammad%hpcllz2@sde.hp.com, pass@cs, scheme@mc.lcs.mit.edu,
        shebs@apple.apple.com

*** EOOH ***
Date:  Sat, 8 Oct 88 17:15:22 +0100
From: mcvax!diku.dk!danvy@uunet.UU.NET (Olivier Danvy)
To: Alan@ai.ai.mit.edu, carr%car@cs
Subject: Re: self reproducing code
Cc: carr%car@cs, mohammad%hpcllz2@sde.hp.com, pass@cs, scheme@mc.lcs.mit.edu,
        shebs@apple.apple.com

Chez Scheme Version 2.0.3 Copyright (c) 1987 R. Kent Dybvig

> ()
()
> 

	This one is pretty small :-)
	It is illegal according to the r3rs's BNF for Scheme, though.

				Olivier


Summary-line:  8-Oct  KMP@STONY-BROOK.SCRC.Symb  #Re: self reproducing code
Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA25910; Sat, 8 Oct 88 20:53:40 MDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA10632; Sat, 8 Oct 88 20:53:18 MDT
Received: from BOBOLINK.SCRC.Symbolics.COM by STONY-BROOK.SCRC.Symbolics.COM via CHAOS with CHAOS-MAIL id 473424; Sat 8-Oct-88 22:51:52 EDT
Date: Sat, 8 Oct 88 22:51 EDT
From: Kent M Pitman <KMP@STONY-BROOK.SCRC.Symbolics.COM>
Subject: Re: self reproducing code
To: mcvax!diku.dk!danvy@uunet.UU.NET
Cc: Alan@ai.ai.mit.edu, carr%car@cs, mohammad%hpcllz2@sde.hp.com, pass@cs,
        scheme@mc.lcs.mit.edu, shebs@apple.apple.com
In-Reply-To: <8810081615.AA14951@diku.dk>
Message-Id: <881008225128.4.KMP@BOBOLINK.SCRC.Symbolics.COM>

*** EOOH ***
Date: Sat, 8 Oct 88 22:51 EDT
From: Kent M Pitman <KMP@STONY-BROOK.SCRC.Symbolics.COM>
Subject: Re: self reproducing code
To: mcvax!diku.dk!danvy@uunet.UU.NET
Cc: Alan@ai.ai.mit.edu, carr%car@cs, mohammad%hpcllz2@sde.hp.com, pass@cs,
        scheme@mc.lcs.mit.edu, shebs@apple.apple.com
In-Reply-To: <8810081615.AA14951@diku.dk>

() by itself is certainly cute, but I don't think it counts.
It's not -constructing- a program, it's just -returning- one.
All self-evaluating forms have the same property, after all.
{{1, 2, 3, ...}, {#t, #f}, ...}

Another borderline case, that comes up in Common Lisp, is:
 #1='#1#
But depending on your model of what QUOTE does, that's just
self-evaluating, too, and doesn't count either. Btw, don't
try to look at the result without setting *print-circle* or
*print-level* appropriately.

Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA26669; Mon, 10 Oct 88 07:38:31 MDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA19565; Mon, 10 Oct 88 07:37:56 MDT
Received: by ATHENA.CS.YALE.EDU; Mon, 10 Oct 88 09:33:38 EDT
Date: Mon, 10 Oct 88 09:33:38 EDT
From: Ashwin Ram <ram-ashwin@YALE.ARPA>
Message-Id: <8810101333.AA05276@ATHENA.CS.YALE.EDU>
Received: by yale-ring (node-abc3/ABC3) 
          via WIMP-MAIL (Version 1.3/1.5) ; Mon Oct 10 09:24:25
To: carr%car@CS (Harold Carr)
Subject: Re: self reproducing code
Newsgroups: comp.lang.scheme
In-Reply-To: <8810071930.AA25143@car.utah.edu>
Organization: Computer Science, Yale University, New Haven, CT 06520-2158
Reply-To: Ram-Ashwin@YALE.ARPA (Ashwin Ram)

*** EOOH ***
Date: Mon, 10 Oct 88 09:33:38 EDT
From: Ashwin Ram <ram-ashwin@YALE.ARPA>
To: carr%car@CS (Harold Carr)
Subject: Re: self reproducing code
Newsgroups: comp.lang.scheme
In-Reply-To: <8810071930.AA25143@car.utah.edu>
Organization: Computer Science, Yale University, New Haven, CT 06520-2158
Reply-To: Ram-Ashwin@YALE.ARPA (Ashwin Ram)

If you get any responses, could you please forward them to me?

Thanks.

-- Ashwin.

ARPA:    Ram-Ashwin@cs.yale.edu
UUCP:    {decvax,ucbvax,harvard,cmcl2,...}!yale!Ram-Ashwin
BITNET:  Ram@yalecs




Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA26949; Mon, 10 Oct 88 13:22:34 MDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA05433; Mon, 10 Oct 88 13:22:17 MDT
Received: from IBM.COM (TCP 30001235007) by MC.LCS.MIT.EDU 10 Oct 88 09:24:42 EDT
Date: 10 Oct 88 09:06:52 EDT
From: Cyril Alberga <ALBERGA@ibm.com>
To: scheme@mc.lcs.mit.edu
Message-Id: <101088.090653.alberga@ibm.com>
Subject: Self replicating code

*** EOOH ***
Date: 10 Oct 88 09:06:52 EDT
From: Cyril Alberga <ALBERGA@ibm.com>
To: scheme@mc.lcs.mit.edu
Subject: Self replicating code

Here is a brute-force expression which prints itself.  This was in LISP370,
circa 1978.

 (PRINT
   ( (LAMBDA (X Y)
       (SEQ
         (RPLACA (CDAR (CDDADR X)) (COPY Y))
         (RPLACA (CDADR (CADADR X)) (COPY Y))
         (EXIT X) ) )
     (COPY
       "(PRINT
         ( (LAMBDA (X Y)
             (SEQ
               (RPLACA (CDAR (CDDADR X)) (COPY Y))
               (RPLACA (CDADR (CADADR X)) (COPY Y))
               (EXIT X) ) ) (COPY "NIL) "NIL ) ) )
     "(PRINT
       ( (LAMBDA (X Y)
           (SEQ
             (RPLACA (CDAR (CDDADR X)) (COPY Y))
             (RPLACA (CDADR (CADADR X)) (COPY Y))
             (EXIT X) ) ) (COPY "NIL) "NIL ) ) ) )


The uses of copy were to keep it from modifying itself.
Obviously, shared sub-structure could be used to shorten the
representation.

Cyril N. Alberga


Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA28201; Tue, 11 Oct 88 05:50:17 MDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA27168; Tue, 11 Oct 88 05:50:11 MDT
Message-Id: <8810111150.AA27168@cs.utah.edu>
Received: from MITVMA.MIT.EDU (TCP 2227000003) by MC.LCS.MIT.EDU 11 Oct 88 07:15:39 EDT
Received: from MITVMA.MIT.EDU by MITVMA.MIT.EDU (IBM VM SMTP R1.1) with BSMTP id 1995; Tue, 11 Oct 88 07:13:31 EDT
Received: from IRUCCIBM by MITVMA.MIT.EDU (Mailer X1.25) with BSMTP id 1994;
 Tue, 11 Oct 88 07:13:29 EDT
Received: from IRUCCVAX.UCC.IE by IRUCCIBM (Mailer X1.25) with BSMTP id 0193;
 Mon, 10 Oct 88 15:45:35 IST
Date: Mon, 10 Oct 88 15:48 GMT
From: "G.OULSNAM" <STCS8004%IRUCCVAX.UCC.IE@MITVMA.MIT.EDU>
Subject: self-replicating code
To: SCHEME@MC.LCS.MIT.EDU
X-Vms-To: SCHEME

*** EOOH ***
Date: Mon, 10 Oct 88 15:48 GMT
From: "G.OULSNAM" <STCS8004%IRUCCVAX.UCC.IE@MITVMA.MIT.EDU>
Subject: self-replicating code
To: SCHEME@MC.LCS.MIT.EDU
X-Vms-To: SCHEME

Various respondents  to the question  of self-replicating anonymous  lambda
expressions have given  us solutions, but no derivations.  I hope therefore
that the following contribution might be of interest.

If one  has a normal-order evaluator  in Scheme rather than  an applicative
order one then the simplest self-replicating lambda expression is

                  ((lambda (x) (x x)) (lambda (x) (x x)))

since the  argument expression is substituted  without being evaluated, but
loops forever with applicative order.

Any approach to generating self-replication in applicative order evaluators
must therefore include emulation of  normal-order evaluation. Consider as a
first attempt:
               (define f (lambda (x) (list 'f x)))

This doesn't quite work  because the x in the list will  be replaced by its
value.  So a better attempt is:

          (define f (lambda (x) (list 'f <reconstruction-of-x>)))

As a first step towards eliminating the  recursive use of f, it makes sense
to pass f an argument that will  evaluate to the lambda expression for f at
the 'f position, but will not itself (the argument that is) be evaluated to
f.  The insight for this comes by recognizing that ((lambda () <body>))
evaluates to <body>.  This suggests that f be recast to the form:

(define f (lambda (x) (list (x) <reconstruction-of-x>)))

and that  it be passed  the argument:  (lambda  () 'f). (This  is where the
normal-order evaluation is emulated.)

The reconstruction of x can now be accomplished to give for f:

         (define f (lambda (x) (list (x) (list 'lambda '() 'f))))

followed again by the elimination of 'f to yield:

(define f
   (lambda (x)
      (list (x)
            (list 'lambda '() (list 'quote (x))))))

It can be verified that:

> (f (lambda () 'f)
(f (lambda () 'f)
>

Elimination of  the define statement  is now straightforward,  to yield the
required anonymous self-replicating expression:

    ((lambda (x)
        (list (x)
              (list 'lambda '() (list 'quote (x)))))
     (lambda ()
        '(lambda (x)
            (list (x)
                  (list 'lambda '() (list 'quote (x)))))))

Any comments?

Gordon Oulsnam



Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA28267; Tue, 11 Oct 88 09:23:02 MDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA02848; Tue, 11 Oct 88 09:22:53 MDT
Received: from NSS.Cs.Ucl.AC.UK (TCP 20012204403) by MC.LCS.MIT.EDU 11 Oct 88 10:53:58 EDT
Received: from aiai.edinburgh.ac.uk by NSS.Cs.Ucl.AC.UK   via Janet with NIFTP
           id aa03181; 10 Oct 88 15:39 BST
Date: Mon, 10 Oct 88 15:39:36 BST
Message-Id: <10500.8810101439@subnode.aiai.ed.ac.uk>
From: Jeff Dalton <jeff%aiai.edinburgh.ac.uk@NSS.Cs.Ucl.AC.UK>
Subject: Re: self reproducing code
To: scheme@mc.lcs.mit.edu

*** EOOH ***
Date: Mon, 10 Oct 88 15:39:36 BST
From: Jeff Dalton <jeff%aiai.edinburgh.ac.uk@NSS.Cs.Ucl.AC.UK>
Subject: Re: self reproducing code
To: scheme@mc.lcs.mit.edu

Here's one I wrote a while ago using the fairly standard technique
of having some data that looks pretty much like the code that uses
the data to reconstruct the data and the code.

;;; Self-reproducing function

(defun v ()
  (let ((m '(subst m
		   '**
		   '(defun v () (let ((m '**)) **)))))
    (subst m
	   '**
	   '(defun v () (let ((m '**)) **)))))

-- Jeff


Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA29177; Tue, 11 Oct 88 17:51:07 MDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA21848; Tue, 11 Oct 88 17:50:54 MDT
Received: from EDDIE.MIT.EDU by MC.LCS.MIT.EDU via Chaosnet; 11 OCT 88  19:19:13 EDT
Received: by EDDIE.MIT.EDU with UUCP with smail2.5 with sendmail-5.45/4.7 id <AA20412@EDDIE.MIT.EDU>; Tue, 11 Oct 88 19:18:42 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA29975@BLOOM-BEACON.MIT.EDU>; Tue, 11 Oct 88 18:55:18 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 11 Oct 88 22:24:52 GMT
From: sun.soe!sun.soe.clarkson.edu!gary@tcgould.tn.cornell.edu  (Gary Levin)
Organization: Clarkson University
Subject: Re: self reproducing code
Message-Id: <GARY.88Oct11182452@milo.mcs.clarkson.edu>
References: <10500.8810101439@subnode.aiai.ed.ac.uk>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

*** EOOH ***
Date: 11 Oct 88 22:24:52 GMT
From: sun.soe!sun.soe.clarkson.edu!gary@tcgould.tn.cornell.edu  (Gary Levin)
Organization: Clarkson University
Subject: Re: self reproducing code
References: <10500.8810101439@subnode.aiai.ed.ac.uk>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

A non-trivial expression must be a list of at least 2 elements, so
let's guess that our solution looks like:

	( ____________  ___________ )

The first blank must be a lambda expression if we are to avoid the
necessity of defining a function outside of our solution.  (Which
would violate the self-reproducing aspect to some extent.)

	( (lambda (x) ________ ) ____________ )

The choice of the name ``x'' was arbitrary.  The choice of one
argument followed from the assumption of a two element list.  The body
of the lambda expression must return a two element list, if we are to
re-produce the original input.  There are different choices possible;
I'll choose 

	( (lambda (x) (list _____ _____ )) ___________ )

The argument might as well be quoted, otherwise we need to delve
deeper into the expression.  This then determines some of the second
argument to ``list''.

	( (lambda (x) (list _1_ (list (quote quote) _2_ ))) (quote _3_ ) )

Now comes the ``magic'' part.  Notice that whatever is written in _3_,
we can make the second element of our result match by replacing _2_ by x.

	( (lambda (x) (list _1_ (list (quote quote) x ))) (quote _3_ ) )
yields  ( value_of_1_                                     (quote _3_ ) )

We can now use ``x'' for _1_, which let's us determine the value_of_1_
by our choice of _3_.  The solution follows immediately.

	( (lambda (x) (list x (list (quote quote) x )))
          (quote (lambda (x) (list x (list (quote quote) x ))) ) )

The logic of the derivation makes this easy to remember/reconstruct.
--

-----
Gary Levin/Dept of Math & CS/Clarkson Univ/Potsdam, NY 13676/(315) 268-2384
BitNet: gary@clutx   Internet: gary@clutx.clarkson.edu


Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA29347; Wed, 12 Oct 88 02:08:04 MDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA28514; Wed, 12 Oct 88 02:07:56 MDT
Received: by kestrel.arpa (5.58/SMI-DDN)
	id AA16036; Wed, 12 Oct 88 01:07:26 PDT
Date: Wed, 12 Oct 88 01:07:26 PDT
From: gyro@kestrel.arpa (Scott B. Layson)
Message-Id: <8810120807.AA16036@kestrel.arpa>
To: carr%car@cs
Cc: scheme@mc.lcs.mit.edu
In-Reply-To: Harold Carr's message of Fri, 7 Oct 88 14:19:26 MDT <8810072019.AA25193@car.utah.edu>
Subject: self reproducing code

*** EOOH ***
Date: Wed, 12 Oct 88 01:07:26 PDT
From: gyro@kestrel.arpa (Scott B. Layson)
To: carr%car@cs
Cc: scheme@mc.lcs.mit.edu
In-Reply-To: Harold Carr's message of Fri, 7 Oct 88 14:19:26 MDT <8810072019.AA25193@car.utah.edu>
Subject: self reproducing code

Here's a fun variation: write a Lisp function which returns its own
defining form (that is, a form EQUAL to the one you typed in to define
the function in the first place).

My solution to follow.  No doubt there are many.

-- Scott

Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA29368; Wed, 12 Oct 88 03:37:21 MDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA29288; Wed, 12 Oct 88 03:37:11 MDT
Received: from kestrel.arpa (TCP 1200600040) by MC.LCS.MIT.EDU 12 Oct 88 04:08:34 EDT
Received: by kestrel.arpa (5.58/SMI-DDN)
	id AA16036; Wed, 12 Oct 88 01:07:26 PDT
Date: Wed, 12 Oct 88 01:07:26 PDT
From: gyro@kestrel.arpa (Scott B. Layson)
Message-Id: <8810120807.AA16036@kestrel.arpa>
To: carr%car@cs
Cc: scheme@mc.lcs.mit.edu
In-Reply-To: Harold Carr's message of Fri, 7 Oct 88 14:19:26 MDT <8810072019.AA25193@car.utah.edu>
Subject: self reproducing code

*** EOOH ***
Date: Wed, 12 Oct 88 01:07:26 PDT
From: gyro@kestrel.arpa (Scott B. Layson)
To: carr%car@cs
Cc: scheme@mc.lcs.mit.edu
In-Reply-To: Harold Carr's message of Fri, 7 Oct 88 14:19:26 MDT <8810072019.AA25193@car.utah.edu>
Subject: self reproducing code

Here's a fun variation: write a Lisp function which returns its own
defining form (that is, a form EQUAL to the one you typed in to define
the function in the first place).

My solution to follow.  No doubt there are many.

-- Scott


Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA29603; Wed, 12 Oct 88 10:39:41 MDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA07201; Wed, 12 Oct 88 10:39:25 MDT
Message-Id: <8810121639.AA07201@cs.utah.edu>
Received: from MITVMA.MIT.EDU (TCP 2227000003) by MC.LCS.MIT.EDU 12 Oct 88 12:11:03 EDT
Received: from MITVMA.MIT.EDU by MITVMA.MIT.EDU (IBM VM SMTP R1.1) with BSMTP id 9799; Wed, 12 Oct 88 12:07:43 EDT
Received: from IRUCCIBM by MITVMA.MIT.EDU (Mailer X1.25) with BSMTP id 9798;
 Wed, 12 Oct 88 12:06:34 EDT
Received: from IRUCCVAX.UCC.IE by IRUCCIBM (Mailer X1.25) with BSMTP id 1372;
 Wed, 12 Oct 88 16:34:38 IST
Date: Wed, 12 Oct 88 16:35 GMT
From: "G.OULSNAM" <STCS8004%IRUCCVAX.UCC.IE@MITVMA.MIT.EDU>
Subject: Self-reproducing code (correction)
To: SCHEME@MC.LCS.MIT.EDU
X-Vms-To: SCHEME

*** EOOH ***
Date: Wed, 12 Oct 88 16:35 GMT
From: "G.OULSNAM" <STCS8004%IRUCCVAX.UCC.IE@MITVMA.MIT.EDU>
Subject: Self-reproducing code (correction)
To: SCHEME@MC.LCS.MIT.EDU
X-Vms-To: SCHEME

My thanks  to John Gateley for  pointing out the erroneous  claim regarding
the normal order/applicative order evaluation of ((lambda (x) (x x) (lambda
(x) (x x)). I'm  sorry he chose not to examine the  rest of the derivation,
as  it did  not rely  on the  erroneous claim.  For the  record, what I now
consider I should have written was:

"Consider
                  ((lambda (x) (x x)) (lambda (x) (x x))).

With normal order  evaluation this reproduces itself, but  loops forever on
attempting  to  evaluate  the  result.  However,  in Scheme  the
argument  is evaluated  to an  internal procedure,  say #<procedure>, which
then  loops  forever  trying  to  evaluate  the  first  (x  x) in the above
expression, without reproducing the original form directly."

The remark  about Scheme applies to  TI Scheme (v2), and  can be checked by
depositing extra code to see what is being passed around. My point was, and
remains, that both normal order  and applicative order (by-value in Scheme)
cause the above  to loop, but for different  reasons. Normal order provided
the  idea for  self-reproducing code,  if  one  could first  find a  way to
emulate normal order evaluation, and then  find a way to stop evaluation of
the result.  The remainder of the article showed how.

Gordon Oulsnam.


Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA29691; Wed, 12 Oct 88 12:02:08 MDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA11572; Wed, 12 Oct 88 12:01:48 MDT
Received: from EDDIE.MIT.EDU by MC.LCS.MIT.EDU via Chaosnet; 12 OCT 88  12:36:11 EDT
Received: by EDDIE.MIT.EDU with UUCP with smail2.5 with sendmail-5.45/4.7 id <AA07031@EDDIE.MIT.EDU>; Wed, 12 Oct 88 12:35:42 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA19237@BLOOM-BEACON.MIT.EDU>; Wed, 12 Oct 88 12:09:38 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 10 Oct 88 22:58:15 GMT
From: dewey.soe.berkeley.edu!oster@ucbvax.berkeley.edu  (David Phillip Oster)
Organization: School of Education, UC-Berkeley
Subject: Re: Self-reproduction
Message-Id: <26381@ucbvax.BERKELEY.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

*** EOOH ***
Date: 10 Oct 88 22:58:15 GMT
From: dewey.soe.berkeley.edu!oster@ucbvax.berkeley.edu  (David Phillip Oster)
Organization: School of Education, UC-Berkeley
Subject: Re: Self-reproduction
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

A cute trick, not quite a self-reproducing program, but an interesting
example of a string that produces itself, is to take an arbitrary error
message, and hand it back to the interpreter as input. On many systems if
you repeat this 4-8 times, you reach a fixed point at which no further
change occurs. This is also fun with a C compiler.


Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA00414; Thu, 13 Oct 88 02:58:28 MDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA03251; Thu, 13 Oct 88 02:58:22 MDT
Received: from mcvax.UUCP by uunet.UU.NET (5.59/1.14) with UUCP 
	id AA25781; Thu, 13 Oct 88 04:58:07 EDT
Received: by mcvax.cwi.nl; Wed, 12 Oct 88 04:47:36 +0100 (MET)
Received: from ski.cs.vu.nl by botter.cs.vu.nl id aa02469; 11 Oct 88 18:57 MET
To: carr%car@cs
From: J A Biep Durieux <mcvax!cs.vu.nl!biep@uunet.UU.NET>
Subject: Re: self reproducing code
Newsgroups: comp.lang.scheme
In-Reply-To: <8810072019.AA25193@car.utah.edu>
References: <19881007200040.6.ALAN@QUESTION-AUTHORITY.AI.MIT.EDU>
Organization: VU Informatica, Amsterdam
Cc: 
Date: Tue, 11 Oct 88 18:58:01 MET
Sender: mcvax!cs.vu.nl!biep@uunet.UU.NET
Message-Id:  <8810111858.aa17014@ski.cs.vu.nl>

*** EOOH ***
To: carr%car@cs
From: J A Biep Durieux <mcvax!cs.vu.nl!biep@uunet.UU.NET>
Subject: Re: self reproducing code
Newsgroups: comp.lang.scheme
In-Reply-To: <8810072019.AA25193@car.utah.edu>
References: <19881007200040.6.ALAN@QUESTION-AUTHORITY.AI.MIT.EDU>
Organization: VU Informatica, Amsterdam
Cc: 
Date: Tue, 11 Oct 88 18:58:01 MET
Sender: mcvax!cs.vu.nl!biep@uunet.UU.NET

If you want trivial ones too, what about

		NIL

or, even shorter

		T

?
-- 
						Biep.  (biep@cs.vu.nl via mcvax)
	Never confound "power", "command" with "right",
	 especially not when it concerns our own body!

Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA00973; Thu, 13 Oct 88 14:40:38 MDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA19175; Thu, 13 Oct 88 14:40:25 MDT
Received: from aic.nrl.navy.mil (TCP 3200200010) by MC.LCS.MIT.EDU 12 Oct 88 13:45:38 EDT
Return-Path: <hoey@aic.nrl.navy.mil>
Received: Wed, 12 Oct 88 13:43:58 EDT by aic.nrl.navy.mil id AA19260
Date: Wed, 12 Oct 88 13:43:58 EDT
From: Dan Hoey <hoey@aic.nrl.navy.mil>
Message-Id: <8810121743.AA19260@aic.nrl.navy.mil>
To: scheme@mc.lcs.mit.edu
Subject: Automatic programming

*** EOOH ***
Return-Path: <hoey@aic.nrl.navy.mil>
Date: Wed, 12 Oct 88 13:43:58 EDT
From: Dan Hoey <hoey@aic.nrl.navy.mil>
To: scheme@mc.lcs.mit.edu
Subject: Automatic programming

My favorite version of the LAMBDA self-reproducer is

((LAMBDA (LAMBDA) `(,LAMBDA ',LAMBDA))
 '(LAMBDA (LAMBDA) `(,LAMBDA ',LAMBDA)))

though SCHEMErs will have to forgo the pun.  There is also

(format t "~A~:*~S)" "(format t \"~A~:*~S)\" ")

Dan


Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA01218; Fri, 14 Oct 88 02:08:47 MDT
Received: from MC.LCS.MIT.EDU by cs.utah.edu (5.59/utah-2.0-cs)
	id AA13301; Fri, 14 Oct 88 02:08:40 MDT
Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 14 Oct 88 03:44:02 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA07904@BLOOM-BEACON.MIT.EDU>; Thu, 13 Oct 88 23:46:04 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 12 Oct 88 09:58:03 GMT
From: mcvax!enea!kth!draken!Urd!newsuser@uunet.uu.net  (LTH network news server)
Organization: Dept. of Automatic Control, Lund Inst. of Technology, Sweden
Subject: Self-reproducing code
Message-Id: <1988Oct12.105804.3747@LTH.Se>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

*** EOOH ***
Date: 12 Oct 88 09:58:03 GMT
From: mcvax!enea!kth!draken!Urd!newsuser@uunet.uu.net  (LTH network news server)
Organization: Dept. of Automatic Control, Lund Inst. of Technology, Sweden
Subject: Self-reproducing code
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


Several examples of self-reproducing code has been given in this group
lately. While running a definite risc of reminding people of what may
be already generally known, I would like to submit the shortest solution
of all. And not only the shortest, it will work in almost any language!

The solution is:

The only problem with this solution, the empty program, is that someone
might argue that it is not a program at all. Still, I think it has a
certain elegance to it.

"Real Programmers aren't afraid of RISC architectures."


-- 
Jan Eric Larsson                      janeric@Control.LTH.Se      +46 46 108795
Department of Automatic Control
Lund Institute of Technology         "We watched the thermocouples dance to the
Box 118, S-221 00 LUND, Sweden        spirited tunes of a high frequency band."


Received: from cs.utah.edu by car.utah.edu (5.59/utah-2.0-leaf)
	id AA02703; Mon, 17 Oct 88 12:07:50 MDT
Received: from KESTREL.ARPA by cs.utah.edu (5.59/utah-2.0-cs)
	id AA03697; Mon, 17 Oct 88 12:07:01 MDT
Received: by kestrel.arpa (5.58/SMI-DDN)
	id AA14370; Mon, 17 Oct 88 07:50:21 PDT
Date: Mon, 17 Oct 88 07:50:21 PDT
From: gyro@kestrel.arpa (Scott B. Layson)
Message-Id: <8810171450.AA14370@kestrel.arpa>
To: carr%car@cs
Subject: Lisp function which returns its own defining form

*** EOOH ***
Date: Mon, 17 Oct 88 07:50:21 PDT
From: gyro@kestrel.arpa (Scott B. Layson)
To: carr%car@cs
Subject: Lisp function which returns its own defining form

In deference to the recent complaints, I'm not sending this to the
whole list, but I thought you'd like to see it, since I had promised
it:

(defun generate-self ()
  (let ((foo (quote (lambda (x)
                      (list (quote defun) (quote generate-self)
                            (list (quote let)
                                  (list (list (quote foo)
                                              (list (quote quote) x)))
                                  (quote (funcall foo foo))))))))
    (funcall foo foo)))

As you can see, it makes use of the somewhat archaic property retained
in Common Lisp that a list whose car is 'LAMBDA is a funcallable
object.  To do the same thing in Scheme requires an explicit call to
EVAL, which makes it a little plainer what's going on.

-- Scott

Received: from cs.utah.edu by car.utah.edu (5.59/utah-2.0-leaf)
	id AA03897; Wed, 19 Oct 88 05:20:38 MDT
Received: from uunet.UU.NET by cs.utah.edu (5.59/utah-2.0-cs)
	id AA09978; Wed, 19 Oct 88 05:20:29 MDT
Received: from mcvax.UUCP by uunet.UU.NET (5.59/1.14) with UUCP 
	id AA05951; Wed, 19 Oct 88 07:19:56 EDT
Received: by mcvax.cwi.nl; Mon, 17 Oct 88 14:28:41 +0100 (MET)
Received: by inria.inria.fr with Fnet-EUnet; Fri, 14 Oct 88 14:39:17 +0100 (MET)
Date: Fri, 14 Oct 88 12:00:25 -0100
From: mcvax!poly!queinnec@uunet.UU.NET (Queinnec Christian)
Message-Id: <8810141100.AA23995@poly.poly.fr>
To: carr%car@cs
Cc: scheme@mc.lcs.mit.edu
Subject: Self reproducing code

*** EOOH ***
Date: Fri, 14 Oct 88 12:00:25 -0100
From: mcvax!poly!queinnec@uunet.UU.NET (Queinnec Christian)
To: carr%car@cs
Cc: scheme@mc.lcs.mit.edu
Subject: Self reproducing code


I wrote these two solutions several years ago after seeing the original
problem in the McCarthy's paper "Lisp Micro-Manual, not the whole
truth" as a little exercice. Something like (as I remember)
           Find s such that (equal s (eval s)) 
which is self-reproducing code.

They are written in Le-Lisp and can be found as examples in its manual
after description of EQUAL.

((lambda (s) `(,(car s) ',s)) 
 '((lambda (s) `(,(car s) ',s))) )

and using old-style FLAMBDA (fexprs)

((flambda (s) `(,s ,s)) (flambda (s) `(,s ,s)))

which bears strong similarity to a certain lambda term.

-----------------------------------------------------------------------
New Address !!!             Christian Queinnec
    LIX     Laboratoire d'Informatique de l'\'Ecole Polytechnique
    Route de Saclay        91128 Palaiseau Cedex           France
    Internet: queinnec@poly.poly.fr          Earn: QUEINNEC at FRPOLY11
-----------------------------------------------------------------------

Received: from cs.utah.edu by car.utah.edu (5.59/utah-2.0-leaf)
	id AA07808; Tue, 25 Oct 88 17:04:02 MDT
Received: from MC.LCS.MIT.EDU by cs.utah.edu (5.59/utah-2.0-cs)
	id AA10378; Tue, 25 Oct 88 17:03:53 MDT
Received: from MITVMA.MIT.EDU (TCP 2227000003) by MC.LCS.MIT.EDU 24 Oct 88 14:56:59 EDT
Received: from MITVMA.MIT.EDU by MITVMA.MIT.EDU (IBM VM SMTP R1.1) with BSMTP id 3598; Mon, 24 Oct 88 09:37:18 EDT
Received: from DB0TUI6.BITNET (ZTUBTFAL) by MITVMA.MIT.EDU (Mailer X1.25) with
 BSMTP id 3597; Mon, 24 Oct 88 09:22:50 EDT
Received: by tub.UUCP; Mon, 24 Oct 88 13:38:39 +0200; AA06867
Received: by tub-tfs.uucp (4.0/SMI-3.0DEV3)
        id AA20497; Mon, 24 Oct 88 13:40:34 +0100
Date: Mon, 24 Oct 88 13:40:34 +0100
From: alti%tub-tfs.uucp%TUB.BITNET@MITVMA.MIT.EDU (Thorsten Altenkirch)
Message-Id: <8810241240.AA20497@tub-tfs.uucp>
To: tub!scheme%mc.lcs.mit.edu
Subject: Re: self-replicating-code, self-replicating-messages

*** EOOH ***
Date: Mon, 24 Oct 88 13:40:34 +0100
From: alti%tub-tfs.uucp%TUB.BITNET@MITVMA.MIT.EDU (Thorsten Altenkirch)
To: tub!scheme%mc.lcs.mit.edu
Subject: Re: self-replicating-code, self-replicating-messages

I find it more interesting to discuss things like self replicating
code than technical details of SCHEME Implementations. Perhaps I am
on the wrong mailing list. Is there one about functional-programming,
lambda-calculus, theory and application ???

The most solutions to the problem were quite tricky. The reason is
that the problem was ill defined. The most interesting contributioon
came from
"G.OULSNAM" <uunet!MITVMA.MIT.EDU!STCS8004%IRUCCVAX.UCC.IE@tub.UUCP>

                  ((lambda (x) (x x)) (lambda (x) (x x)))

The critic was that these expression has no normal form - even worse
it is an example for an so called non solvable term, which puts even
a lazy evaluator (which does only head reductions) into an infinite
loop.

But the point is, that every solution to the proble has no normal
form, because if :

x ---> x

(---> means reduces to), than you can go on reducing x...

More interesting is another question : Is there a function, which
returns itself for every argument ?

This problem can be solved more straightforward. You just need a
solution for the equation

f x = f , for every x.

This can be done with the fixed-point-combinator Y. The solution is

f = Y K

or in lambda notation :

f = lambda f . ( lambda x . f x x ) ( lambda x . f x x )
        (lambda x y . x)

The Y - Kombinator is a relative of letrec in scheme, so in scheme you
would write :

(define y-k (letrec ((h (lambda (x) h))) h))

It is also possible to define Y in terms of simple scheme expressions
without refering to letrec at all :

(define (yy y f x) ((f ((y y) f)) x))
(define y (yy yy))

So now you can just write :

(define (k x) (lambda (y) x))
(define y-k (y k))

Thorsten




Received: from cs.utah.edu by car.utah.edu (5.59/utah-2.0-leaf)
	id AA08172; Wed, 26 Oct 88 11:42:43 MDT
Received: from MC.LCS.MIT.EDU by cs.utah.edu (5.59/utah-2.0-cs)
	id AA03858; Wed, 26 Oct 88 11:42:26 MDT
Received: from MITVMA.MIT.EDU (TCP 2227000003) by MC.LCS.MIT.EDU 26 Oct 88 13:16:05 EDT
Received: from MITVMA.MIT.EDU by MITVMA.MIT.EDU (IBM VM SMTP R1.1) with BSMTP id 1800; Wed, 26 Oct 88 13:13:48 EDT
Received: from DB0TUI6.BITNET (ZTUBTFAL) by MITVMA.MIT.EDU (Mailer X1.25) with
 BSMTP id 1798; Wed, 26 Oct 88 13:13:04 EDT
Received: by tub.UUCP; Wed, 26 Oct 88 18:11:43 +0200; AA12857
Received: by tub-tfs.uucp (4.0/SMI-3.0DEV3)
        id AA05234; Wed, 26 Oct 88 18:13:44 +0100
Date: Wed, 26 Oct 88 18:13:44 +0100
From: alti%tub-tfs.uucp%TUB.BITNET@MITVMA.MIT.EDU (Thorsten Altenkirch)
Message-Id: <8810261713.AA05234@tub-tfs.uucp>
To: tub!uunet!rice.edu!dorai
Cc: tub!scheme%mc.lcs.mit.edu
In-Reply-To: Dorai Sitaram's message of Tue, 25 Oct 88 22:46:50 CDT
 <8810260346.AA26475@titan.rice.edu>
Subject: self-replicating-code, self-replicating-messages

*** EOOH ***
Date: Wed, 26 Oct 88 18:13:44 +0100
From: alti%tub-tfs.uucp%TUB.BITNET@MITVMA.MIT.EDU (Thorsten Altenkirch)
To: tub!uunet!rice.edu!dorai
Cc: tub!scheme%mc.lcs.mit.edu
In-Reply-To: Dorai Sitaram's message of Tue, 25 Oct 88 22:46:50 CDT
 <8810260346.AA26475@titan.rice.edu>
Subject: self-replicating-code, self-replicating-messages


> I think you are confusing the phenomenon of reduction to normal form
> in the lambda calculus with the process of evaluation which takes
> place in the case of a Scheme program yielding a value.

Sorry, I haven't been clear here. There is a strong analogy between
reduction and evaluation, but it's not the same thing. For me the
lambda calculus serves as a principial model of functional languages,
which can be used to understand certain aspects of these languages
without the overload of accidential properties of implementations. So
evaluation relates to reduction and values to normal forms.

There are functional languages which use reduction as evaluation.
MIRANDA is such an example, it uses a reduction machine for lazy
evaluation. See the book of Simon L. Peyton Jones ("The implementation
of functional programming languages", Prentice/Hall, 1988) for how
lazy functional languages are implemented by reduction machines.

> E.g., the result of the program (list 'list 8) is (list 8), *not* (8),
> which would have been the case in the case of continual reduction.

I think the relation between normal forms and values is, that normal
forms somehow denotate values. The point that lisp values can be lisp
programs again is - as important it is for programming practice - only
confusing here.

> >(define (yy y f x) ((f ((y y) f)) x))
> >(define y (yy yy))

> You doubtless imply currying, viz.,
> (define yy (lambda (y) (lambda (f) (lambda (x) ((f ((y y) f)) x)))))

I am sorry, somehow I copied the old version of the function into my
buffer. I imply nothing it's just a mistake - your version is the
correct one.

Thank you for your comments . . .

Until now nobody has answered my other question (mailing list for
theoretical questions of functional programming).

Thorsten


Received: from cs.utah.edu by car.utah.edu (5.59/utah-2.0-leaf)
	id AA08882; Thu, 27 Oct 88 15:33:32 MDT
Received: from MC.LCS.MIT.EDU by cs.utah.edu (5.59/utah-2.0-cs)
	id AB05648; Thu, 27 Oct 88 15:33:14 MDT
Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 27 Oct 88 16:16:53 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA22826@BLOOM-BEACON.MIT.EDU>; Thu, 27 Oct 88 05:47:31 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 26 Oct 88 00:58:21 GMT
From: pasteur!agate!saturn!kjell@ames.arpa  (Kjell Post)
Organization: University of California, Santa Cruz
Subject: Re: self-replicating-code, self-replicating-messages
Message-Id: <5259@saturn.ucsc.edu>
References: <8810241240.AA20497@tub-tfs.uucp>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

*** EOOH ***
Date: 26 Oct 88 00:58:21 GMT
From: pasteur!agate!saturn!kjell@ames.arpa  (Kjell Post)
Organization: University of California, Santa Cruz
Subject: Re: self-replicating-code, self-replicating-messages
References: <8810241240.AA20497@tub-tfs.uucp>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

In article <8810241240.AA20497@tub-tfs.uucp> alti@tub-tfs.UUCP (Thorsten Altenkirch) writes:
>I find it more interesting to discuss things like self replicating
>code than technical details of SCHEME Implementations. Perhaps I am
>on the wrong mailing list. Is there one about functional-programming,
>lambda-calculus, theory and application ???

I haven't seen one but I certainly wouldn't mind.
By the way, why isn't there a comp.lang.ml?

	fun Y f x = f (Y f) x;
	fun fac x = Y (fn f => fn x => if x = 0 then 1 else x*f(x-1)) x;


-------

That's it....

Received: from ti.com (TCP 1201600056) by MC.LCS.MIT.EDU 10 Nov 88 12:22:24 EST
Received: by ti.com id AA20203; Thu, 10 Nov 88 11:22:46 CST
Received: from mips by tilde id AA12141; Thu, 10 Nov 88 11:01:58 CST
Received: by mips id AA13609; Thu, 10 Nov 88 11:01:41 CST
Date: Thu, 10 Nov 88 11:01:41 CST
From: Clyde Camp <camp@mips.csc.ti.com>
Message-Id: <8811101701.AA13609@mips>
To: scheme@MC.LCS.MIT.EDU
Subject: PC Scheme Error Handlers Address Correction
Reply-To: camp@ti-csl.csc.ti.com


Oops!!  The correct Zipcode is 75265. The other one will get to me as
well, but may take a little longer.

- Clyde

Received: from ti.com (TCP 1201600056) by MC.LCS.MIT.EDU  9 Nov 88 17:33:51 EST
Received: by ti.com id AA14157; Wed, 9 Nov 88 16:34:16 CST
Received: from mips by tilde id AA22703; Wed, 9 Nov 88 16:24:45 CST
Received: by mips id AA03675; Wed, 9 Nov 88 16:24:27 CST
Date: Wed, 9 Nov 88 16:24:27 CST
From: Clyde Camp <camp@mips.csc.ti.com>
Message-Id: <8811092224.AA03675@mips>
To: scheme@MC.LCS.MIT.EDU
Cc: camp@mips.csc.ti.com
In-Reply-To: <6278@ti-csl.CSNET>
Subject: PC Scheme Error Handlers
Reply-To: camp@ti-csl.csc.ti.com



With respect to the PC Scheme error handlers, send me a pair of
initialized DOS disks and a self-addressed STAMPED return mailer and
I'll send you a set of utilities which do what you want.  There is no
charge for this.  Also included are several menu shells,
window-handlers, on-line help utilities, keyboard utilities and
mechanisms for "pushing" new top-level loops as well as a new
top-level command-line editor with EMACS-like editing and UNIX-like
history (e.g. scroll through previous entries, edit the one you like
and submit it).

In the meantime, a very crude version of a user error handler can be
implemented as follows:

   (define foo (lambda (error-number irritant error-msg sys-error-handler)
      (... do your own thing ...)
      ))

   (set! *user-error-handler* foo)

This is covered (albeit briefly) in the section on breakpoints (pp3-6
thru 3-8) in the PC Scheme user's guide.  Make SURE your error handler
is bug free or you're in real trouble.

Clyde R. Camp
Texas Instruments, Incorporated
P.O. Box 655474  M/S 238
Dallas, TX   75266
(214)995-0407


Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU  8 Nov 88 16:54:04 EST
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA22493@BLOOM-BEACON.MIT.EDU>; Tue, 8 Nov 88 16:43:19 EST
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 8 Nov 88 20:30:45 GMT
From: uoregon!markv@beaver.cs.washington.edu  (Mark VandeWettering)
Organization: University of Oregon, Computer Science, Eugene OR
Subject: Wanted: extend-syntax for T
Message-Id: <3111@uoregon.uoregon.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


I am currently involved in hacking some T code as part of my thesis
work.  It dawns on me that Kohlbecker's "extend-syntax" macros would
simplify both the look and the coding of elements of this.

Problem:  I only have "extend-syntax" for MacScheme, and my brain
	isn't working very well right now.  If anyone has done the
	probably trivial modifications to make these work under 
	T, can you please send them to me?

Alternatively, you could give me a T macro which converts MacScheme
(macro ...) calls into T's (define-syntax ...) form.

Thanks once again..
Mark VandeWettering
---
markv@cs.uoregon.edu  \	Mark Terrence VandeWettering
University of Oregon   \  ..!tektronix!uoregon!markv	
Computer Science Dept.  \  			  	

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU  8 Nov 88 13:39:00 EST
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA19423@BLOOM-BEACON.MIT.EDU>; Tue, 8 Nov 88 13:28:10 EST
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 8 Nov 88 18:17:24 GMT
From: bbn.com!jgrace@bbn.com  (Joe Grace)
Subject: (Still) searching for latest XScheme
Message-Id: <32005@bbn.COM>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

A few weeks ago, I posted a request for XScheme.  Many others
requested copies from me via e-mail --- but the only tip I received
involved getting it from a bboard in Colorado (long distance calls to
a bboard.  I would prefer someone send me sources via e-mail. 

So, could someone who has sources (preferably, for both PC
and Mac) for XScheme, contact me?

I will then forward the sources to the others who are interested. 

Thanks,

= Joe =

Joe Grace
ARPA: jgrace@bbn.com
UUCP: {harvard,husc6,decvax,etc.}!bbn!jgrace

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU  4 Nov 88 04:37:35 EST
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA25320@BLOOM-BEACON.MIT.EDU>; Fri, 4 Nov 88 04:26:41 EST
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 3 Nov 88 16:18:58 GMT
From: mcvax!hp4nl!botter!star.cs.vu.nl!roelw%cs.vu.nl@uunet.uu.net
Organization: VU Informatica, Amsterdam
Subject: T manual
Message-Id: <1617@star.cs.vu.nl>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

Can anyone tell me how to obtain a copy of

J. Rees et al., "The T Manual"?

Thanx,

Roel Wieringa
Dept. of Math. and Comp. Science
Vrije Universiteit
De Boelelaan 1081
1081 HV Amsterdam
Holland

uucp: roelw@cs.vu.nl

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU  3 Nov 88 17:19:50 EST
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA12906@BLOOM-BEACON.MIT.EDU>; Thu, 3 Nov 88 17:07:35 EST
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 3 Nov 88 19:28:34 GMT
From: uoregon!will@beaver.cs.washington.edu  (William Clinger)
Organization: University of Oregon, Computer Science, Eugene OR
Subject: Declaring variables more than once
Message-Id: <3084@uoregon.uoregon.edu>
References: <41415@linus.UUCP>, <17416@shemp.CS.UCLA.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

In article <17416@shemp.CS.UCLA.EDU> pierce@cs.ucla.edu (Brad Pierce) writes:
>Also, is one allowed to declare the same identifier more than once in the same
>lambda closure in official Scheme?...((lambda (x x) x) 1 2) 

There's no prohibition in R3RS, but that's an oversight.  R4RS will say that
(lambda (x x) ...) is an error.  Implementations will still not be required
to detect the error.

>And is it officially legal to "define" something more than once at top level.

There is nothing that says you can't.  Many people think that a <program>
should not contain multiple top level definitions for the same variable,
but that an interactive programming environment must allow re-definitions
as a debugging feature.  This is my view.

Peace, William Clinger

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU  3 Nov 88 14:34:52 EST
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA10955@BLOOM-BEACON.MIT.EDU>; Thu, 3 Nov 88 14:26:30 EST
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 2 Nov 88 16:19:08 GMT
From: leverich@rand-unix.arpa  (Brian Leverich)
Organization: RAND Corp., Santa Monica, CA
Subject: TRAPPING ERRORS IN TI'S PC-SCHEME
Message-Id: <1768@randvax.UUCP>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


Deep in the bowels of a hunk of TI's PC-Scheme code, I'm running what
amounts to a read-eval-print loop of my own (where the user is using
the ROSS simulation language defined in Scheme, rather than Scheme itself).

What I'd like to do is trap all errors, _including errors that would
normally be trapped by Scheme_, and handle them in my own way.  Problem
is that any time Scheme sees a glitch it dumps the user into the Scheme
break package, and the user has to manually extricate himself/herself.

In LISP implementations of ROSS we've done some magic with catches and
throws to shelter the user from the tender mercies of the break package.
Is there some TI PC-Scheme magic, using continuations or whatever, that
would allow ROSS to evaluate a user-input expression, return the value of
the expression if it evaluated successfully, or return a flag _without
invoking the break package_ if the expression causes a Scheme error?

Tnx for advice...  -B
-- 
  "Simulate it in ROSS"
  Brian Leverich                       | U.S. Snail: 1700 Main St.
  ARPAnet:     leverich@rand-unix      |             Santa Monica, CA 90406
  UUCP/usenet: decvax!randvax!leverich | Ma Bell:    (213) 393-0411 X7769

Received: from REAGAN.AI.MIT.EDU (CHAOS 13065) by MC.LCS.MIT.EDU  2 Nov 88 15:47:32 EST
Received: from NULLSTELLENSATZ.AI.MIT.EDU by REAGAN.AI.MIT.EDU via CHAOS with CHAOS-MAIL id 147026; Wed 2-Nov-88 15:46:55 EST
Date: Wed, 2 Nov 88 15:47 EST
From: Scheme Requestee <SCHREQ@MC.LCS.MIT.EDU>
Subject: Digest test, ignore
To: scheme@MC.LCS.MIT.EDU
Message-ID: <"19881102204700.6.schreq@MC"@NULLSTELLENSATZ.AI.MIT.EDU>

This is a test of the automatic digester.  Please ignore it.

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 31 Oct 88 22:42:27 EST
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA28580@BLOOM-BEACON.MIT.EDU>; Mon, 31 Oct 88 22:27:00 EST
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 1 Nov 88 02:14:24 GMT
From: pierce@locus.ucla.edu  (Brad Pierce)
Organization: UCLA Computer Science Department
Subject: Re: Internal definitions as a combination of LETREC's and LET*'s.
Message-Id: <17416@shemp.CS.UCLA.EDU>
References: <41415@linus.UUCP>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

In article <41415@linus.UUCP> ramsdell@linus.UUCP (John D. Ramsdell) writes:
>Yet at top level, it is okay to define values in terms of other
>definitions.  An obvious way of making internal definitions behave
>more like top level definitions, is to specify the order in which the
>init bodies are evaluated.  I call this interpretation internal
>definitions as a combination of LETREC's and LET*'s; a definition
>becomes equivalent to the following combinations of LET's and SET!'s:
>
>(LET ()
>  (DEFINE <var-0> <init-0>)
>            ...
>  (DEFINE <var-n> <init-n>)
>  <body>)
>         ==>
>(LET ((<var-0> <undefined>)
>             ...
>      (<var-n> <undefined>))
>  (SET! <var-0> <init-0>)		; init's must be evaluated
>          ...				; in the order presented.
>  (SET! <var-n> <init-n>)
>  <body>)
>

Here's one possible problem, at least with the suggested expansion:


               (define x 5)

               (let ()
                 (define y x)
                 (define x 'any)
                 y)


Then wouldn't the result be unspecified, even though the intuitive
answer is 5? 

-- Brad Pierce


P.S. Something else I'm curious about...

Also, is one allowed to declare the same identifier more than once in the same
lambda closure in official Scheme? The Scheme I am currently using doesn't give
an error message when I try to do this:  ((lambda (x x) x) 1 2) 

And is it officially legal to "define" something more than once at top level.
The reason that I ask is that the expansion looks a little shaky in the case
that one would re"define" an identifier in such a clause. 

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 31 Oct 88 20:58:58 EST
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA27377@BLOOM-BEACON.MIT.EDU>; Mon, 31 Oct 88 20:44:37 EST
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 31 Oct 88 13:55:21 GMT
From: linus!ramsdell@gatech.edu  (John D. Ramsdell)
Organization: The MITRE Corp., Bedford, MA
Subject: Internal definitions as a combination of LETREC's and LET*'s.
Message-Id: <41415@linus.UUCP>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

I would like to shift the current topic of this news group to an issue
of Scheme language design: the meaning of internal definitions.  I
contrast two interpretations of internal definitions:

	[1] internal definitions as LETREC's, and
	[2] internal definitions as a combination of LETREC's and LET*'s.

R3RS describes internal definitions in Section 5.2.2.  Some Scheme
implementations permit definitions to occur at the beginning of the
syntactic entity <body>, and are simply a syntactic variation of
LETREC.  In my opinion, they are an important variation as they reduce
the number of paratheses and make programs more readable.

Let me remind readers of the definition of LETREC of Section 7.3.  It
is equivalent to the following combinations of LET's and SET!'s:

(LETREC ((<var-0> <init-0>)
              ...
         (<var-n> <init-n>))
  <body>)
         ==>
(LET ((<var-0> <undefined>)
           ...
      (<var-n> <undefined>))
  (LET ((<temp-0> <init-0>)
              ...
        (<temp-n> <init-n>))
    (SET! <var-0> <init-0>)
            ...
    (SET! <var-n> <init-n>)
    <body>))

The second LET is there to ensure the property that the init
expressions are evaluated in an arbitrary order.  That is, no init
expression can depend of the value of any other one.  Thus the
following is incorrect.

(LAMBDA (X)
  (DEFINE A 4)
  (DEFINE B (* A A))
  (+ A (* X B)))

Yet at top level, it is okay to define values in terms of other
definitions.  An obvious way of making internal definitions behave
more like top level definitions, is to specify the order in which the
init bodies are evaluated.  I call this interpretation internal
definitions as a combination of LETREC's and LET*'s; a definition
becomes equivalent to the following combinations of LET's and SET!'s:

(LET ()
  (DEFINE <var-0> <init-0>)
            ...
  (DEFINE <var-n> <init-n>)
  <body>)
         ==>
(LET ((<var-0> <undefined>)
             ...
      (<var-n> <undefined>))
  (SET! <var-0> <init-0>)		; init's must be evaluated
          ...				; in the order presented.
  (SET! <var-n> <init-n>)
  <body>)

Aside from making internal definition behave more like top level
definitions, I think this meaning of internal definitions reduces the
number of parentheses, and makes programs more readable.  What's your
opinion? 
John

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 31 Oct 88 12:42:16 EST
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA21555@BLOOM-BEACON.MIT.EDU>; Mon, 31 Oct 88 12:30:54 EST
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 31 Oct 88 16:28:42 GMT
From: ucdavis.ucdavis.edu!windley@ucdavis.ucdavis.edu  (Phil Windley)
Organization: UCD Robotics Research Lab
Subject: debuggers for teaching
Message-Id: <WINDLEY.88Oct31082928@cheetah.ucdavis.edu.cheetah.ucdavis.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


Has anyone written a program that demonstrates scheme evaluation in both
the substitution and environment model of evaluation (Sussman and Abelson)?
I've been contemplating such a "debugging" environment for my class.  The
substitution model could be text based, but I think that the environment
model would have to be based on X or some other windowing system.  I think
a tool like this would be great for teaching students about program
evaluation. 

--
Phil Windley                          |  windley@iris.ucdavis.edu
Division of Computer Science          |  ucbvax!ucdavis!iris!windley
College of Engineering                |  (916) 752-7324 (or 3168)
University of California, Davis       |  Davis, CA 95616

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 28 Oct 88 20:11:26 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA16794@BLOOM-BEACON.MIT.EDU>; Fri, 28 Oct 88 19:56:58 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 27 Oct 88 19:58:00 GMT
From: m.cs.uiuc.edu!carr@uxc.cso.uiuc.edu
Subject: Re: MacScheme Manual!
Message-Id: <38100001@m.cs.uiuc.edu>
References: <222600001@uxa.cso.uiuc.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


Semantic Microsystems
4470 S.W. Hall St.
Suite 340
Beaverton, Oregon  97005

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 28 Oct 88 08:11:17 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA09270@BLOOM-BEACON.MIT.EDU>; Fri, 28 Oct 88 07:55:39 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 28 Oct 88 11:53:22 GMT
From: verber@ohio-state.arpa  (Mark A. Verber)
Organization: Ohio State University, Computer Science Department
Subject: Re: MacScheme Manual!
Message-Id: <25950@tut.cis.ohio-state.edu>
References: <222600001@uxa.cso.uiuc.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


The makers of MacScheme are:

	Semantic Microsystems
	4470 S.W. Hall
	Suite 340
	Beaverton, OR 97005

	503-643-4539

Cheers,
Mark Verber

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 27 Oct 88 16:19:41 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA16857@BLOOM-BEACON.MIT.EDU>; Wed, 26 Oct 88 21:02:05 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 25 Oct 88 06:40:00 GMT
From: uxg.cso.uiuc.edu!uxa.cso.uiuc.edu!jb10320@uxc.cso.uiuc.edu
Subject: MacScheme Manual!
Message-Id: <222600001@uxa.cso.uiuc.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


Does anybody have the address/phone for Semantic Microsystems, the makers
of the MacScheme system?  I got the program thru the U of I licence for CS199, and now can't find anyone with the dox.

Help!

jb10320@uxa.cso.uiuc.edu
:

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 27 Oct 88 16:16:53 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA22826@BLOOM-BEACON.MIT.EDU>; Thu, 27 Oct 88 05:47:31 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 26 Oct 88 00:58:21 GMT
From: pasteur!agate!saturn!kjell@ames.arpa  (Kjell Post)
Organization: University of California, Santa Cruz
Subject: Re: self-replicating-code, self-replicating-messages
Message-Id: <5259@saturn.ucsc.edu>
References: <8810241240.AA20497@tub-tfs.uucp>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

In article <8810241240.AA20497@tub-tfs.uucp> alti@tub-tfs.UUCP (Thorsten Altenkirch) writes:
>I find it more interesting to discuss things like self replicating
>code than technical details of SCHEME Implementations. Perhaps I am
>on the wrong mailing list. Is there one about functional-programming,
>lambda-calculus, theory and application ???

I haven't seen one but I certainly wouldn't mind.
By the way, why isn't there a comp.lang.ml?

	fun Y f x = f (Y f) x;
	fun fac x = Y (fn f => fn x => if x = 0 then 1 else x*f(x-1)) x;

Received: from MITVMA.MIT.EDU (TCP 2227000003) by MC.LCS.MIT.EDU 26 Oct 88 13:16:05 EDT
Received: from MITVMA.MIT.EDU by MITVMA.MIT.EDU (IBM VM SMTP R1.1) with BSMTP id 1800; Wed, 26 Oct 88 13:13:48 EDT
Received: from DB0TUI6.BITNET (ZTUBTFAL) by MITVMA.MIT.EDU (Mailer X1.25) with
 BSMTP id 1798; Wed, 26 Oct 88 13:13:04 EDT
Received: by tub.UUCP; Wed, 26 Oct 88 18:11:43 +0200; AA12857
Received: by tub-tfs.uucp (4.0/SMI-3.0DEV3)
        id AA05234; Wed, 26 Oct 88 18:13:44 +0100
Date: Wed, 26 Oct 88 18:13:44 +0100
From: alti%tub-tfs.uucp%TUB.BITNET@MITVMA.MIT.EDU (Thorsten Altenkirch)
Message-Id: <8810261713.AA05234@tub-tfs.uucp>
To: uunet!rice.edu!dorai@tub.UUCP
Cc: scheme%mc.lcs.mit.edu@tub.uucp
In-Reply-To: Dorai Sitaram's message of Tue, 25 Oct 88 22:46:50 CDT
 <8810260346.AA26475@titan.rice.edu>
Subject: self-replicating-code, self-replicating-messages


> I think you are confusing the phenomenon of reduction to normal form
> in the lambda calculus with the process of evaluation which takes
> place in the case of a Scheme program yielding a value.

Sorry, I haven't been clear here. There is a strong analogy between
reduction and evaluation, but it's not the same thing. For me the
lambda calculus serves as a principial model of functional languages,
which can be used to understand certain aspects of these languages
without the overload of accidential properties of implementations. So
evaluation relates to reduction and values to normal forms.

There are functional languages which use reduction as evaluation.
MIRANDA is such an example, it uses a reduction machine for lazy
evaluation. See the book of Simon L. Peyton Jones ("The implementation
of functional programming languages", Prentice/Hall, 1988) for how
lazy functional languages are implemented by reduction machines.

> E.g., the result of the program (list 'list 8) is (list 8), *not* (8),
> which would have been the case in the case of continual reduction.

I think the relation between normal forms and values is, that normal
forms somehow denotate values. The point that lisp values can be lisp
programs again is - as important it is for programming practice - only
confusing here.

> >(define (yy y f x) ((f ((y y) f)) x))
> >(define y (yy yy))

> You doubtless imply currying, viz.,
> (define yy (lambda (y) (lambda (f) (lambda (x) ((f ((y y) f)) x)))))

I am sorry, somehow I copied the old version of the function into my
buffer. I imply nothing it's just a mistake - your version is the
correct one.

Thank you for your comments . . .

Until now nobody has answered my other question (mailing list for
theoretical questions of functional programming).

Thorsten

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 26 Oct 88 06:10:32 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA06222@BLOOM-BEACON.MIT.EDU>; Wed, 26 Oct 88 04:04:06 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 26 Oct 88 05:54:40 GMT
From: chiba!khb@sun.com  (Keith Bierman - Sun Tactical Engineering)
Subject: -------------------------- call for votes -------------------
Message-Id: <74720@sun.uucp>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu



----------------------------------------------------------------------------
****************************************************************************
			    CALL FOR VOTES
----------------------------------------------------------------------------
****************************************************************************

Comp.lang.sigplan --- a moderated newsgroup sponsored by the ACM.
SIGPLAN is the ACM's special interest group on computer languages. The
forum will focus on issues which are of "general" interest.

This is merely a pointer. The "real" call for votes is located in News.groups.

Those who wish to vote yes can skip reading news.groups and simply
send mail to sigplan@iuvax.cs.indiana.edu. The SUBJECT should be YES.

Those not in favor should read the real call for votes before casting
a vote.

Thanks for your support.



Keith H. Bierman
It's Not My Fault ---- I Voted for Bill & Opus

Received: from MITVMA.MIT.EDU (TCP 2227000003) by MC.LCS.MIT.EDU 24 Oct 88 14:56:59 EDT
Received: from MITVMA.MIT.EDU by MITVMA.MIT.EDU (IBM VM SMTP R1.1) with BSMTP id 3598; Mon, 24 Oct 88 09:37:18 EDT
Received: from DB0TUI6.BITNET (ZTUBTFAL) by MITVMA.MIT.EDU (Mailer X1.25) with
 BSMTP id 3597; Mon, 24 Oct 88 09:22:50 EDT
Received: by tub.UUCP; Mon, 24 Oct 88 13:38:39 +0200; AA06867
Received: by tub-tfs.uucp (4.0/SMI-3.0DEV3)
        id AA20497; Mon, 24 Oct 88 13:40:34 +0100
Date: Mon, 24 Oct 88 13:40:34 +0100
From: alti%tub-tfs.uucp%TUB.BITNET@MITVMA.MIT.EDU (Thorsten Altenkirch)
Message-Id: <8810241240.AA20497@tub-tfs.uucp>
To: scheme%mc.lcs.mit.edu@tub.uucp
Subject: Re: self-replicating-code, self-replicating-messages

I find it more interesting to discuss things like self replicating
code than technical details of SCHEME Implementations. Perhaps I am
on the wrong mailing list. Is there one about functional-programming,
lambda-calculus, theory and application ???

The most solutions to the problem were quite tricky. The reason is
that the problem was ill defined. The most interesting contributioon
came from
"G.OULSNAM" <uunet!MITVMA.MIT.EDU!STCS8004%IRUCCVAX.UCC.IE@tub.UUCP>

                  ((lambda (x) (x x)) (lambda (x) (x x)))

The critic was that these expression has no normal form - even worse
it is an example for an so called non solvable term, which puts even
a lazy evaluator (which does only head reductions) into an infinite
loop.

But the point is, that every solution to the proble has no normal
form, because if :

x ---> x

(---> means reduces to), than you can go on reducing x...

More interesting is another question : Is there a function, which
returns itself for every argument ?

This problem can be solved more straightforward. You just need a
solution for the equation

f x = f , for every x.

This can be done with the fixed-point-combinator Y. The solution is

f = Y K

or in lambda notation :

f = lambda f . ( lambda x . f x x ) ( lambda x . f x x )
        (lambda x y . x)

The Y - Kombinator is a relative of letrec in scheme, so in scheme you
would write :

(define y-k (letrec ((h (lambda (x) h))) h))

It is also possible to define Y in terms of simple scheme expressions
without refering to letrec at all :

(define (yy y f x) ((f ((y y) f)) x))
(define y (yy yy))

So now you can just write :

(define (k x) (lambda (y) x))
(define y-k (y k))

Thorsten



Received: from XX.LCS.MIT.EDU by MC.LCS.MIT.EDU via Chaosnet; 24 OCT 88  10:14:34 EDT
Received: from BLOOM-BEACON.MIT.EDU by XX.LCS.MIT.EDU with TCP/SMTP; Sun 23 Oct 88 07:34:02-EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA12546@BLOOM-BEACON.MIT.EDU>; Sun, 23 Oct 88 07:22:12 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 23 Oct 88 08:36:55 GMT
From: helios.ee.lbl.gov!pasteur!agate!e260-2c.berkeley.edu!c60a-2ce@nosc.mil  (Mikey)
Organization: University of California, Berkeley
Subject: Re: Wanted:  most recent xscheme
Message-Id: <15901@agate.BERKELEY.EDU>
References: <30901@bbn.COM>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


Is there xscheme for the Mac? I know there is Xlisp. If so, will someone 
please email me a copy or post it to comp.binaries.mac? I would greatly
appreciate it!!!!!
---------------------------------------------------------------------
Please reply via e-mail; I just don't have enough time to go thru
the entire newsgroup. Thanks a lot!
c60a-2ce@web.berkeley.edu@ucbvax.berkeley.edu...................Mikey
*** Call Tanelorn III! (415) 540-1180. The Apple/Mac BBS of Berkeley.

Received: from XX.LCS.MIT.EDU by MC.LCS.MIT.EDU via Chaosnet; 24 OCT 88  10:13:16 EDT
Received: from shredded-wheat.ai.mit.edu by XX.LCS.MIT.EDU with TCP/SMTP; Mon 24 Oct 88 10:12:47-EDT
Received: by shredded-wheat.ai.mit.edu; Mon, 24 Oct 88 10:13:10 EDT
Date: Mon, 24 Oct 88 10:13:10 EDT
From: kranz@wheaties.ai.mit.edu (David Kranz)
Message-Id: <8810241413.AA04159@shredded-wheat.ai.mit.edu>
To: uoregon!markv@beaver.cs.washington.edu
Cc: scheme@mc.lcs.mit.edu
In-Reply-To: (Mark VandeWettering's message of 20 Oct 88 18:21:46 GMT <3007@uoregon.uoregon.edu>
Subject: Where/how to get Scheme for Suns?

   Date: 20 Oct 88 18:21:46 GMT
   From: uoregon!markv@beaver.cs.washington.edu  (Mark VandeWettering)
   Organization: University of Oregon, Computer Science, Eugene OR
   References: <483@ccncsu.ColoState.EDU>
   Sender: scheme-request@mc.lcs.mit.edu

   After being irritated by the slowness of C-Scheme, I decided to try
   the T dialect of Scheme.  It is available via anonymous from 
   prep.ai.mit.edu in the "t" subdirectory.  Versions are available for the
   Sun and the Vax.  I have used the sun version extensively, and find it 
   very nice, and it compiles to very good native code.

   There are some trivial differences between T and Scheme, but they
   are both based on the R3RS, so problems should be minimal.




The latest version of T is on wheaties.ai.mit.edu in the pub/t3.1 directory
via anonymous FTP.  Note that typing (scheme-reset) to the top level prompt
will put you in a R3RS environment.  Versions are available for Sun, Vax, Hp,
Apollo, Mac II (Unix) and Encore Multimax.

Received: from XX.LCS.MIT.EDU (CHAOS 2420) by MC.LCS.MIT.EDU 22 Oct 88 18:27:46 EDT
Received: from void.ai.mit.edu by XX.LCS.MIT.EDU with TCP/SMTP; Sat 22 Oct 88 12:18:12-EDT
Received: by void.ai.mit.edu (5.59/1.5)
	id AA02865; Sat, 22 Oct 88 12:22:10 EDT
Date: Sat, 22 Oct 88 12:22:10 EDT
From: jar@void.ai.mit.edu (Jonathan Rees)
Message-Id: <8810221622.AA02865@void.ai.mit.edu>
To: uoregon!markv@beaver.cs.washington.edu
Cc: scheme@mc.lcs.mit.edu
In-Reply-To: (Mark VandeWettering's message of 20 Oct 88 18:21:46 GMT <3007@uoregon.uoregon.edu>
Subject: Where/how to get Scheme for Suns?
Reply-To: jar@zurich.ai.mit.edu

   Date: 20 Oct 88 18:21:46 GMT
   From: uoregon!markv@beaver.cs.washington.edu  (Mark VandeWettering)

   After being irritated by the slowness of C-Scheme, I decided to try
   the T dialect of Scheme.  It is available via anonymous from 
   prep.ai.mit.edu in the "t" subdirectory.  Versions are available for the
   Sun and the Vax.  I have used the sun version extensively, and find it 
   very nice, and it compiles to very good native code.

Please get T version 3.1 from wheaties.ai.mit.edu.  I think there's a
/pub/t3.1 directory.  Prep only has T version 3.0.

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 22 Oct 88 14:18:53 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA21584@BLOOM-BEACON.MIT.EDU>; Sat, 22 Oct 88 13:24:13 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 20 Oct 88 20:24:11 GMT
From: mcvax!enea!kth!draken!chalmers!cs.chalmers.se!augustss@uunet.uu.net  (Lennart Augustsson)
Organization: Dept. of CS, Chalmers, Sweden
Subject: Re: Limitation with lambda
Message-Id: <2769@fnatte.cs.chalmers.se>
References: <15590@agate.BERKELEY.EDU>, <4557@polya.Stanford.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

In article <4557@polya.Stanford.EDU> weening@Gang-of-Four.Stanford.EDU (Joe Weening) writes:
>In article <15590@agate.BERKELEY.EDU>, 128a-3aj@e260-3b (Jonathan Dubman) writes:
>>
>>There seems to be a gross omission in the lambda primitive.  It seems like
>>there is no way to create a recursive function on the fly!  I'm reading
>>the Abelson and Sussman book but they seem to avoid this issue.
... [ Talk about LABEL ] ...
>
>I don't know if it was known in 1963, but LABEL or its equivalent is
>not actually necessary in order to define recursive functions.  The
>trick is to use the Y combinator.  In practice, though, this method
>would be fairly inefficient.

It was certainly known in 1963, the question is who knew it.  The fact that
Y can be defined in terms of (nonrecursive) functions was discovered in the
30s (I think) by Haskell B. Curry.  He didn't die until the -83 (or so) so
at least he knew, and assuming that people read his books others knew as well.
The problem is that probably very few computer scientist knew about it (well,
it's not really a problem since this definition(s) of Y is of theoretical
interest only).



-- 

	Lennart Augustsson
Email:	augustss@cs.chalmers.se or augustss@chalmers.csnet

Received: from RELAY.CS.NET (TCP 1201000005) by MC.LCS.MIT.EDU 21 Oct 88 23:02:39 EDT
Received: from relay2.cs.net by RELAY.CS.NET id ba04850; 21 Oct 88 18:04 EDT
Received: from zix.gmd.dbp.de by RELAY.CS.NET id ap06834; 21 Oct 88 17:33 EDT
Received: from zix.gmd.dbp.de by .zix.gmd.dbp.de id a003549; 21 Oct 88 19:52 MET
Date: 21 Oct 88 14:37 GMT+0100
From: Michael Stumpf <stumpf%cogsys.psychologie.uni-freiburg.dbp.de@RELAY.CS.NET>
To: Harold Carr <carr%car@CS.UTAH.EDU>
Cc:  scheme@MC.LCS.MIT.EDU
MMDF-Warning:  Parse error in original version of preceding line at gmdzix.csnet
In-Reply-To: <<8810171639.AA02636@car.utah.edu>>
Message-ID: <282:stumpf@cogsys.psychologie.uni-freiburg.dbp.de>
Subject: Re: self reproducing messages.

Harold,
perhaps the best way to do it is to collect all examples of
self-reproducing programs or whatsoever and to distribute the
commented list through the scheme mailing list... I think that
most of the people listening to it are in fact interested in
the examples, but are not willing to step through each of the
messages.
Of course, its a problem with the cc message field...
Michael.

Received: from XX.LCS.MIT.EDU (CHAOS 2420) by MC.LCS.MIT.EDU 21 Oct 88 19:01:02 EDT
Received: from BLOOM-BEACON.MIT.EDU by XX.LCS.MIT.EDU with TCP/SMTP; Thu 20 Oct 88 15:48:34-EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA29392@BLOOM-BEACON.MIT.EDU>; Thu, 20 Oct 88 15:38:34 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 20 Oct 88 18:21:46 GMT
From: uoregon!markv@beaver.cs.washington.edu  (Mark VandeWettering)
Organization: University of Oregon, Computer Science, Eugene OR
Subject: Re: Where/how to get Scheme for Suns?
Message-Id: <3007@uoregon.uoregon.edu>
References: <483@ccncsu.ColoState.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

In article <483@ccncsu.ColoState.EDU> olender@handel.CS.ColoState.EDU (Kurt Olender) writes:
>I am looking for an implementation of Scheme (no particular
>dialect) that will compile to native code for the Sun-3 
>workstation, preferable PD?  Can someone tell me who/where
>to contact?  Thanks
>
>	- Kurt Olender

After being irritated by the slowness of C-Scheme, I decided to try
the T dialect of Scheme.  It is available via anonymous from 
prep.ai.mit.edu in the "t" subdirectory.  Versions are available for the
Sun and the Vax.  I have used the sun version extensively, and find it 
very nice, and it compiles to very good native code.

There are some trivial differences between T and Scheme, but they
are both based on the R3RS, so problems should be minimal.

Received: from XX.LCS.MIT.EDU (CHAOS 2420) by MC.LCS.MIT.EDU 21 Oct 88 16:46:10 EDT
Received: from BLOOM-BEACON.MIT.EDU by XX.LCS.MIT.EDU with TCP/SMTP; Thu 20 Oct 88 20:03:44-EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA05703@BLOOM-BEACON.MIT.EDU>; Thu, 20 Oct 88 19:56:35 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 20 Oct 88 23:14:22 GMT
From: titan!dorai@rice.edu  (Dorai Sitaram)
Organization: Rice University, Houston
Subject: case-lambda and interpreter environments
Message-Id: <2033@kalliope.rice.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

Since there's been some talk of case-lambda, thought I'd say something
about a simple use of this syntax to get a nice implementation of 
interpreter environments. The definition of the initial environment
(which doesn't associate any identifier with any value) goes as
follows:

(define init-env
  (letrec ([extend (lambda (r x v)
		     (rec r1
			 (case-lambda
			  [(y) (if (eq? y x) v (r y))]
			  [(y w) (extend r1 y w)])))])
    (rec r
	(case-lambda
	 [(x) (error "unbound ~a" x)]
	 [(x v) (extend r x v)]))))

No other function is required! When called with a single argument (an
identifier), the environment yields the value of the identifier; when
called with two arguments (an identifier and a value) a new
environment is produced which is the extension of the original one
associating the new identifier with the new value. 

One attraction (fatal? |-]) with this is that the use of the
environment closely mimics denotational semantics notation, viz.,

r[x] 	;for looking up identifier x in environment r; and
r[x/v]	;for extending environment r to associate x with v.

--dorai

Received: from XX.LCS.MIT.EDU (CHAOS 2420) by MC.LCS.MIT.EDU 21 Oct 88 16:45:48 EDT
Received: from BLOOM-BEACON.MIT.EDU by XX.LCS.MIT.EDU with TCP/SMTP; Thu 20 Oct 88 19:58:07-EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA25972@BLOOM-BEACON.MIT.EDU>; Thu, 20 Oct 88 13:56:45 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 20 Oct 88 16:33:04 GMT
From: ccncsu!handel.CS.ColoState.EDU!olender@boulder.colorado.edu  (Kurt Olender)
Organization: Colorado State University, Ft. Collins CO 80526
Subject: Where/how to get Scheme for Suns?
Message-Id: <483@ccncsu.ColoState.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

I am looking for an implementation of Scheme (no particular
dialect) that will compile to native code for the Sun-3 
workstation, preferable PD?  Can someone tell me who/where
to contact?  Thanks

	- Kurt Olender

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 20 Oct 88 17:46:45 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA24672@BLOOM-BEACON.MIT.EDU>; Thu, 20 Oct 88 13:10:42 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 20 Oct 88 02:02:24 GMT
From: portal!cup.portal.com!@uunet.uu.net  (Daniel B Hankins)
Organization: The Portal System (TM)
Subject: Lisp, Xlisp, Prolog and Scheme
Message-Id: <10218@cup.portal.com>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


     I have an application which I would like to prototype in one of the
four subject languages.  Please see my posting to comp.lang.misc under the
topic 'Prolog and Lisp'.  Comments are solicited.

     Thanks.


Dan Hankins

Received: from G.BBN.COM (TCP 1000400022) by MC.LCS.MIT.EDU 20 Oct 88 14:39:38 EDT
Date: 20 Oct 1988 11:03-EDT
Sender: FWHITE@G.BBN.COM
Subject: Re: Limitation with lambda
From: FWHITE@G.BBN.COM
To: polya!weening%Gang-of-Four.Stanford.EDU@LABREA.STANFORD.EDU
Cc: scheme@MC.LCS.MIT.EDU
Message-ID: <[G.BBN.COM]20-Oct-88 11:03:02.FWHITE>
In-Reply-To: <4557@polya.Stanford.EDU>

  In "A Basis for a Mathematical Theory of Computation"* by
McCarthy, which dates from the 1961 Western Joint Computer
Conference, McCarthy mentions that Y can be used to eliminate
LABEL but at the expense of giant resulting expressions.

  Who did invent Y, anyways?

------------
* Reprinted in "Computer Programming and Formal Systems", 
P. Braffort & D. Hirschberg eds, 1967. See pp 46-7.

Received: from XX.LCS.MIT.EDU (CHAOS 2420) by MC.LCS.MIT.EDU 20 Oct 88 01:49:24 EDT
Received: from BLOOM-BEACON.MIT.EDU by XX.LCS.MIT.EDU with TCP/SMTP; Wed 19 Oct 88 09:44:10-EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA08134@BLOOM-BEACON.MIT.EDU>; Wed, 19 Oct 88 00:06:32 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 19 Oct 88 02:31:35 GMT
From: polya!weening%Gang-of-Four.Stanford.EDU@labrea.stanford.edu  (Joe Weening)
Organization: Stanford University
Subject: Re: Limitation with lambda
Message-Id: <4557@polya.Stanford.EDU>
References: <15590@agate.BERKELEY.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

In article <15590@agate.BERKELEY.EDU>, 128a-3aj@e260-3b (Jonathan Dubman) writes:
>
>There seems to be a gross omission in the lambda primitive.  It seems like
>there is no way to create a recursive function on the fly!  I'm reading
>the Abelson and Sussman book but they seem to avoid this issue.

This problem actually has quite an interesting history.  From the Lisp
1.5 Programmer's Manual (J. McCarthy et al, 1963), p. 8:

    "The lambda notation alone is inadequate for naming recursive
    functions.  Not only must the variables be bound, but the name of
    the function must be bound, since it is used inside an expresion
    to stand for the entire expression. ... In order to be able to
    write expressions that bear their own name, we introduce the LABEL
    notation."

LABEL only defines a single function in terms of itself.  Scheme's
LETREC and Common Lisp's LABELS extend this to allow mutually
recursive function definitions.

I don't know if it was known in 1963, but LABEL or its equivalent is
not actually necessary in order to define recursive functions.  The
trick is to use the Y combinator.  In practice, though, this method
would be fairly inefficient.
-- 
Joe Weening                                Computer Science Dept.
weening@Gang-of-Four.Stanford.EDU          Stanford University

Received: from MCC.COM (TCP 1200600076) by MC.LCS.MIT.EDU 19 Oct 88 20:51:49 EDT
Received: from PELE.ACA.MCC.COM (PELE.ACA.MCC.COM.#Chaos) by MCC.#Chaos with Chaos/SMTP; Wed 19 Oct 88 16:45:19-CDT
Date: Wed, 19 Oct 88 16:45 CDT
From: Christopher Maeda <maeda@MCC.COM>
Subject: Self reference in objects (Adventure)
To: scheme@mc.lcs.mit.edu
In-Reply-To: The message from HANCHE%NORUNIT.BITNET@CUNYVM.CUNY.EDU
Message-ID: <19881019214531.1.MAEDA@PELE.ACA.MCC.COM>

    From: HANCHE%NORUNIT.BITNET@CUNYVM.CUNY.EDU

    Date: 19 October 1988, 16:51:25 ECT
    From: Harald Hanche-Olsen       +47-7-593525         HANCHE   at NORUNIT
    To:   scheme@mc.lcs.mit.edu

    (I suppose this should be sent directly to Jonathan Dubman who asked
    the question, but my mailer would not accept his monstrous address...)

    To: apple!bionet!agate!e260-3b.berkeley.edu!128a-3aj@BLOOM-BEACON.MIT.EDU

    [...]

Wasn't there a 6.001 problem set on this?  Can't we just send the
sources to this guy and be done with it?

Received: from CUNYVM.CUNY.EDU (TCP 20071000402) by MC.LCS.MIT.EDU 19 Oct 88 19:41:55 EDT
Received: from NORUNIT.BITNET by CUNYVM.CUNY.EDU (IBM VM SMTP R1.1) with BSMTP id 6035; Wed, 19 Oct 88 12:46:35 EDT
Date: Wed, 19 Oct 88 16:59:28 ECT
To: scheme@mc.lcs.mit.edu
From: HANCHE%NORUNIT.BITNET@CUNYVM.CUNY.EDU
Comment: CROSSNET mail via SMTP@INTERBIT
Subject: Self reference in objects

Date: 19 October 1988, 16:51:25 ECT
From: Harald Hanche-Olsen       +47-7-593525         HANCHE   at NORUNIT
To:   scheme@mc.lcs.mit.edu

(I suppose this should be sent directly to Jonathan Dubman who asked
the question, but my mailer would not accept his monstrous address...)

To: apple!bionet!agate!e260-3b.berkeley.edu!128a-3aj@BLOOM-BEACON.MIT.EDU

Jonathan had problems with allowing his objects to refer to themselves.
His objects are defined by lambda expressions, so I can't think of any
reason why the following would not work:

(define (make-player ...)
  (letrec
    ((self (lambda (...)   <body of player>)))
    self))

or something like it.  In <body of player> you can use  self
to denote *this* player, like in

(present-room 'move self 'north)

- Harald Hanche-Olsen

Received: from EDDIE.MIT.EDU by MC.LCS.MIT.EDU via Chaosnet; 19 OCT 88  17:55:36 EDT
Received: by EDDIE.MIT.EDU with UUCP with smail2.5 with sendmail-5.45/4.7 id <AA26843@EDDIE.MIT.EDU>; Tue, 18 Oct 88 19:48:26 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA01440@BLOOM-BEACON.MIT.EDU>; Tue, 18 Oct 88 18:28:36 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 18 Oct 88 19:04:12 GMT
From: pierce@locus.ucla.edu
Organization: UCLA Computer Science Department
Subject: case-lambda syntax in Chez Scheme
Message-Id: <16934@shemp.CS.UCLA.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

-
Some good person replied to my example in Re: Limitation with Lambda.
This person pointed out that the "case-lambda" syntax is not standard
Scheme.  My apologies, case-lambda is from Chez Scheme Version 2.0,
and I have found it so useful (I use it a *lot*) that I just forgot
that users of other Scheme systems might not know what it meant.

An excerpt from the Chez Scheme Version 2.0 release notes follows.  It's
a simple idea that not only makes code easier to write and to understand,
but it also runs faster than the old way.  Maybe Kent Dybvig could
be encouraged to post a little more info about case-lambda?

-- Brad Pierce

------------------------------------------------------------------------
(below Copyright Kent Dybvig)

Optional Arguments

    Procedures with a variable number of arguments could only be defined 
    in earlier versions using the "lambda dot" interface, which requires 
    allocation  of  a  list  to hold all but  the  required  parameters.  
    Version  2.0 supports a variant of "lambda",  called  "case-lambda", 
    that  allows  procedures with variable numbers of  arguments  to  be 
    defined efficiently.  "case-lambda" has the form:

         (case-lambda [idspec-a exp1-a exp2-a ...]
                      [idspec-b exp1-b exp2-b ...] ...)

    where the idspecs are normal "lambda" parameter lists.   In essence, 
    each  bracketted item (parens may be used in place of the  brackets) 
    represents  a different "lambda" expression;  which one is evaluated 
    depends upon the number of arguments.  If the number of arguments is 
    a correct number for the first idspec,  evaluation proceeds with the 
    first body within the bindings implied by the first idspec.  If not, 
    then  if the number of arguments is a correct number for the  second 
    idspec, evaluation proceeds with the second body, etc.

Received: from zohar (TCP 2212600256) by MC.LCS.MIT.EDU 19 Oct 88 16:54:10 EDT
Received: by ZOHAR.AI.MIT.EDU; Tue, 18 Oct 88 09:43:26 edt
Date: Tue, 18 Oct 88 09:43:26 edt
From: gjs@ZOHAR.AI.MIT.EDU (Gerald Jay Sussman)
Message-Id: <8810181343.AA00956@zohar>
To: apple!bionet!agate!e260-3b.berkeley.edu!128a-3aj@bloom-beacon.mit.edu
Cc: scheme@mc.lcs.mit.edu
In-Reply-To: (Jonathan Dubman's message of 17 Oct 88 17:00:42 GMT <15590@agate.BERKELEY.EDU>
Subject: Limitation with lambda


You ask:

    For example, how would someone write a function generator that generates the
    sum of all squares or cubes or fourths, etc., based on an exponent?


How 'bout:

(define sum-of-powers 
  (lambda (power)
    (lambda (n)
      (sum-of (lambda (i)
                (expt i power))
              n))))

(define sum-of
  (lambda (termfun nterms)
    (if (= nterms 0)
        0
        (+ (termfun nterms) 
	   (sum-of termfun (- nterms 1))))))


;;; e.g.

((sum-of-powers 3) 5)
;Value: 225

Does this solve your problem?  If not, call me on the phone and I will
try to debug you.  My phone is (617) 253-5874.

Received: from MITVMA.MIT.EDU (TCP 2227000003) by MC.LCS.MIT.EDU 19 Oct 88 16:53:39 EDT
Received: from MITVMA.MIT.EDU by MITVMA.MIT.EDU (IBM VM SMTP R1.1) with BSMTP id 0247; Mon, 17 Oct 88 15:37:22 EDT
Received: from IRUCCIBM by MITVMA.MIT.EDU (Mailer X1.25) with BSMTP id 0246;
 Mon, 17 Oct 88 12:28:25 EDT
Received: from IRUCCVAX.UCC.IE by IRUCCIBM (Mailer X1.25) with BSMTP id 3774;
 Mon, 17 Oct 88 17:16:48 IST
Date: Mon, 17 Oct 88 17:20 GMT
From: "G.OULSNAM" <STCS8004%IRUCCVAX.UCC.IE@MITVMA.MIT.EDU>
Subject: Unknown host
To: SCHEME@MC.LCS.MIT.EDU
X-VMS-To: SCHEME

Attn: John Gateley@mips.csc.ti.com
I tried  replying  to  your  direct  mail  (for  which  thanks) but gateway
CUNYVM.CUNY.EDU  claims that  your host  mips.csc.ti.com is  Unknown, so my
mail was returned.

Apologies to everyone else for cluttering up your mail with this message.

Gordon Oulsnam.

Received: from CUNYVM.CUNY.EDU (TCP 20071000402) by MC.LCS.MIT.EDU 19 Oct 88 16:46:20 EDT
Received: from NORUNIT.BITNET by CUNYVM.CUNY.EDU (IBM VM SMTP R1.1) with BSMTP id 6035; Wed, 19 Oct 88 12:46:35 EDT
Date: Wed, 19 Oct 88 16:59:28 ECT
To: scheme@mc.lcs.mit.edu
From: HANCHE%NORUNIT.BITNET@CUNYVM.CUNY.EDU
Comment: CROSSNET mail via SMTP@INTERBIT
Subject: Self reference in objects

Date: 19 October 1988, 16:51:25 ECT
From: Harald Hanche-Olsen       +47-7-593525         HANCHE   at NORUNIT
To:   scheme@mc.lcs.mit.edu

(I suppose this should be sent directly to Jonathan Dubman who asked
the question, but my mailer would not accept his monstrous address...)

To: apple!bionet!agate!e260-3b.berkeley.edu!128a-3aj@BLOOM-BEACON.MIT.EDU

Jonathan had problems with allowing his objects to refer to themselves.
His objects are defined by lambda expressions, so I can't think of any
reason why the following would not work:

(define (make-player ...)
  (letrec
    ((self (lambda (...)   <body of player>)))
    self))

or something like it.  In <body of player> you can use  self
to denote *this* player, like in

(present-room 'move self 'north)

- Harald Hanche-Olsen

Received: from XX.LCS.MIT.EDU (CHAOS 2420) by MC.LCS.MIT.EDU 17 Oct 88 18:59:50 EDT
Received: from cs.utah.edu by XX.LCS.MIT.EDU with TCP/SMTP; Mon 17 Oct 88 14:58:38-EDT
Received: from car.utah.edu by cs.utah.edu (5.59/utah-2.0-cs)
	id AA00275; Mon, 17 Oct 88 10:45:12 MDT
Received: by car.utah.edu (5.59/utah-2.0-leaf)
	id AA02636; Mon, 17 Oct 88 10:39:28 MDT
Date: Mon, 17 Oct 88 10:39:28 MDT
From: carr%car@cs.utah.edu (Harold Carr)
Message-Id: <8810171639.AA02636@car.utah.edu>
To: cph@zurich.ai.mit.edu
Cc: scheme@mc.lcs.mit.edu
In-Reply-To: Chris Hanson's message of Thu, 13 Oct 88 19:02:33 EDT <8810132302.AA05926@kleph.ai.mit.edu>
Subject: Re: self reproducing messages.

OK, even though this list is pretty quiet most of the time, it looks
as if Chris and Daniel would like it to remain that way.  But please,
feel free to continue sending examples of self reproducing code
directly to me (I never said cc to scheme@mc.lcs.mit.edu in the first
place).

Thanks for the replies so far, and sorry for "annoying" anyone else.

Harold Carr

Received: from XX.LCS.MIT.EDU (CHAOS 2420) by MC.LCS.MIT.EDU 17 Oct 88 18:53:18 EDT
Received: from BLOOM-BEACON.MIT.EDU by XX.LCS.MIT.EDU with TCP/SMTP; Mon 17 Oct 88 13:55:31-EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA11375@BLOOM-BEACON.MIT.EDU>; Mon, 17 Oct 88 13:32:27 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 17 Oct 88 17:00:42 GMT
From: apple!bionet!agate!e260-3b.berkeley.edu!128a-3aj@bloom-beacon.mit.edu  (Jonathan Dubman)
Organization: University of California, Berkeley
Subject: Limitation with lambda
Message-Id: <15590@agate.BERKELEY.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


There seems to be a gross omission in the lambda primitive.  It seems like
there is no way to create a recursive function on the fly!  I'm reading
the Abelson and Sussman book but they seem to avoid this issue.

For example, how would someone write a function generator that generates the
sum of all squares or cubes or fourths, etc., based on an exponent?

Bear with me, as I'm not a Scheme expert.

My specific problem arises from trying to write a simple object-oriented
mini-adventure in Scheme.  There are two types of objects: players and rooms.
Rooms have four exits.  Given a direction and a player, the room will move the
player to the new room in that direction.
Players have a current room.  They accept two messages: 'move direction and
'hop new-room.  Say you tell a player to go north.  He knows his current room
and asks that room to send him north.  But how can that happen, if the player
doesn't know his own name?  Make-player, which is a call to a lambda, can't
tell the current room to move the player in the given direction because the
player isn't defined until after the lambda is finished!

One possible solution is to change the communication method so that
players merely ask the room where the exit goes and move THEMSELVES.  But
that's not the way I wanted to do it.

Help!  What can I do?

	-Jonathan Dubman

Received: from XX.LCS.MIT.EDU (CHAOS 2420) by MC.LCS.MIT.EDU 17 Oct 88 18:47:21 EDT
Received: from BLOOM-BEACON.MIT.EDU by XX.LCS.MIT.EDU with TCP/SMTP; Mon 17 Oct 88 11:55:01-EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA09019@BLOOM-BEACON.MIT.EDU>; Mon, 17 Oct 88 11:38:29 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 17 Oct 88 15:17:04 GMT
From: jgrace%bbn.com@bbn.com
Subject: Wanted:  most recent xscheme
Message-Id: <30901@bbn.COM>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


Recently, someone mentioned that the most recent version
of xscheme was available on BIX.  I don't have an account
on BIX so...

  Could someone send me an e-mail copy of the most
  recent version of xscheme?

Thanks,

= Joe =

Joe Grace
ARPA: jgrace@bbn.com
UUCP: {harvard,husc6,decvax,ihnp4,etc.}!bbn!jgrace

Received: from EDDIE.MIT.EDU by MC.LCS.MIT.EDU via Chaosnet; 16 OCT 88  23:01:43 EDT
Received: by EDDIE.MIT.EDU with UUCP with smail2.5 with sendmail-5.45/4.7 id <AA21266@EDDIE.MIT.EDU>; Sun, 16 Oct 88 05:47:52 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA04145@BLOOM-BEACON.MIT.EDU>; Sun, 16 Oct 88 02:39:02 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 16 Oct 88 05:07:30 GMT
From: spdcc!ima!johnl@bloom-beacon.mit.edu  (John R. Levine)
Organization: Not much
Subject: coroutines
Message-Id: <2782@ima.ima.isc.com>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

Although it seems pretty clear that you should be able to implement
producer/consumer coroutines trivially with call/cc, I am having trouble
warping my brain around to get it right.

Does someone have some coroutine it* could send me?

TIA,
John

* - Non-sexist pronoun.
-- 
John R. Levine, IECC, PO Box 349, Cambridge MA 02238-0349, +1 617 492 3869
{ bbn | think | decvax | harvard | yale }!ima!johnl, Levine@YALE.something
Rome fell, Babylon fell, Scarsdale will have its turn.  -G. B. Shaw

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 14 Oct 88 03:44:41 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA07620@BLOOM-BEACON.MIT.EDU>; Thu, 13 Oct 88 23:34:15 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 14 Oct 88 02:53:20 GMT
From: apple!bionet!agate!web-2h.berkeley.edu!c60a-2ce@bloom-beacon.mit.edu  (Mikey)
Organization: University of California, Berkeley
Subject: Help!
Message-Id: <15438@agate.BERKELEY.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

Can someone please explain to me the differences and relative benefits of the following:
using manifest types, data-directed programming, message-passing.
---------------------------------------------------------------------
Please reply via e-mail; I just don't have enough time to go thru
the entire newsgroup. Thanks a lot!
				     "A little coitus, neva hoit us!"
c60a-2ce@web.berkeley.edu@ucbvax.berkeley.edu................Mike Kao

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 14 Oct 88 03:44:02 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA07904@BLOOM-BEACON.MIT.EDU>; Thu, 13 Oct 88 23:46:04 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 12 Oct 88 09:58:03 GMT
From: mcvax!enea!kth!draken!Urd!newsuser@uunet.uu.net  (LTH network news server)
Organization: Dept. of Automatic Control, Lund Inst. of Technology, Sweden
Subject: Self-reproducing code
Message-Id: <1988Oct12.105804.3747@LTH.Se>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


Several examples of self-reproducing code has been given in this group
lately. While running a definite risc of reminding people of what may
be already generally known, I would like to submit the shortest solution
of all. And not only the shortest, it will work in almost any language!

The solution is:

The only problem with this solution, the empty program, is that someone
might argue that it is not a program at all. Still, I think it has a
certain elegance to it.

"Real Programmers aren't afraid of RISC architectures."


-- 
Jan Eric Larsson                      janeric@Control.LTH.Se      +46 46 108795
Department of Automatic Control
Lund Institute of Technology         "We watched the thermocouples dance to the
Box 118, S-221 00 LUND, Sweden        spirited tunes of a high frequency band."

Received: from kleph.ai.mit.edu (TCP 2212600254) by MC.LCS.MIT.EDU 13 Oct 88 21:06:40 EDT
Received: by kleph.ai.mit.edu (5.59/1.5)
	id AA05926; Thu, 13 Oct 88 19:02:33 EDT
Date: Thu, 13 Oct 88 19:02:33 EDT
From: cph@kleph.ai.mit.edu (Chris Hanson)
Message-Id: <8810132302.AA05926@kleph.ai.mit.edu>
To: carr%car@cs.utah.edu
Cc: daniel@mojave.stanford.edu, scheme@mc.lcs.mit.edu
In-Reply-To: Harold Carr's message of Wed, 12 Oct 88 11:25:13 MDT <8810121725.AA29636@car.utah.edu>
Subject: self reproducing messages.
Reply-To: cph@zurich.ai.mit.edu

   Date: Wed, 12 Oct 88 11:25:13 MDT
   From: carr%car@cs.utah.edu (Harold Carr)

   On the contrary, I want to receive as many replies as possible on
   self-reproducing code, so please do send more if it doesn't duplicate
   any previous submissions.

   Thank you, Harold

I agree with Daniel.  If you want to talk about self reproducing code,
make your own mailing list.  This stuff has little or nothing to do
with Scheme.

Please remember that this is an ENORMOUS mailing list (hundreds of
people).  The subscribers to this list are expecting topics pertaining
to Scheme.  They have a right to be annoyed when a digression exceeds
a few messages (this one is already in the tens).

Received: from aic.nrl.navy.mil (TCP 3200200010) by MC.LCS.MIT.EDU 12 Oct 88 13:45:38 EDT
Return-Path: <hoey@aic.nrl.navy.mil>
Received: Wed, 12 Oct 88 13:43:58 EDT by aic.nrl.navy.mil id AA19260
Date: Wed, 12 Oct 88 13:43:58 EDT
From: Dan Hoey <hoey@aic.nrl.navy.mil>
Message-Id: <8810121743.AA19260@aic.nrl.navy.mil>
To: scheme@mc.lcs.mit.edu
Subject: Automatic programming

My favorite version of the LAMBDA self-reproducer is

((LAMBDA (LAMBDA) `(,LAMBDA ',LAMBDA))
 '(LAMBDA (LAMBDA) `(,LAMBDA ',LAMBDA)))

though SCHEMErs will have to forgo the pun.  There is also

(format t "~A~:*~S)" "(format t \"~A~:*~S)\" ")

Dan

Received: from cs.utah.edu (TCP 20033402025) by MC.LCS.MIT.EDU 12 Oct 88 13:25:57 EDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA09477; Wed, 12 Oct 88 11:25:17 MDT
Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA29636; Wed, 12 Oct 88 11:25:13 MDT
Date: Wed, 12 Oct 88 11:25:13 MDT
From: carr%car@cs.utah.edu (Harold Carr)
Message-Id: <8810121725.AA29636@car.utah.edu>
To: daniel@mojave.stanford.edu
Cc: scheme@mc.lcs.mit.edu
In-Reply-To: Daniel Weise's message of Wed, 12 Oct 88 09:22:17 PDT <8810121622.AA02612@mojave.Stanford.EDU>
Subject: Re: self reproducing messages.

On the contrary, I want to receive as many replies as possible on
self-reproducing code, so please do send more if it doesn't duplicate
any previous submissions.

Thank you, Harold

Received: from EDDIE.MIT.EDU by MC.LCS.MIT.EDU via Chaosnet; 12 OCT 88  12:36:11 EDT
Received: by EDDIE.MIT.EDU with UUCP with smail2.5 with sendmail-5.45/4.7 id <AA07031@EDDIE.MIT.EDU>; Wed, 12 Oct 88 12:35:42 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA19237@BLOOM-BEACON.MIT.EDU>; Wed, 12 Oct 88 12:09:38 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 10 Oct 88 22:58:15 GMT
From: dewey.soe.berkeley.edu!oster@ucbvax.berkeley.edu  (David Phillip Oster)
Organization: School of Education, UC-Berkeley
Subject: Re: Self-reproduction
Message-Id: <26381@ucbvax.BERKELEY.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

A cute trick, not quite a self-reproducing program, but an interesting
example of a string that produces itself, is to take an arbitrary error
message, and hand it back to the interpreter as input. On many systems if
you repeat this 4-8 times, you reach a fixed point at which no further
change occurs. This is also fun with a C compiler.

Received: from mojave.Stanford.EDU (TCP 4405400170) by MC.LCS.MIT.EDU 12 Oct 88 12:22:07 EDT
Received: by mojave.Stanford.EDU (5.59/inc-1.0)
	id AA02612; Wed, 12 Oct 88 09:22:17 PDT
Date: Wed, 12 Oct 88 09:22:17 PDT
From: daniel@mojave.Stanford.EDU (Daniel Weise)
Message-Id: <8810121622.AA02612@mojave.Stanford.EDU>
To: scheme@mc.lcs.mit.edu
Subject: self reproducing messages.

The entropy on this list is increasing.  Please stop sending messages
on self reproducing code.  

Daniel
 

Received: from MITVMA.MIT.EDU (TCP 2227000003) by MC.LCS.MIT.EDU 12 Oct 88 12:11:03 EDT
Received: from MITVMA.MIT.EDU by MITVMA.MIT.EDU (IBM VM SMTP R1.1) with BSMTP id 9799; Wed, 12 Oct 88 12:07:43 EDT
Received: from IRUCCIBM by MITVMA.MIT.EDU (Mailer X1.25) with BSMTP id 9798;
 Wed, 12 Oct 88 12:06:34 EDT
Received: from IRUCCVAX.UCC.IE by IRUCCIBM (Mailer X1.25) with BSMTP id 1372;
 Wed, 12 Oct 88 16:34:38 IST
Date: Wed, 12 Oct 88 16:35 GMT
From: "G.OULSNAM" <STCS8004%IRUCCVAX.UCC.IE@MITVMA.MIT.EDU>
Subject: Self-reproducing code (correction)
To: SCHEME@MC.LCS.MIT.EDU
X-VMS-To: SCHEME

My thanks  to John Gateley for  pointing out the erroneous  claim regarding
the normal order/applicative order evaluation of ((lambda (x) (x x) (lambda
(x) (x x)). I'm  sorry he chose not to examine the  rest of the derivation,
as  it did  not rely  on the  erroneous claim.  For the  record, what I now
consider I should have written was:

"Consider
                  ((lambda (x) (x x)) (lambda (x) (x x))).

With normal order  evaluation this reproduces itself, but  loops forever on
attempting  to  evaluate  the  result.  However,  in Scheme  the
argument  is evaluated  to an  internal procedure,  say #<procedure>, which
then  loops  forever  trying  to  evaluate  the  first  (x  x) in the above
expression, without reproducing the original form directly."

The remark  about Scheme applies to  TI Scheme (v2), and  can be checked by
depositing extra code to see what is being passed around. My point was, and
remains, that both normal order  and applicative order (by-value in Scheme)
cause the above  to loop, but for different  reasons. Normal order provided
the  idea for  self-reproducing code,  if  one  could first  find a  way to
emulate normal order evaluation, and then  find a way to stop evaluation of
the result.  The remainder of the article showed how.

Gordon Oulsnam.

Received: from kestrel.arpa (TCP 1200600040) by MC.LCS.MIT.EDU 12 Oct 88 04:08:34 EDT
Received: by kestrel.arpa (5.58/SMI-DDN)
	id AA16036; Wed, 12 Oct 88 01:07:26 PDT
Date: Wed, 12 Oct 88 01:07:26 PDT
From: gyro@kestrel.arpa (Scott B. Layson)
Message-Id: <8810120807.AA16036@kestrel.arpa>
To: carr%car@cs.utah.edu
Cc: scheme@mc.lcs.mit.edu
In-Reply-To: Harold Carr's message of Fri, 7 Oct 88 14:19:26 MDT <8810072019.AA25193@car.utah.edu>
Subject: self reproducing code

Here's a fun variation: write a Lisp function which returns its own
defining form (that is, a form EQUAL to the one you typed in to define
the function in the first place).

My solution to follow.  No doubt there are many.

-- Scott

Received: from EDDIE.MIT.EDU by MC.LCS.MIT.EDU via Chaosnet; 11 OCT 88  22:20:34 EDT
Received: by EDDIE.MIT.EDU with UUCP with smail2.5 with sendmail-5.45/4.7 id <AA24121@EDDIE.MIT.EDU>; Tue, 11 Oct 88 22:19:59 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA04466@BLOOM-BEACON.MIT.EDU>; Tue, 11 Oct 88 21:59:27 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 11 Oct 88 21:58:29 GMT
From: killer!pollux!ti-csl!mips!gateley@eddie.mit.edu  (John Gateley)
Organization: TI Computer Science Center, Dallas
Subject: Re: self-replicating code
Message-Id: <60753@ti-csl.CSNET>
References: <8810111207.AA15692@BLOOM-BEACON.MIT.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

In article <8810111207.AA15692@BLOOM-BEACON.MIT.EDU> STCS8004%IRUCCVAX.UCC.IE@MITVMA.MIT.EDU ("G.OULSNAM") writes:
>If one  has a normal-order evaluator  in Scheme rather than  an applicative
>order one then the simplest self-replicating lambda expression is
>
>                  ((lambda (x) (x x)) (lambda (x) (x x)))
>
>since the  argument expression is substituted  without being evaluated, but
>loops forever with applicative order.
[rest of derivation]
>Any comments?
>Gordon Oulsnam

I did not try to follow the rest of the derivation. Your first statement
is incorrect. The expression is an infinite loop in both normal and
applicative order evaluation. Also, the problem is even more complex
than normal order/applicative order. Scheme is a by-value system, which means
that

(lambda (x) (infinite-loop))

terminates in Scheme, but not in a by name system (such as the lambda calc).
I could not think of the smallest normal-order self-replicating code off
the top of my head.

John
gateley@mips.csc.ti.com

Received: from EDDIE.MIT.EDU by MC.LCS.MIT.EDU via Chaosnet; 11 OCT 88  20:19:35 EDT
Received: by EDDIE.MIT.EDU with UUCP with smail2.5 with sendmail-5.45/4.7 id <AA21477@EDDIE.MIT.EDU>; Tue, 11 Oct 88 20:19:04 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA01322@BLOOM-BEACON.MIT.EDU>; Tue, 11 Oct 88 19:56:16 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 10 Oct 88 16:44:00 GMT
From: uicsrd.csrd.uiuc.edu!kwang@uxc.cso.uiuc.edu
Subject: Re: Scheme mailing list
Message-Id: <16800009@uicsrd.csrd.uiuc.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


What is the "scheme mailing adress" for?
It seems there is an address directory used when a new paper/report on scheme
is to be sent to.

Then, would you include my name and address too?

email: kwang@uicsrd.uiuc.edu

address: Kwangkeun Yi
         Center for Supercomputing Research & Development
	 305 Talbot Lab. 104 S.Wright st.
         Urbana, IL 61801-2932

Thankyou very much, -Kwangkeun

         

Received: from EDDIE.MIT.EDU by MC.LCS.MIT.EDU via Chaosnet; 11 OCT 88  19:19:13 EDT
Received: by EDDIE.MIT.EDU with UUCP with smail2.5 with sendmail-5.45/4.7 id <AA20412@EDDIE.MIT.EDU>; Tue, 11 Oct 88 19:18:42 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA29975@BLOOM-BEACON.MIT.EDU>; Tue, 11 Oct 88 18:55:18 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 11 Oct 88 22:24:52 GMT
From: sun.soe!sun.soe.clarkson.edu!gary@tcgould.tn.cornell.edu  (Gary Levin)
Organization: Clarkson University
Subject: Re: self reproducing code
Message-Id: <GARY.88Oct11182452@milo.mcs.clarkson.edu>
References: <10500.8810101439@subnode.aiai.ed.ac.uk>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

A non-trivial expression must be a list of at least 2 elements, so
let's guess that our solution looks like:

	( ____________  ___________ )

The first blank must be a lambda expression if we are to avoid the
necessity of defining a function outside of our solution.  (Which
would violate the self-reproducing aspect to some extent.)

	( (lambda (x) ________ ) ____________ )

The choice of the name ``x'' was arbitrary.  The choice of one
argument followed from the assumption of a two element list.  The body
of the lambda expression must return a two element list, if we are to
re-produce the original input.  There are different choices possible;
I'll choose 

	( (lambda (x) (list _____ _____ )) ___________ )

The argument might as well be quoted, otherwise we need to delve
deeper into the expression.  This then determines some of the second
argument to ``list''.

	( (lambda (x) (list _1_ (list (quote quote) _2_ ))) (quote _3_ ) )

Now comes the ``magic'' part.  Notice that whatever is written in _3_,
we can make the second element of our result match by replacing _2_ by x.

	( (lambda (x) (list _1_ (list (quote quote) x ))) (quote _3_ ) )
yields  ( value_of_1_                                     (quote _3_ ) )

We can now use ``x'' for _1_, which let's us determine the value_of_1_
by our choice of _3_.  The solution follows immediately.

	( (lambda (x) (list x (list (quote quote) x )))
          (quote (lambda (x) (list x (list (quote quote) x ))) ) )

The logic of the derivation makes this easy to remember/reconstruct.
--

-----
Gary Levin/Dept of Math & CS/Clarkson Univ/Potsdam, NY 13676/(315) 268-2384
BitNet: gary@clutx   Internet: gary@clutx.clarkson.edu

Received: from NSS.Cs.Ucl.AC.UK (TCP 20012204403) by MC.LCS.MIT.EDU 11 Oct 88 10:53:58 EDT
Received: from aiai.edinburgh.ac.uk by NSS.Cs.Ucl.AC.UK   via Janet with NIFTP
           id aa03181; 10 Oct 88 15:39 BST
Date: Mon, 10 Oct 88 15:39:36 BST
Message-Id: <10500.8810101439@subnode.aiai.ed.ac.uk>
From: Jeff Dalton <jeff%aiai.edinburgh.ac.uk@NSS.Cs.Ucl.AC.UK>
Subject: Re: self reproducing code
To: scheme@mc.lcs.mit.edu

Here's one I wrote a while ago using the fairly standard technique
of having some data that looks pretty much like the code that uses
the data to reconstruct the data and the code.

;;; Self-reproducing function

(defun v ()
  (let ((m '(subst m
		   '**
		   '(defun v () (let ((m '**)) **)))))
    (subst m
	   '**
	   '(defun v () (let ((m '**)) **)))))

-- Jeff

Received: from MITVMA.MIT.EDU (TCP 2227000003) by MC.LCS.MIT.EDU 11 Oct 88 07:15:39 EDT
Received: from MITVMA.MIT.EDU by MITVMA.MIT.EDU (IBM VM SMTP R1.1) with BSMTP id 1995; Tue, 11 Oct 88 07:13:31 EDT
Received: from IRUCCIBM by MITVMA.MIT.EDU (Mailer X1.25) with BSMTP id 1994;
 Tue, 11 Oct 88 07:13:29 EDT
Received: from IRUCCVAX.UCC.IE by IRUCCIBM (Mailer X1.25) with BSMTP id 0193;
 Mon, 10 Oct 88 15:45:35 IST
Date: Mon, 10 Oct 88 15:48 GMT
From: "G.OULSNAM" <STCS8004%IRUCCVAX.UCC.IE@MITVMA.MIT.EDU>
Subject: self-replicating code
To: SCHEME@MC.LCS.MIT.EDU
X-VMS-To: SCHEME

Various respondents  to the question  of self-replicating anonymous  lambda
expressions have given  us solutions, but no derivations.  I hope therefore
that the following contribution might be of interest.

If one  has a normal-order evaluator  in Scheme rather than  an applicative
order one then the simplest self-replicating lambda expression is

                  ((lambda (x) (x x)) (lambda (x) (x x)))

since the  argument expression is substituted  without being evaluated, but
loops forever with applicative order.

Any approach to generating self-replication in applicative order evaluators
must therefore include emulation of  normal-order evaluation. Consider as a
first attempt:
               (define f (lambda (x) (list 'f x)))

This doesn't quite work  because the x in the list will  be replaced by its
value.  So a better attempt is:

          (define f (lambda (x) (list 'f <reconstruction-of-x>)))

As a first step towards eliminating the  recursive use of f, it makes sense
to pass f an argument that will  evaluate to the lambda expression for f at
the 'f position, but will not itself (the argument that is) be evaluated to
f.  The insight for this comes by recognizing that ((lambda () <body>))
evaluates to <body>.  This suggests that f be recast to the form:

(define f (lambda (x) (list (x) <reconstruction-of-x>)))

and that  it be passed  the argument:  (lambda  () 'f). (This  is where the
normal-order evaluation is emulated.)

The reconstruction of x can now be accomplished to give for f:

         (define f (lambda (x) (list (x) (list 'lambda '() 'f))))

followed again by the elimination of 'f to yield:

(define f
   (lambda (x)
      (list (x)
            (list 'lambda '() (list 'quote (x))))))

It can be verified that:

> (f (lambda () 'f)
(f (lambda () 'f)
>

Elimination of  the define statement  is now straightforward,  to yield the
required anonymous self-replicating expression:

    ((lambda (x)
        (list (x)
              (list 'lambda '() (list 'quote (x)))))
     (lambda ()
        '(lambda (x)
            (list (x)
                  (list 'lambda '() (list 'quote (x)))))))

Any comments?

Gordon Oulsnam


Received: from mimsy.umd.edu (TCP 20002100010) by MC.LCS.MIT.EDU 10 Oct 88 10:07:02 EDT
Received: by mimsy.umd.edu (5.58/4.7)
	id AA23432; Mon, 10 Oct 88 10:04:25 EDT
Date: Mon, 10 Oct 88 10:04:25 EDT
From: C. Terry Ireland <cti@mimsy.umd.edu>
Message-Id: <8810101404.AA23432@mimsy.umd.edu>
To: Scheme@mc.lcs.mit.edu
Subject: Scheme Mailing List

Please add my name to the Scheme mailing list.  If paper mail is ever
used, my address is

Terry Ireland
10023 Menlo Avenue
Silver Spring, MD  20910

Thank you.

T

Received: from IBM.COM (TCP 30001235007) by MC.LCS.MIT.EDU 10 Oct 88 09:24:42 EDT
Date: 10 Oct 88 09:06:52 EDT
From: Cyril Alberga <ALBERGA@ibm.com>
To:   scheme@mc.lcs.mit.edu
Message-Id: <101088.090653.alberga@ibm.com>
Subject: Self replicating code

Here is a brute-force expression which prints itself.  This was in LISP370,
circa 1978.

 (PRINT
   ( (LAMBDA (X Y)
       (SEQ
         (RPLACA (CDAR (CDDADR X)) (COPY Y))
         (RPLACA (CDADR (CADADR X)) (COPY Y))
         (EXIT X) ) )
     (COPY
       "(PRINT
         ( (LAMBDA (X Y)
             (SEQ
               (RPLACA (CDAR (CDDADR X)) (COPY Y))
               (RPLACA (CDADR (CADADR X)) (COPY Y))
               (EXIT X) ) ) (COPY "NIL) "NIL ) ) )
     "(PRINT
       ( (LAMBDA (X Y)
           (SEQ
             (RPLACA (CDAR (CDDADR X)) (COPY Y))
             (RPLACA (CDADR (CADADR X)) (COPY Y))
             (EXIT X) ) ) (COPY "NIL) "NIL ) ) ) )


The uses of copy were to keep it from modifying itself.
Obviously, shared sub-structure could be used to shorten the
representation.

Cyril N. Alberga

Received: from mimsy.umd.edu (TCP 20002100010) by MC.LCS.MIT.EDU  9 Oct 88 16:25:46 EDT
Received: by mimsy.umd.edu (5.58/4.7)
	id AA11729; Sun, 9 Oct 88 16:23:19 EDT
Date: Sun, 9 Oct 88 16:23:19 EDT
From: C. Terry Ireland <cti@mimsy.umd.edu>
Message-Id: <8810092023.AA11729@mimsy.umd.edu>
To: scheme@mc.lcs.mit.edu
Subject: Scheme mailing list
Cc: cti@mimsy.umd.edu, norm@mimsy.umd.edu

Please add my name to the scheme mailing address.  If paper mail is
ever used, my address is:

Terry Ireland
10023 Menlo Avenue
Silver Spring, MD  20910

Thank you.

T

Received: from EDDIE.MIT.EDU by MC.LCS.MIT.EDU via Chaosnet; 9 OCT 88  10:34:22 EDT
Received: by EDDIE.MIT.EDU with UUCP with smail2.5 with sendmail-5.45/4.7 id <AA03068@EDDIE.MIT.EDU>; Sun, 9 Oct 88 10:33:01 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA26343@BLOOM-BEACON.MIT.EDU>; Sun, 9 Oct 88 10:13:32 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 8 Oct 88 18:59:05 GMT
From: att!chinet!mcdchg!clyde!watmath!utgpu!utzoo!yunexus!oz@bloom-beacon.mit.edu  (Ozan Yigit)
Organization: York U. Computing Services - Magic Group
Subject: Re: Unwind-Protect and Continuations (Ref)
Message-Id: <867@yunexus.UUCP>
References: <344@scaup.cl.cam.ac.uk>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

In article <344@scaup.cl.cam.ac.uk> pmcy@cl.cam.ac.uk (Phillip Yelland) writes:
>There's a paper from Indiana U. entitled "Constraining Control", by Wand and
>Friedman (I think)...

[from the scheme bibliography (latest will be out real soon)]
	
	%A Daniel P. Friedman
	%A Christopher T. Haynes
	%T Constraining Control
	%J Proceedings of the Twelfth Annual Symposium on Principles of 
	Programming Languages
	%C New Orleans, LA.
	%P 245-254
	%I ACM
	%D January 1985
	
oz
-- 
Reflections are 	        	| Usenet: ...!utzoo!yunexus!oz
images of tarnished aspirations.	|   ...uunet!mnetor!yunexus!oz
			RACTER		| Bitnet: oz@[yulibra|yuyetti]
[an Artifically Insane program.]	| Phonet: +1 416 736-5257x3976

Received: from STONY-BROOK.SCRC.Symbolics.COM (TCP 20024224620) by MC.LCS.MIT.EDU  8 Oct 88 22:55:06 EDT
Received: from BOBOLINK.SCRC.Symbolics.COM by STONY-BROOK.SCRC.Symbolics.COM via CHAOS with CHAOS-MAIL id 473424; Sat 8-Oct-88 22:51:52 EDT
Date: Sat, 8 Oct 88 22:51 EDT
From: Kent M Pitman <KMP@STONY-BROOK.SCRC.Symbolics.COM>
Subject: Re: self reproducing code
To: mcvax!diku.dk!danvy@uunet.UU.NET
cc: Alan@ai.ai.mit.edu, carr%car@cs.utah.edu,
    mohammad%hpcllz2@sde.hp.com, pass@cs.utah.edu, scheme@mc.lcs.mit.edu,
    shebs@apple.apple.com
In-Reply-To: <8810081615.AA14951@diku.dk>
Message-ID: <881008225128.4.KMP@BOBOLINK.SCRC.Symbolics.COM>

() by itself is certainly cute, but I don't think it counts.
It's not -constructing- a program, it's just -returning- one.
All self-evaluating forms have the same property, after all.
{{1, 2, 3, ...}, {#t, #f}, ...}

Another borderline case, that comes up in Common Lisp, is:
 #1='#1#
But depending on your model of what QUOTE does, that's just
self-evaluating, too, and doesn't count either. Btw, don't
try to look at the result without setting *print-circle* or
*print-level* appropriately.

Received: from uunet.UU.NET (TCP 30003106601) by MC.LCS.MIT.EDU  8 Oct 88 17:54:32 EDT
Received: from mcvax.UUCP by uunet.UU.NET (5.59/1.14) with UUCP 
	id AA22266; Sat, 8 Oct 88 17:53:02 EDT
Received: by mcvax.cwi.nl; Sat, 8 Oct 88 22:23:48 +0100 (MET)
Received: from diku.dk
	by dkuug.dk (3.2/smail2.5/ease)
	id AA07492; Sat, 8 Oct 88 17:15:36 +0100
Received: by diku.dk (5.51/smail2.5/ease)
	id AA14951; Sat, 8 Oct 88 17:15:22 +0100
Date:  Sat, 8 Oct 88 17:15:22 +0100
From: mcvax!diku.dk!danvy@uunet.UU.NET (Olivier Danvy)
Message-Id:  <8810081615.AA14951@diku.dk>
To: Alan@ai.ai.mit.edu, carr%car@cs.utah.edu
Subject: Re: self reproducing code
Cc: carr%car@cs.utah.edu, mohammad%hpcllz2@sde.hp.com, pass@cs.utah.edu,
        scheme@mc.lcs.mit.edu, shebs@apple.apple.com

Chez Scheme Version 2.0.3 Copyright (c) 1987 R. Kent Dybvig

> ()
()
> 

	This one is pretty small :-)
	It is illegal according to the r3rs's BNF for Scheme, though.

				Olivier

Received: from EDDIE.MIT.EDU by MC.LCS.MIT.EDU via Chaosnet; 8 OCT 88  03:20:18 EDT
Received: by EDDIE.MIT.EDU with UUCP with smail2.5 with sendmail-5.45/4.7 id <AA09860@EDDIE.MIT.EDU>; Sat, 8 Oct 88 03:18:58 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA21642@BLOOM-BEACON.MIT.EDU>; Sat, 8 Oct 88 02:58:14 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 3 Oct 88 14:02:14 GMT
From: mcvax!ukc!cam-cl!pmcy@uunet.uu.net  (Phillip Yelland on jenny)
Organization: U of Cambridge Comp Lab, UK
Subject: re: Unwind-Protect and Continuations
Message-Id: <344@scaup.cl.cam.ac.uk>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu



There's a paper from Indiana U. entitled "Constraining Control", by Wand and
Friedman (I think), which shows how unwind-protect and similar facilities may
be coded using 'first-class' continuations.
If there's interest, I can go away and look it up in greater detail.
--Phil

Received: from murren.ai.mit.edu (TCP 2212600263) by MC.LCS.MIT.EDU  7 Oct 88 21:50:20 EDT
Received: by murren.ai.mit.edu (5.59/1.5)
	id AA14603; Fri, 7 Oct 88 21:27:27 EDT
Date: Fri, 7 Oct 88 21:27:27 EDT
From: hal@murren.ai.mit.edu (Hal Abelson)
Message-Id: <8810080127.AA14603@murren.ai.mit.edu>
To: arpanet-bboard@mc.lcs.mit.edu, lisp-forum@mc.lcs.mit.edu,
        scheme@mc.lcs.mit.edu
Subject: 1989 Conference on Lisp and History of Lisp -- Advance Notice
Reply-To: hal@zurich.ai.mit.edu


	       HAPPY 30TH BIRTHDAY FOR LISP CONFERENCE

In recognition of the 30th birthday of the Lisp programming language,
the ACM is sponsoring a special conference on Lisp and the history of
Lisp, to be held at MIT, November 28 through December 1 1989.

Part of the conference will deal with technical issues of current
interest to the Lisp community (similar to Lisp presentations at the
Lisp and Functional Programming conferences).  There also be sessions
devoted to historical papers, evolution of Lisp implementation
technology, perspectives on the past and future of Lisp, and so on.
A formal call for abstracts (which will be due next May) will appear
in a few months.

In the meantime, we would like to solicit your advice about
appropriate special events for this conference.  For example, people
have suggested presenting awards for "distinguished contributions to
Lisp."  Are there particular panel discussions you would like to see?
Or other events you think would be appropriate for a birthday
celebration?

Please mail us your suggestions.

For the program committee:

Dick Gabriel
Guy Steele
Jan Zubkoff
Hal Abelson

send suggestions to 

Hal Abelson
MIT
545 Technology Square
Cambridge, MA 02129

hal@zurich.ai.mit.edu



Received: from EDDIE.MIT.EDU by MC.LCS.MIT.EDU via Chaosnet; 7 OCT 88  21:45:57 EDT
Received: by EDDIE.MIT.EDU with UUCP with smail2.5 with sendmail-5.45/4.7 id <AA04531@EDDIE.MIT.EDU>; Fri, 7 Oct 88 21:44:39 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA15419@BLOOM-BEACON.MIT.EDU>; Fri, 7 Oct 88 21:30:00 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 8 Oct 88 00:00:04 GMT
From: spdcc!ima!johnl@bloom-beacon.mit.edu  (John R. Levine)
Organization: Not much
Subject: Scheme for 386/ix?
Message-Id: <2752@ima.ima.isc.com>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

Can anybody point me at an implementation of Scheme that runs or could be
made to run on an 80386 box running 386/ix (System V Unix) ?

TIA,
-- 
John R. Levine, IECC, PO Box 349, Cambridge MA 02238-0349, +1 617 492 3869
{ bbn | think | decvax | harvard | yale }!ima!johnl, Levine@YALE.something
Rome fell, Babylon fell, Scarsdale will have its turn.  -G. B. Shaw

Received: from IVORY.S4CC.Symbolics.COM (TCP 20024231401) by MC.LCS.MIT.EDU  7 Oct 88 17:09:37 EDT
Received: from HALEAKALA.S4CC.Symbolics.COM by IVORY.S4CC.Symbolics.COM via CHAOS with CHAOS-MAIL id 194006; Fri 7-Oct-88 17:04:11 EDT
Date: Fri, 7 Oct 88 17:04 EDT
From: stever@Riverside.SCRC.Symbolics.COM
Sender: Zippy@QUABBIN.SCRC.Symbolics.COM
Subject: self reproducing code
To: Harold Carr <carr%car@cs.utah.edu>
cc: pass@cs.utah.edu, scheme@mc.lcs.mit.edu, shebs@apple.apple.com, mohammad%hpcllz2@sde.hp.com
In-Reply-To: <8810071930.AA25143@car.utah.edu>
Message-ID: <19881007210401.2.LISP-MACHINE@HALEAKALA.S4CC.Symbolics.COM>

    Date: Fri, 7 Oct 88 13:30:30 MDT
    From: carr%car@cs.utah.edu (Harold Carr)

    It was an anonymous lambda application which, when evaluated in Common
    Lisp, would return the exact same for, which could then be evaluated
    again, always returning the same anonymous application.

((LAMBDA (TEMPLATE)
   (SETF (SECOND (SECOND TEMPLATE)) (COPY-TREE TEMPLATE))
   TEMPLATE)
 '((LAMBDA (TEMPLATE)
     (SETF (SECOND (SECOND TEMPLATE)) (COPY-TREE TEMPLATE))
     TEMPLATE)
   (QUOTE *PLACEHOLDER*)))

This will work.  I'm pretty sure there's a more elegant way to do it.
If anyone send you one, I'd appreciate a copy.

Thanks,

Stephen

Received: from cs.utah.edu (TCP 20033402025) by MC.LCS.MIT.EDU  7 Oct 88 16:23:24 EDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA07777; Fri, 7 Oct 88 14:19:30 MDT
Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA25193; Fri, 7 Oct 88 14:19:26 MDT
Date: Fri, 7 Oct 88 14:19:26 MDT
From: carr%car@cs.utah.edu (Harold Carr)
Message-Id: <8810072019.AA25193@car.utah.edu>
To: Alan@ai.ai.mit.edu
Cc: carr%car@cs.utah.edu, pass@cs.utah.edu, scheme@mc.lcs.mit.edu,
        shebs@apple.apple.com, mohammad%hpcllz2@sde.hp.com
In-Reply-To: Alan Bawden's message of Fri, 7 Oct 88 16:00 EDT <19881007200040.6.ALAN@QUESTION-AUTHORITY.AI.MIT.EDU>
Subject: Re: self reproducing code

Thanks for the self-reproducing code.  Since yours is different from
what I was looking for it prompts me to ask of everyone: send me any
examples you have of self-reproducing code.  I'd like to make a
collection of them.  If possible, cite the author as Alan has done.

Thanks, Harold

ps:  I don't care whether the code is interlisp, cl, psl, scheme, not
quite legal - just so it does (or has) run on some system that does
(or has) exists.


Received: from REAGAN.AI.MIT.EDU (CHAOS 13065) by MC.LCS.MIT.EDU  7 Oct 88 16:01:33 EDT
Received: from QUESTION-AUTHORITY.AI.MIT.EDU by REAGAN.AI.MIT.EDU via CHAOS with CHAOS-MAIL id 141482; Fri 7-Oct-88 16:00:51 EDT
Date: Fri, 7 Oct 88 16:00 EDT
From: Alan Bawden <Alan@AI.AI.MIT.EDU>
Subject: self reproducing code
To: carr%car@cs.utah.edu
cc: pass@cs.utah.edu, scheme@MC.LCS.MIT.EDU, shebs@apple.apple.com, mohammad%hpcllz2@sde.hp.com
In-Reply-To: <8810071930.AA25143@car.utah.edu>
Message-ID: <19881007200040.6.ALAN@QUESTION-AUTHORITY.AI.MIT.EDU>

    Date: Fri, 7 Oct 88 13:30:30 MDT
    From: carr%car@cs.utah.edu (Harold Carr)
    A couple of years ago I found an example of self reproducing code....
    in Common Lisp, ...

My favorite example:

  (let ((let '`(let ((let ',let))
		 ,let)))
    `(let ((let ',let))
       ,let))

I believe that Mike McMahon is the author of this variant.  It is
unfortunate that this isn't standard Scheme because of the use of 
LET as an identifier...

Received: from cs.utah.edu (TCP 20033402025) by MC.LCS.MIT.EDU  7 Oct 88 15:59:48 EDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA06715; Fri, 7 Oct 88 13:56:00 MDT
Received: by morgan.utah.edu (5.54/utah-2.0-leaf)
	id AA04067; Fri, 7 Oct 88 13:55:56 MDT
Date: Fri, 7 Oct 88 13:55:56 MDT
From: stoller%morgan@cs.utah.edu (Leigh B. Stoller)
Message-Id: <8810071955.AA04067@morgan.utah.edu>
To: carr%car@cs.utah.edu
Cc: pass@cs.utah.edu, scheme@mc.lcs.mit.edu, shebs@apple.apple.com,
        mohammad%hpcllz2@sde.hp.com
In-Reply-To: Harold Carr's message of Fri, 7 Oct 88 13:30:30 MDT <8810071930.AA25143@car.utah.edu>
Subject: Re: self reproducing code

Date: Tue, 19 May 87 15:39:42 MDT
From: carr@orion.utah.edu (Harold Carr)
To: kessler@orion.utah.edu
Subject: Fun stuff
Cc: pass@orion.utah.edu

Here's one everyone has already probably seen, but I forgot about it.
What does the following evaluate to?


((lambda (x) (list x (list (quote quote) x)))
 (quote (lambda (x) (list x (list (quote quote) x)))))


Great problem for Bob's Lisp class.

Harold

Received: from cs.utah.edu (TCP 20033402025) by MC.LCS.MIT.EDU  7 Oct 88 15:32:25 EDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA05469; Fri, 7 Oct 88 13:30:43 MDT
Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA25143; Fri, 7 Oct 88 13:30:30 MDT
Date: Fri, 7 Oct 88 13:30:30 MDT
From: carr%car@cs.utah.edu (Harold Carr)
Message-Id: <8810071930.AA25143@car.utah.edu>
To: pass@cs.utah.edu
Cc: scheme@mc.lcs.mit.edu, shebs@apple.apple.com, mohammad%hpcllz2@sde.hp.com
Subject: self reproducing code

A couple of years ago I found an example of self reproducing code.
It looked something like:

 ((lambda (lambda) (list (quote (lambda ....


It was an anonymous lambda application which, when evaluated in Common
Lisp, would return the exact same for, which could then be evaluated
again, always returning the same anonymous application.

If anyone has this code please send it to me.

Thanks, Harold

Received: from iuvax.cs.indiana.edu (TCP 30003147300) by MC.LCS.MIT.EDU  4 Oct 88 18:22:58 EDT
Received: by iuvax.cs.indiana.edu (5.54/1.16) 
Date: Tue, 4 Oct 88 17:21:02 EST
From: Chris Haynes <chaynes@iuvax.cs.indiana.edu>
To: rrrs-authors@mc.lcs.mit.edu, scheme@mc.lcs.mit.edu
Subject: scheme-standard mailing list

The mailing list 

	scheme-standard@wheaties.ai.mit.edu

has been created for technical and administrative communication
within the IEEE Scheme standardization Working Group, which is 
open to all interested parties.  Administrative communication related
to this list, including requests for membership, should be addressed to

	scheme-standard-request@wheaties.ai.mit.edu

-- Chris Haynes (chaynes@iuvax.cs.indiana.edu)

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU  4 Oct 88 06:09:07 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA01661@BLOOM-BEACON.MIT.EDU>; Tue, 4 Oct 88 06:07:31 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 3 Oct 88 22:20:36 GMT
From: uoregon!will@beaver.cs.washington.edu  (William Clinger)
Organization: University of Oregon, Computer Science, Eugene OR
Subject: Re: Re : unwind-protect
Message-Id: <2917@uoregon.uoregon.edu>
References: <16407@shemp.CS.UCLA.EDU>, <19881003111852.6.MAEDA@PELE.ACA.MCC.COM>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

>Hmm.  How would unwind-protect be expressed with just call/cc?

UNWIND-PROTECT is trivial to implement in terms of DYNAMIC-WIND, which can
be implemented in terms of CALL-WITH-CURRENT-CONTINUATION provided the
Scheme system permits CALL-WITH-CURRENT-CONTINUATION to be redefined,
uses close-coded calls to CALL-WITH-CURRENT-CONTINUATION for all captures
of a continuation, and contains no pre-captured continuations.

An implementation appears in Haynes and Friedman, Embedding Continuations
in Procedural Objects, TOPLAS 9, 4 (October 1987), pages 582-598.

Peace,
William Clinger

Received: from MCC.COM (TCP 1200600076) by MC.LCS.MIT.EDU  3 Oct 88 07:20:12 EDT
Received: from PELE.ACA.MCC.COM (PELE.ACA.MCC.COM.#Chaos) by MCC.#Chaos with Chaos/SMTP; Mon 3 Oct 88 06:18:57-CDT
Date: Mon, 3 Oct 88 06:18 CDT
From: Christopher Maeda <maeda@MCC.COM>
Subject: Re : unwind-protect
To: pierce@locus.ucla.edu
cc: scheme@mc.lcs.mit.edu
In-Reply-To: <16407@shemp.CS.UCLA.EDU>
Message-ID: <19881003111852.6.MAEDA@PELE.ACA.MCC.COM>

    Date: 3 Oct 88 07:08:04 GMT
    From: pierce@locus.ucla.edu


    ** Subject: unwind-protect
    ** Message-ID: <10180@eddie.MIT.EDU>
    ** Date: 3 Oct 88 03:41:57 GMT
    ** Sender: uucp@eddie.MIT.EDU
    ** Reply-To: jbs@fenchurch.MIT.EDU (Jeff Siegal)
    ** Organization: MIT EE/CS Computer Facilities, Cambridge, MA
    ** Lines: 5
    ** 
    ** How can one do something like UNWIND-PROTECT in Scheme?  Is the
    ** concept completely ill-defined in the presence of first-class
    ** continuations, or is there an idiom which "sometimes works?"
    ** 
    ** Jeff Siegal

    Kent Dybvig's Chez Scheme has what seems to be a much more powerful construct
    called "dynamic-wind".  A brief sketch of its uses is given in Dybvig's
    "The Scheme Programming Language".

    -- Brad Pierce

Hmm.  How would unwind-protect be expressed with just call/cc?

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU  3 Oct 88 04:23:44 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA02296@BLOOM-BEACON.MIT.EDU>; Mon, 3 Oct 88 04:18:51 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 3 Oct 88 07:08:04 GMT
From: pierce@locus.ucla.edu
Organization: UCLA Computer Science Department
Subject: Re : unwind-protect
Message-Id: <16407@shemp.CS.UCLA.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


** Subject: unwind-protect
** Message-ID: <10180@eddie.MIT.EDU>
** Date: 3 Oct 88 03:41:57 GMT
** Sender: uucp@eddie.MIT.EDU
** Reply-To: jbs@fenchurch.MIT.EDU (Jeff Siegal)
** Organization: MIT EE/CS Computer Facilities, Cambridge, MA
** Lines: 5
** 
** How can one do something like UNWIND-PROTECT in Scheme?  Is the
** concept completely ill-defined in the presence of first-class
** continuations, or is there an idiom which "sometimes works?"
** 
** Jeff Siegal

Kent Dybvig's Chez Scheme has what seems to be a much more powerful construct
called "dynamic-wind".  A brief sketch of its uses is given in Dybvig's
"The Scheme Programming Language".

-- Brad Pierce

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU  3 Oct 88 02:53:46 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA00683@BLOOM-BEACON.MIT.EDU>; Mon, 3 Oct 88 02:42:00 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 3 Oct 88 03:41:57 GMT
From: fenchurch.mit.edu!jbs@eddie.mit.edu  (Jeff Siegal)
Organization: MIT EE/CS Computer Facilities, Cambridge, MA
Subject: unwind-protect
Message-Id: <10180@eddie.MIT.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

How can one do something like UNWIND-PROTECT in Scheme?  Is the
concept completely ill-defined in the presence of first-class
continuations, or is there an idiom which "sometimes works?"

Jeff Siegal

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU  2 Oct 88 19:40:17 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA27450@BLOOM-BEACON.MIT.EDU>; Sun, 2 Oct 88 19:36:03 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 1 Oct 88 17:05:00 GMT
From: uicbert.eecs.uic.edu!wilson@uxc.cso.uiuc.edu
Subject: dynamic compilation/optimization II
Message-Id: <82000001@uicbert.eecs.uic.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu



(Please excuse if this redunds;  I tried to post it before, but it didn't 
appear to make it.)

There seems to be some interest out there, so here's a bit more detail
on those dynamic compilation ideas:

*  When a chunk of code is dynamically compiled (not optimized yet), it
   is given a little prologue that increments a count every time it is
   executed.  When the count exceeds a threshold, the code is recompiled
   with a much higher level of optimization.  The most optimized code
   would not have this prologue to slow it down, since it wouldn't
   need it anymore.  Highly optimized code might be less subject
   to being discarded as well.

*  The business about noticing common types of arguments and compiling
   specially optimized versions could be handled similarly.  A little
   prologue would check every nth execution for types, rather than
   every execution.  Most times, it would just increment a counter.
   Very highly optimized code could forego the checking and counting
   entirely, assuming it had already learned all of the likely argument
   type combinations.  (Actually, every nth time it would change n
   a little to avoid rhythmic problems.)

*  Something like this might also be useful for trace scheduling.
   Every now and then you execute an "instrumented" version of the
   code that collects data on common execution patterns.

Any comments?  Does anybody know of any systems that use dynamic
compilation?  I know a couple of Smalltalks do it, and now
I'm told that MIT Scheme has a somewhat  similar cache-with-
dependencies mechanism for variable lookups.

Does anybody have any opinions on the expected efficiency of such a system?
It seems to me that it could be quite good.  It could also be advantageous
in that it would not optimize a lot of the code.  In particular, it could
keep things in a more debuggable form than something that optimizes
more stupidly, without much performance penalty.  (Especially since
frequently modified things will never get heaviliy optimized.)

I only have a few references on dynamic compilation, none of which go into
anything advanced.  If you have others, please send them to me and I'll
pass them on to interested parties.

(Besides the ones in Andy Gordon's posting, there was "An Evaluation
of Throw-away Compiling" in Software Practice and Experience, vol. 13
(1983), pp. 241-249.)

I have not gotten any responses indicating that dynamic compilation has
been used to control levels of optimization or to recompile when
optimizer assumptions are violated.


Paul R. Wilson                         
Human-Computer Interaction Laboratory
U. of Illin. at C. EECS Dept. (M/C 154)   wilson%uicbert@uxc.cso.uiuc.edu
Box 4348   Chicago,IL 60680 

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU  2 Oct 88 19:40:03 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA27483@BLOOM-BEACON.MIT.EDU>; Sun, 2 Oct 88 19:36:54 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 1 Oct 88 17:27:00 GMT
From: uicbert.eecs.uic.edu!wilson@uxc.cso.uiuc.edu
Subject: example of dynamic optimization
Message-Id: <82000002@uicbert.eecs.uic.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu




To motivate the discussion of dynamic optimization, here's a simple
example of why I think it might be worthwhile.

Suppose you have a language in which you can have homogeneous collections
like array-of-integer.  (Or an implementation that lets you declare them.)
Suppose also that the language is basically dynamically typed, and that
the declared types are attached to the objects at runtime.  So an array
of integer would have a header saying so.

Now suppose we define a routine that processes collections, looping to
apply some operation to its elements.  A dynamic optimizing system
would generate a generic version of the code that checks the types
of the arguments and then dispatches to an optimized version for those
types.  If it has never seen that combination of types before, a new
version is created on the fly.

So the first time this generic code sees an array-of-integer, it compiles
a version of the looping routine that assumes each element is an integer,
omitting tag checks, unrolling the loop, etc.

The generic code must always check the collection's type when it is
executed, but the compiled code it dispatches to needn't.  (If it's
not a homogeneous collection, it simply dispatches to a normal
version with type checking.)

The nice thing about this is that the code is still generic from the
programmer's point of view, and type checking is not abandoned.  (Unlike
systems in which declarations tell the compiler to make assumptions
at a particular point in the code.)

My guess is that for most programs, most routines are only ever given
one kind of argument, so there wouldn't be an explosion of versions.
(You can always use a cache and throw away disused versions.)

At least for this example, the optimization would be transparent and
safe.  If somebody changes (at another point in the code) the type
of some object that is passed to the optimized routine, the dynamic
check will ensure that an appropriate version is generated.

Now the question is how general this system could be, using more
sophisticated type inference than recognizing homogeneous collections.
And can it be combined with nifty trace-scheduling techniques to 
precompute paths through often-executed chunks of code and seriously
optimize them?

Paul R. Wilson                         
Human-Computer Interaction Laboratory
U. of Illin. at C. EECS Dept. (M/C 154)   wilson%uicbert@uxc.cso.uiuc.edu
Box 4348   Chicago,IL 60680 

Received: from bu-it.BU.EDU (TCP 20061201050) by MC.LCS.MIT.EDU  2 Oct 88 10:02:03 EDT
Received: from BUCSF.BU.EDU by bu-it.BU.EDU (5.58/4.7)
	id AA02487; Sun, 2 Oct 88 10:01:09 EDT
Return-Path: <gjc@bucsf.bu.edu>
Received: by bucsf (4.12/4.7)
	id AA13715; Sun, 2 Oct 88 10:00:39 edt
Date: Sun, 2 Oct 88 10:00:39 edt
From: gjc%bucsf.BU.EDU@bu-it.bu.edu (George J. Carrette)
Message-Id: <8810021400.AA13715@bucsf>
To: mjk@planets.risc.com
Cc: scheme@mc.lcs.mit.edu
Subject: Plea for Scheme Code

The mit cscheme implementation comes with quite a bit of scheme code
you can try to run in parallel. There must be a lot of dispatching and
data conversion in the arithmetic/bignum code, there must be sorting code,
syntax conversion routines etc.

You could also look at using the compiler from the yale T system. It has
all sorts of passes that do interesting things with list structure.

-gjc

Received: from XX.LCS.MIT.EDU (CHAOS 2420) by MC.LCS.MIT.EDU  2 Oct 88 01:56:36 EDT
Received: from risc.com by XX.LCS.MIT.EDU with TCP/SMTP; Wed 28 Sep 88 16:36:55-EDT
Received: from planets.risc.com (jupiter.risc.com) by risc.com (4.0/SMI-DDN)
	id AA06488; Wed, 28 Sep 88 13:35:09 PDT
Received: by planets.risc.com (3.2/SMI-3.2)
	id AA18434; Wed, 28 Sep 88 13:33:02 PDT
Date: Wed, 28 Sep 88 13:33:02 PDT
From: mjk@planets.risc.com (Morry Katz)
Message-Id: <8809282033.AA18434@planets.risc.com>
To: larus@ginger.Berkeley.EDU
Cc: scheme@mc.lcs.mit.edu, comp-lang-scheme@ucbvax.Berkeley.EDU
In-Reply-To: James Larus's message of Thu, 15 Sep 88 16:14:43 PDT <8809152314.AA03895@paris.Berkeley.EDU>
Subject: Plea for Scheme Code

   From: larus%paris.Berkeley.EDU@ginger.Berkeley.EDU (James Larus)
   Reply-To: larus@ginger.Berkeley.EDU
   Date: Thu, 15 Sep 88 16:14:43 PDT

   I am looking for some small-to-medium sized Scheme programs as test
   cases for my dissertation research.  These programs should have
   side-effect producing operations and should do something "real" (i.e.,
   fib, tak, etc. need not apply).

   My research is studying how to restructure Lisp programs for
   concurrent execution.  For more details, see [1].  Your program
   doesn't need to be inherently parallel, though if you have a copy in a
   parallel dialect, I'd also be interested in it.

   All I offer in exchange for your code is immortality in a footnote
   (they do keep dissertations forever, don't they?).

I have been looking for the same sorts of programs to test my system, with
little sucess.  I would be most appreciative if you would forward any replies
you get to me as well.
					Morry Katz

Received: from XX.LCS.MIT.EDU by MC.LCS.MIT.EDU via Chaosnet; 2 OCT 88  00:33:05 EDT
Received: from uunet.UU.NET by XX.LCS.MIT.EDU with TCP/SMTP; Fri 30 Sep 88 18:21:55-EDT
Received: from mnetor.UUCP by uunet.UU.NET (5.59/1.14) with UUCP 
	id AA08955; Fri, 30 Sep 88 18:08:30 EDT
Received: by mnetor.UUCP (smail2.3)
	id AA23994; 30 Sep 88 17:42:28 EDT (Fri)
Received: by maccs.mcmaster.ca (5.51/SMI-3.2)
	id AA20027; Fri, 30 Sep 88 13:10:39 EDT
Date: Fri, 30 Sep 88 13:10:39 EDT
From: Charlie Root <maccs!root@uunet.UU.NET>
Message-Id: <8809301710.AA20027@maccs.mcmaster.ca>
To: scheme@MC.LCS.MIT.EDU
Subject: Scheme for a Sun 4/280 OS 4.0
Cc: chris@uunet.UU.NET


Is there such a beast? I have compiled mit-scheme on our Sun 4 and it 
works to a certain extent. It has trouble creating the fastload modules
and thus doesn't have a lot of the builtin functions. like (date).

We have a file called rrrs.ytex.13 but don't have ytex. What is ytex and
where can we find it. The key is to get a good copy of the scheme documents
but at the moment that is impossible.

Thanks for any help you can provide
---
Dan Trottier                                            dan@maccs.McMaster.CA
Dept of Computer Science                       ...!uunet!utai!utgpu!maccs!dan
McMaster University                                      (416) 525-9140 x3444

Received: from CUNYVM.CUNY.EDU (TCP 20071000402) by MC.LCS.MIT.EDU 25 Sep 88 15:08:56 EDT
Received: from NORUNIT.BITNET by CUNYVM.CUNY.EDU (IBM VM SMTP R1.1) with BSMTP id 2911; Sun, 25 Sep 88 15:06:19 EDT
Date: Sun, 25 Sep 88 21:07:02 ECT
To: scheme@mc.lcs.mit.edu
From: HANCHE%NORUNIT.BITNET@CUNYVM.CUNY.EDU
Comment: CROSSNET mail via SMTP@INTERBIT
Subject: Re: Status of XScheme

Date: 25 September 1988, 21:05:26 ECT
From: Harald Hanche-Olsen       +47-7-593525         HANCHE   at NORUNIT
To:   scheme@mc.lcs.mit.edu

Recently, Paul Wilson <wilson@UICBERT.EECS.UIC.EDU> asked the following
question:

> A while back I heard something about Dave Betz doing a Scheme.
> They called it XScheme 0.3.  Does anybody know what the status
> of this project is, or any details about the actual code?
> (Is it portable? What machines does it run on?, etc.)

The code is written in reasonably portable C.  I know for sure it runs
on IBM PClones, Macs, and Amigas.  The code is posted and occasionally
being discussed on BIX (Byte Information eXchange).  The latest version
(as far as I know) is *very* preliminary, my copy is version 0.07.  A
handful of bugs and lack of reasonable error messages makes it rather
unsuitable for real work at the moment, but a new and improved version
is rumoured to be in the works (though David Betz has been curiously
silent about it lately).

XScheme is based on a bytecode compiler.  Apart from that, its
distinguishing feature is its object oriented extensions, similar to
those of XLisp.

- Harald Hanche-Olsen       Division of Mathematical Sciences
  hanche@norunit.bitnet     The Norwegian Institute of Technology

Received: from toucan.LCS.MIT.EDU (TCP 2206400272) by MC.LCS.MIT.EDU 24 Sep 88 09:18:04 EDT
Received: by toucan.LCS.MIT.EDU 
	id AA02581; Sat, 24 Sep 88 09:16:41 EDT
Date: Sat, 24 Sep 88 09:16:41 EDT
From: bard@THEORY.lcs.mit.edu
Message-Id: <8809241316.AA02581@toucan.LCS.MIT.EDU>
To: scheme@mc.lcs.mit.edu
Subject: space/time in byte code/native code (was dynamic compilation)


>I don't think reason (1) is very compelling these days, because the size of
>compiled code is not an issue with today's computers...

I disagree, in some contexts.  It certainly matters a lot on my home
computer; some programs won't fit on a floppy.  

Loading time also matters.  If a program like `more' takes a few seconds to
load, it is very annoying.

-- Bard

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 24 Sep 88 06:48:36 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA26964@BLOOM-BEACON.MIT.EDU>; Sat, 24 Sep 88 06:42:38 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 23 Sep 88 23:15:53 GMT
From: uoregon!will@beaver.cs.washington.edu  (William Clinger)
Organization: University of Oregon, Computer Science, Eugene OR
Subject: space/time in byte code/native code (was dynamic compilation)
Message-Id: <2850@uoregon.uoregon.edu>
References: <8809142159.AA28551@uicbert.eecs.uic.edu>, <327@scaup.cl.cam.ac.uk>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

In article <327@scaup.cl.cam.ac.uk> adg@cl.cam.ac.uk (Andy Gordon) writes:
>                          I found on small benchmarks that native code
>was between four and six times bigger than interpreted byte codes, and
>ran between one and seven times faster.

Another data point:  In MacScheme, native code is also four to six times
as large as interpreted byte code, but is two to ten times as fast, with
a factor of four or five being typical.

>There appear to be two reasons for hybrid systems: (1) to give a variable
>time/space tradeoff, i.e., between fast/bulky native code and slow/lean
>interpreted code; (2) to allow fancy interpretive debuggers and tracers
>in the presence of native code.
>
>I don't think reason (1) is very compelling these days, because the size of
>compiled code is not an issue with today's computers...

Here I have to disagree.  On a Macintosh, a factor of five in program size
can easily be the difference between fitting or not fitting on a floppy
disk.  The space required by a program is also a big issue under MultiFinder,
since it determines how many simultaneous applications you can run.  RAM
accounts for about a quarter of the typical Macintosh II system cost, so
five times as much RAM would double the cost.  Similarly for disk space.

I understand why some people don't count Macintoshes and IBM PCs and PS/2s
and their ilk as "today's computers", but I don't think that's realistic.

Peace, Will

Received: from lucid.com (TCP 30006414401) by MC.LCS.MIT.EDU 22 Sep 88 14:59:03 EDT
Received: from kent-state ([192.9.200.24]) by heavens-gate.lucid.com id AA06623g; Thu, 22 Sep 88 10:56:07 PST
Received: by kent-state id AA17374g; Thu, 22 Sep 88 11:54:50 PDT
Date: Thu, 22 Sep 88 11:54:50 PDT
From: Harlan Sexton <hbs@lucid.com>
Message-Id: <8809221854.AA17374@kent-state>
To: ACW@IVORY.S4CC.Symbolics.COM
Cc: mcvax!ukc!cam-cl!adg@uunet.uu.net, scheme@mc.lcs.mit.edu
In-Reply-To: Allan C. Wechsler's message of Thu, 22 Sep 88 10:46 EDT <19880922144647.6.ACW@ROCKY-MOUNTAINS.S4CC.Symbolics.COM>
Subject: dynamic compilation for scheme, with inlining, etc?

I wouldn't be surprised to find interpreted representations bigger than
machine-code. However, you can usually get byte-code to be smaller than
machine-code by factors of about 4 to 10 (higher for RISC machines, in my
limited experience), so compiling to byte-codes can win. Also, in spite of
what someone said, memory is NOT so cheap that it doesn't matter how big
the code for an application is, and I can imagine that it will never be so
for certain classes of applications.


--Harlan

Received: from IVORY.S4CC.Symbolics.COM (TCP 20024231401) by MC.LCS.MIT.EDU 22 Sep 88 10:51:49 EDT
Received: from ROCKY-MOUNTAINS.S4CC.Symbolics.COM by IVORY.S4CC.Symbolics.COM via CHAOS with CHAOS-MAIL id 192376; Thu 22-Sep-88 10:47:03 EDT
Date: Thu, 22 Sep 88 10:47 EDT
From: Allan C. Wechsler <ACW@IVORY.S4CC.Symbolics.COM>
Subject: Re: dynamic compilation for scheme, with inlining, etc?
To: mcvax!ukc!cam-cl!adg@uunet.uu.net, scheme@mc.lcs.mit.edu
In-Reply-To: <327@scaup.cl.cam.ac.uk>
Supersedes: <19880922144647.6.ACW@ROCKY-MOUNTAINS.S4CC.Symbolics.COM>
Message-ID: <19880922144752.7.ACW@ROCKY-MOUNTAINS.S4CC.Symbolics.COM>


Received: from IVORY.S4CC.Symbolics.COM (TCP 20024231401) by MC.LCS.MIT.EDU 22 Sep 88 10:51:08 EDT
Received: from ROCKY-MOUNTAINS.S4CC.Symbolics.COM by IVORY.S4CC.Symbolics.COM via CHAOS with CHAOS-MAIL id 192375; Thu 22-Sep-88 10:45:57 EDT
Date: Thu, 22 Sep 88 10:46 EDT
From: Allan C. Wechsler <ACW@IVORY.S4CC.Symbolics.COM>
Subject: Re: dynamic compilation for scheme, with inlining, etc?
To: mcvax!ukc!cam-cl!adg@uunet.uu.net, scheme@mc.lcs.mit.edu
In-Reply-To: <327@scaup.cl.cam.ac.uk>
Message-ID: <19880922144647.6.ACW@ROCKY-MOUNTAINS.S4CC.Symbolics.COM>

    Date: 19 Sep 88 20:36:51 GMT
    From: mcvax!ukc!cam-cl!adg@uunet.uu.net  (Andy Gordon)

[...]

			    Interpreted code is generally smaller than compiled
    code so less space is needed than compiling the whole thing.

This guy's whole approach is based on this premise.  Does anyone want to
disabuse him.  For a simple recursive factorial, for example, I get
about 25 words interpreted, and about ten compiled.  I don't know what
happens with large programs, but I suspect they show about the same
ratio.

Received: from uicbert.eecs.uic.edu (TCP 20076123031) by MC.LCS.MIT.EDU 21 Sep 88 16:55:42 EDT
Received: by uicbert.eecs.uic.edu (UIUC-5.52/9.7)
	id AA03387; Wed, 21 Sep 88 14:55:15 CST
Date: Wed, 21 Sep 88 14:55:15 CST
From: wilson@uicbert.eecs.uic.edu (Paul Wilson)
Message-Id: <8809212055.AA03387@uicbert.eecs.uic.edu>
To: scheme-request@mc.lcs.mit.edu, scheme@mc.lcs.mit.edu
Subject: Status of XScheme
Cc: wilson@uicbert.eecs.uic.edu

A while back I heard something about Dave Betz doing a Scheme.
They called it XScheme 0.3.  Does anybody know what the status
of this project is, or any details about the actual code?
(Is it portable? What machines does it run on?, etc.)

Thanks,
Paul


Paul R. Wilson                         
Human-Computer Interaction Laboratory
U. of Illin. at C. EECS Dept. (M/C 154)   wilson%uicbert@uxc.cso.uiuc.edu
Box 4348   Chicago,IL 60680 

Received: from uicbert.eecs.uic.edu (TCP 20076123031) by MC.LCS.MIT.EDU 21 Sep 88 16:46:46 EDT
Received: by uicbert.eecs.uic.edu (UIUC-5.52/9.7)
	id AA03336; Wed, 21 Sep 88 14:46:18 CST
Date: Wed, 21 Sep 88 14:46:18 CST
From: wilson@uicbert.eecs.uic.edu (Paul Wilson)
Message-Id: <8809212046.AA03336@uicbert.eecs.uic.edu>
To: scheme-request@mc.lcs.mit.edu, scheme@mc.lcs.mit.edu
Subject: request for info on scheme (or subset) for MVS (or portable)
Cc: wilson@uicbert.eecs.uic.edu

Someone has asked me how to get a Scheme or a subset to run on an
IBM 370.  A subset would do, and debugging facilities are not a
necessity.  They're struggling along with an unfriendly Lisp as
it is.

Anybody out there know of a Scheme that runs on a 370 or is very
portable?  Failing that, does anybody want to make recommendations
about how and what to port to minimize headaches?

Thanks prematurely,

Paul 


Paul R. Wilson                         
Human-Computer Interaction Laboratory
U. of Illin. at C. EECS Dept. (M/C 154)   wilson%uicbert@uxc.cso.uiuc.edu
Box 4348   Chicago,IL 60680 

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 21 Sep 88 13:05:38 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA10016@BLOOM-BEACON.MIT.EDU>; Wed, 21 Sep 88 13:03:30 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 19 Sep 88 20:36:51 GMT
From: mcvax!ukc!cam-cl!adg@uunet.uu.net  (Andy Gordon)
Organization: U of Cambridge Comp Lab, UK
Subject: Re: dynamic compilation for scheme, with inlining, etc?
Message-Id: <327@scaup.cl.cam.ac.uk>
References: <8809142159.AA28551@uicbert.eecs.uic.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


In article <8809142159.AA28551@uicbert.eecs.uic.edu> wilson@uicbert.eecs.uic.EDU (Paul Wilson) writes:
>I've been thinking about using dynamic compilation for Scheme,
>and wondering if anybody else is.  Have people abandoned the idea
>of dynamic compilation, and if so, was it premature?

Firstly, by "dynamic compilation" I understand a system that
represents a programme to start with as a syntax tree or some other form
suitable for interpretation, but compiles parts of it into native code
as execution proceeds.  Interpreted code is generally smaller than compiled
code so less space is needed than compiling the whole thing.

I worked on a related problem for my honours thesis---how to interface
compiled and interpreted code in the Edinburgh Standard ML compiler.  In the
system I built the programmer indicated by annotations for each function
whether it was to be compiled or interpreted, but I did have in mind a scheme
that would do the annotations automatically, based on data from previous runs,
or even dynamically converting interpreted functions into native code if they
were frequently executed.  I found on small benchmarks that native code
was between four and six times bigger than interpreted byte codes, and
ran between one and seven times faster.

Let's call a system that mixes compiled and interpreted code a "hybrid"
system, and then distinguish between "static" and "dynamic" hybrids, i.e.,
between those in which the mode of each function declaration is determined at
compile time and those in which it can change at run time.  So I built a
static hybrid system, and I think you plan to build a dynamic hybrid system.

There appear to be two reasons for hybrid systems: (1) to give a variable
time/space tradeoff, i.e., between fast/bulky native code and slow/lean
interpreted code; (2) to allow fancy interpretive debuggers and tracers
in the presence of native code.

I don't think reason (1) is very compelling these days, because the size of
compiled code is not an issue with today's computers---certainly, big ML
programmes that are compiled to native code by one of the production compilers
don't take up inordinate space.  However, reason (2) is still attractive,
because interpreted code will always be easier to debug than compiled code.  A
dynamic hybrid system is all the work of a static one, and more, so for it to
be worthwhile it must make debugging much easier.  One can imagine a debugger
threading through a programme, seeking to use interpreted versions of compiled
functions as it finds them---maybe you could keep a pointer in each compiled
function to an interpreted version or the source.  I'd be interested to hear
how you get on.

Here are some references you might find useful when implementing your scheme.
I published a technical report [1] that has a comprehensive literature survey
on hybrid compilation/interpretation, and presents a taxonomy of ways to
switch between compiled and interpreted modes.  I have a few copies of it that
I could post to anyone who is interested (email me).  Other papers that might
be of interest: Brown on "throw away compiling" [2], Low on automatically
selecting an appropriate representation of an abstract data type depending on
usage statistics [3] and Dakin and Dawson on a text editor that mixes
compilation and interpretation, together with performance graphs [4].

[1] A. D. Gordon, "How to Breed Hybrid Compiler/Interpreters",
    Technical report ECS--LFCS--88--50, Laboratory for the Foundations of
    Computer Science, Computer Science Dept., University of Edinburgh,
    Edinburgh, EH9 3JZ, Scotland. April, 1988.

[2] P. J. Brown, "Throw-away compiling", SWPE, 6, pages 423--434, 1976.

[3] J.R. Low, "Automatic data structure selection: an example and overview",
    CACM, 21(5), pages 376--385, May 1978.

[4] R. J. Dakin and P. C. Poole, "A mixed code approach", The Computer Journal,
    16(3), pages 219--222, 1973.

Received: from gwusun (TCP 20051001001) by MC.LCS.MIT.EDU 21 Sep 88 00:16:24 EDT
Received:  by gwusun (4.0/25-eef)
	id AA04027; Mon, 22 Aug 88 00:14:27 EDT
Date: Mon, 22 Aug 88 00:14:27 EDT
From: tyan@gwusun.gwu.edu (Tyan Sheng)
Message-Id: <8808220414.AA04027@gwusun>
To: scheme@mc.lcs.mit.edu
Subject: scheme ATT 5


	Would you please send us some instructions about how to install
scheme into our ATT system 5, and if there were other institutes who had
successed in doing so, please give us their mail address, so we can ask
for their experiences.
	Thanks for your help!
		
					School of engineering and applied science
					George Washington University

Received: from iuvax.cs.indiana.edu (TCP 30003147300) by MC.LCS.MIT.EDU 19 Sep 88 16:23:00 EDT
Received: by iuvax.cs.indiana.edu (5.54/1.16) 
Date: Mon, 19 Sep 88 15:19:51 EST
From: Chris Haynes <chaynes@iuvax.cs.indiana.edu>
To: scheme@mc.lcs.mit.edu, rrrs-authors@mc.lcs.mit.edu
Subject: IEEE Scheme Standardization Meeting

 	      IEEE Scheme Standardization Working Group

		       SUMMARY OF FIRST MEETING


The Working Group on Scheme (IEEE/MSC/P1178) met on July 27, 1988,
following the Lisp conference at Snowbird, Utah. There were 30
attendees, including several who are also members of X3J13 and
ISO/SC22/WG16.

The chair's introductory remarks included the main entries in the PAR
and the main features of the IEEE standardization process.  Will
Clinger reported on the Scheme Report Workshop of July 24th, including
proposed differences between the the ``Revised^3 Report on the
Algorithmic Language Scheme'', or R3RS for short, and the forthcoming
R4RS.

There was concern that a Scheme standard not disrupt ongoing research
on Scheme, with general agreement on the following points: (1) The
Scheme standard should encourage evolution of the language, including
alternate programming styles.  (2) The standard is incomplete, so
implementations are expected to extended the standard.  (3) Early
standardization of features should be avoided, so that research on
improved features is not curtailed.

David Bartley, Chris Hanson, and Jim Miller were elected to edit
the standard.

The main part of the meeting was general discussion, for the benefit
of the editors, of anticipated differences between the Scheme standard
and the R4RS.

An electronic newsgroup, based at MIT, will be established for
technical and administrative communication of the working group.
When it is established, its presence will be advertised on the 
scheme newsgroup with information on how to join the new newsgroup.
Transcripts of activity in this group will be periodically mailed to
interested parties, upon request to the chair, for the benefit of
those without network connections.  Full minutes of the meeting
will be posted to this newsgroup when it is created.

It was concluded that the next meeting should be in January or
February at a location and time to be determined by the chair, most
likely in Cambridge.

The working group anticipates the following time schedule: 6 months --
review of first draft of standard, 12 months -- send approved draft of
standard to MSC.

-- Chris Haynes (chaynes@iuvax.cs.indiana.edu)


Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 17 Sep 88 17:34:47 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA03677@BLOOM-BEACON.MIT.EDU>; Sat, 17 Sep 88 17:29:23 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 16 Sep 88 11:48:03 GMT
From: mcvax!ukc!etive!aiva!jeff@uunet.uu.net  (Jeff Dalton)
Organization: Dept. of AI, Univ. of Edinburgh, UK
Subject: Re: Functional Programming Implementation
Message-Id: <586@aiva.ed.ac.uk>
References: <3060@tekcrl.CRL.TEK.COM>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

In article <3060@tekcrl.CRL.TEK.COM> kend@tekchips.CRL.TEK.COM (Ken Dickey)
writes:
>One interesting text I have not yet seen referenced is:
>
>	"Functional Programming", by A. Field & P. Harrison,
>	Addison-Wesley, 1988 ISBN 0-201-19249-7.
>
>It is heavy into Hope, [...]

True, but it has rather strange coverage of Lisp.  For some reason,
many logic programming and functional programming texts are perfectly
willing to present Pascal, Algol, etc. as they are actually used but
then take an approach to Lisp that has little to do with current
practice.  Often Lisp procedures, but no others, are written entirely
in upper case, and we are told that "everything is a list", etc.
This notion of Lisp is better suited to making certain points, but
tends to leave the impression that Lisp is not a very good language.

This book uses Peter Henderson's Lispkit but without (as far as I can
recall) any indication that Lisp might be significantly different.

Received: from XX.LCS.MIT.EDU (CHAOS 2420) by MC.LCS.MIT.EDU 16 Sep 88 18:06:54 EDT
Date: Fri 16 Sep 88 18:02:38-EDT
From: Rishiyur S. Nikhil <NIKHIL@XX.LCS.MIT.EDU>
Subject: Errata for Simon Peyton Jones' book
To: scheme@MC.LCS.MIT.EDU
Message-ID: <12431109258.44.NIKHIL@XX.LCS.MIT.EDU>


Simon Peyton Jones recently sent me the following errata list for his
book.

Nikhil
	-------------------------------------------------------
         The Implementation of Functional Programming Languages
                        Simon L Peyton Jones
                        Prentice Hall, 1987


		E R R A T A		E R R A T A 

	PLEASE TELL ME OF ANY OTHER ERRORS OR TYPOS YOU FIND IN THE BOOK!
			simonpj@uk.ac.ucl.cs

(Line references are given counting only inhabited lines.)
(** for new ones since 15 March 88)

p48, line -6 (in box).  Replace "(3*5)" with "(3+5)"

*p52, line -9.  The line should begin with an open parenthesis "(".

*p56, line -8.  Omit the word "a" at the end of the line.

*p60, middle of bottom line.  Replace "f" with "fst".

*p63, line 5.  Replace second "that" with "what".

p68, line 2 of Fig 4.4.  Replace SECOND equivalence sign with "=".

*p72, line -14.  Replace "As" with "All".

p74, line 21, 22.  Replace the sentence "Furthermore, it uses less store
to hold the temporary applications of SEL-PAIR." with "Furthermore it uses
less store, since no temporary applications of SEL-PAIR are constructed."
(This one is just a clarification.)

p79, line -13.  "NODUPS" should be "nodups".

*p88, line -4; and
*p89, line 8.  Replace "(C u1 x y xs ys)" with "(C u1 x xs y ys)".
		(The "u1" should remain subscripted as it currently appears.)


p91, line 1.  "...is represented by (CONS ..." 
	      should be "...is represented by (CON ..."

p91, last line.  "_ul" should be "_u1".

*p93, line -17 (count carefully!).  Replace "CONS" with "CON".

*p97, line 17.  Replace "...FAIL definitely occurs on the right" with
		"...FAIL definitely occurs on the right or left".

*p97, line 18.  Add "         and         FAIL || E #=# E" to the end of the
		line.  The symbol "||" means the fatbar symbol, and "#=#"
		means the 3-line equivalence symbol, both of which occur 
		earlier on the same line (I just don't have the relevant
		symbols in the system I'm using for this errata list).  
		
		The spacing is important.  There
		should be plenty of space between the "E" at the end of the
		present line 18 and the "and", and an equal space before
		the "FAIL..." which is added.  The "and" is in normal text font
		and the rest is in the usual sans-serif font.

*p97, line 19.  Replace "this rule" with "these rules".

*p116, line -17.  Replace "reply" with "rely".

*p116, line -17.  Replace "previous section" with "Section 6.2.5".

p126, last line.  Dijkstra's initials are "EW" not "EJW".

*p127, line -3.  Replace "into" with "in".

*p137, line 7.  Add another "]" at the end of the line.
		(With similar spacing to the current final "]".)

*p142, line 7.  Replace "v1*" with "v1".
		(The "v1" remains subscripted as before.)

*p145, line 18.  Replace "lists" with "list".

*p145, line -10.  Replace "as" with "of".

*p146, line 2.  Replace "I" with "id".  (In sans-serif font as on the previous
		line.)

*p163, line -2.  Replace "light" with "list".

p179, line 12.  Replace "= tclambda tvn (tc gamma' ns' e)"
		with    "= tclambda1 tvn (tc gamma' ns' e)"

p202, Fig 11.1. Missing @ sign after $ in left-hand diagram.

p205, line -6; also p265, last line of 16.1.3.  Replace "[Richards, 1985]"
	with "[Scheevel, 1986]"

p206, lines 20,21; also p280, lines 16,17.  Replace Richards reference with:
        Scheevel M, 1986. Norma: a graph reduction processor.
        Proceedings of the ACM Conference on Lisp and
        Functional Programming, Cambridge Mass, pp212-219, August.

p206, line 12. "Ixlop" should be "Klop"

p289, line 2. "Aertes" should be "Aerts".

p299, line 3 of Fig 18.3.  Replace "<let> <E>" with "<E> <E>"

p315, lines 9-11.  First three lines of code segment should read:

	PUSH 1;		Get second argument
	EVAL;		Evaluate it
	PUSH 1;		Get first argument

p317, line -20.  Change "PUSH 2" to "PUSH 0"
p317, line -14.  Change "PUSH 0" to "PUSH 2"

p338, line -5,-6.  Replace sentence with "In contrast, a stack is a
	much less flexible allocation mechanism, but the store it allocates
	is recovered immediately when it becomes unused, and this recovery is
	very cheap (decrementing the stack pointer)."
    (This is just a rewording of a bad sentence.)

p343, last line of Fig. 20.3. Replace "The cases for i,j,x,..." 
			      with    "The cases for i,f,x,...".

p405, line -12. "19!" should be "2 to the 19:th power" and
      line -10. "O(N!)" should be "O(2 to-the-Nth)".

*p432, line 23.  Omit the words "squares of the"

p435, line -7.  Line should read "queens 0 = [[]]"
-------

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 15 Sep 88 20:11:31 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA01720@BLOOM-BEACON.MIT.EDU>; Thu, 15 Sep 88 19:58:46 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 15 Sep 88 23:14:43 GMT
From: PARIS.BERKELEY.EDU!larus@ucbvax.berkeley.edu  (James Larus)
Subject: Plea for Scheme Code
Message-Id: <8809152314.AA03895@paris.Berkeley.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

I am looking for some small-to-medium sized Scheme programs as test
cases for my dissertation research.  These programs should have
side-effect producing operations and should do something "real" (i.e.,
fib, tak, etc. need not apply).

My research is studying how to restructure Lisp programs for
concurrent execution.  For more details, see [1].  Your program
doesn't need to be inherently parallel, though if you have a copy in a
parallel dialect, I'd also be interested in it.

All I offer in exchange for your code is immortality in a footnote
(they do keep dissertations forever, don't they?).

/Jim

ARPA: larus@ginger.Berkeley.EDU
uucp: ucbvax!larus
      larus@berkeley


[1] James R. Larus and Paul N. Hilfinger,
    "Restructuring {Lisp} Programs for Concurrent Execution",
    in "ACM SIGPLAN Symposium on Parallel Programming", July, 1988.

Received: from paris.Berkeley.EDU (TCP 20010113056) by MC.LCS.MIT.EDU 15 Sep 88 19:26:20 EDT
Received: by paris.Berkeley.EDU (5.57/1.25)
	id AA03895; Thu, 15 Sep 88 16:14:50 PDT
From: larus%paris.Berkeley.EDU@ginger.Berkeley.EDU (James Larus)
Message-Id: <8809152314.AA03895@paris.Berkeley.EDU>
To: scheme@mc.lcs.mit.edu, comp-lang-scheme@ucbvax.Berkeley.EDU
Subject: Plea for Scheme Code
Reply-To: larus@ginger.Berkeley.EDU
Date: Thu, 15 Sep 88 16:14:43 PDT

I am looking for some small-to-medium sized Scheme programs as test
cases for my dissertation research.  These programs should have
side-effect producing operations and should do something "real" (i.e.,
fib, tak, etc. need not apply).

My research is studying how to restructure Lisp programs for
concurrent execution.  For more details, see [1].  Your program
doesn't need to be inherently parallel, though if you have a copy in a
parallel dialect, I'd also be interested in it.

All I offer in exchange for your code is immortality in a footnote
(they do keep dissertations forever, don't they?).

/Jim

ARPA: larus@ginger.Berkeley.EDU
uucp: ucbvax!larus
      larus@berkeley


[1] James R. Larus and Paul N. Hilfinger,
    "Restructuring {Lisp} Programs for Concurrent Execution",
    in "ACM SIGPLAN Symposium on Parallel Programming", July, 1988.


Received: from uicbert.eecs.uic.edu (TCP 20076123031) by MC.LCS.MIT.EDU 15 Sep 88 09:29:16 EDT
Received: by uicbert.eecs.uic.edu (UIUC-5.52/9.7)
	id AA28551; Wed, 14 Sep 88 15:59:11 CST
Date: Wed, 14 Sep 88 15:59:11 CST
From: wilson@uicbert.eecs.uic.edu (Paul Wilson)
Message-Id: <8809142159.AA28551@uicbert.eecs.uic.edu>
To: scheme-request@mc.lcs.mit.edu, scheme@mc.lcs.mit.edu
Subject: dynamic compilation for scheme, with inlining, etc?
Cc: wilson@uicbert.eecs.uic.edu

I've been thinking about using dynamic compilation for Scheme,
and wondering if anybody else is.  Have people abandoned the idea
of dynamic compilation, and if so, was it premature?

Some of the advantages might be:

   1) portability images could still run fast
   2) an optimizer could be called in to optimize those chunks of
      code that are ACTUALLY executed a bunch of times.
      (rather than just optimizing the time/space tradeoff between
       interpreted and compiled code, it could be used to adjust
       compile time/run time tradeoffs.)
   3) Transparent, automatic compilation and optimization.

   In particular, I'm thinking about a scheme in which inlining would
be done automatically, but dependencies would be recorded.  If somebody
changed the value of an inlined procedure or constant, the code
depending on those values would be invalidated and dynamically
recompiled at runtime.
   (The mechanism for this depends on near-lexical-scoping.  Procedures
that are never redefined in a lexically apparent way could be inlined.
Primitives that can modify things (like first-class environments) in
non-lexically-apparent ways would have to check for dependencies.)

   Anybody care to comment on this idea?  In particular, is there some
irreducible cost of dynamic compilation that I don't know about?  Any
advantages?

   (It seems to me that you might dynamically determine what types of
arguments frequently-executed procedures were frequently called with.
You could then compile special versions for the common combinations.
A large-grained check would dispatch to the proper version, within
which most type checking could be eliminated using type inference.
Would this be workable/worthwhile?)


Paul R. Wilson                         
Human-Computer Interaction Laboratory
U. of Illin. at C. EECS Dept. (M/C 154)   wilson%uicbert@uxc.cso.uiuc.edu
Box 4348   Chicago,IL 60680 

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 14 Sep 88 22:10:12 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA03126@BLOOM-BEACON.MIT.EDU>; Wed, 14 Sep 88 21:54:21 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 14 Sep 88 15:41:25 GMT
From: tektronix!tekcrl!tekchips!kend@bloom-beacon.mit.edu  (Ken Dickey;629-1046;92-726;LP=A;)
Organization: Tektronix, Inc., Beaverton,  OR.
Subject: Re: Functional Programming Implementation
Message-Id: <3060@tekcrl.CRL.TEK.COM>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


One interesting text I have not yet seen referenced is:

	"Functional Programming", by A. Field & P. Harrison,
	Addison-Wesley, 1988 ISBN 0-201-19249-7.

It is heavy into Hope, conbinators, and graph reduction and has
chapters on Memoization, Garbage Collection {one of the few good
gc write-ups I have seen in a text}, abstract interpretation, etc.

-Ken Dickey

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 14 Sep 88 20:55:09 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA01867@BLOOM-BEACON.MIT.EDU>; Wed, 14 Sep 88 20:50:15 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 14 Sep 88 15:11:24 GMT
From: otter!psa@hplabs.hp.com  (Patrick Arnold)
Organization: Hewlett-Packard Laboratories, Bristol, UK.
Subject: Re: Lambda Calculus Books
Message-Id: <1510013@otter.hple.hp.com>
References: <8809121253.AA25062@BLOOM-BEACON.MIT.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

The book is

	Principles of Functional Programming

by 

	Glaser, Hankin and Till.

It's so long since I read it it must be introductory!!

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 14 Sep 88 18:10:09 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA28476@BLOOM-BEACON.MIT.EDU>; Wed, 14 Sep 88 18:06:43 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 14 Sep 88 22:06:06 GMT
From: mcharity@athena.mit.edu  (Mitchell N Charity)
Organization: Massachusetts Institute of Technology
Subject: Re: Implementation of functional languages
Message-Id: <7066@bloom-beacon.MIT.EDU>
References: <12430328726.19.NIKHIL@XX.LCS.MIT.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

There were some typos in the functional language bibliography.

mcharity@athena.mit.edu
...!mit-eddie!mit-athena!mcharity

*** old	Wed Sep 14 17:37:59 1988
--- new	Wed Sep 14 17:48:56 1988
***************
*** 33 ****
!     organization = ACM,
--- 33 ----
!     organization = "ACM",
***************
*** 117,118 ****
!     author = "Burn, Geoffrey L., {Peyton Jones}, Simon L. and Robson, J.D.",
!     title = "{The Spineless G-Machine",
--- 117,118 ----
!     author = "Burn, Geoffrey L. and {Peyton Jones}, Simon L. and Robson, J.D.",
!     title = "{The Spineless G-Machine}",
***************
*** 216 ****
!     Goldberg88a,
--- 216 ----
!     Goldberg88b,
***************
*** 366 ****
!     author = "{Peyton Jones}, Simon L."
--- 366 ----
!     author = "{Peyton Jones}, Simon L.",
***************
*** 419 ****
!                  Functional Languages, Aspenas, Sweden (to appear)"
--- 419 ----
!                  Functional Languages, Aspenas, Sweden (to appear)",

Received: from XX.LCS.MIT.EDU (CHAOS 2420) by MC.LCS.MIT.EDU 13 Sep 88 18:53:13 EDT
Date: Tue 13 Sep 88 18:35:03-EDT
From: Rishiyur S. Nikhil <NIKHIL@XX.LCS.MIT.EDU>
Subject: Implementation of functional languages
To: scheme@MC.LCS.MIT.EDU
Message-ID: <12430328726.19.NIKHIL@XX.LCS.MIT.EDU>


Here is a ``must read'' bibliography for those interested in modern implementations
of functional languages.  Apologies for any omissions.

Nikhil

-------- CUT HERE ------------------
@inProceedings{
    Appel87a,
    key = "Appel, Andrew",
    author = "Appel, Andrew and MacQueen, David B.",
    title = "A Standard ML Compiler",
    booktitle = "Proceedings of the Conference on Functional Programming
                 and Computer Architecture, Portland, Oregon",
    year = 1987,
    month = "September",
    note = "Springer-Verlag LNCS 274",
    annote = "Functional languages"
}

@inProceedings{
    Argo88a,
    key = "Argo, Guy",
    author = "Argo, Guy",
    title = "The G-TIM: a refined Three Instruction Machine",
    booktitle = "Proceedings of the Workshop on Implementation of Lazy
                 Functional Languages, Aspenas, Sweden (to appear)",
    month = "September 5-8",
    year = 1988,
    annote = "Graph Reduction, Lambda Calculus"
}

@inProceedings{
    Augustsson84,
    key = "Augustsson, Lennart",
    author = "Augustsson, Lennart",
    title = "A Compiler for Lazy ML",
    booktitle = "Proc. 1984 ACM Conf. on Lisp and Functional Programming,
                 Austin, Texas",
    organization = ACM,
    year = 1984,
    month = "August",
    pages = "218-227",
    annote = "Lambda-lifting, Super-Combinators"
}

@inProceedings{
    Augustsson85,
    key = "Augustsson, Lennart",
    author = "Augustsson, Lennart",
    title = "Compiling Pattern Matching",
    booktitle = "Proc. 1985 Workshop on Implementations of
                 Functional Languages, Goteborg, Sweden",
    organization = "Chalmers University of Technology",
    year = 1985,
    month = "February",
    annote = "Lambda-lifting, Super-Combinators, ML"
}

@PhDThesis{
    Augustsson87a,
    key = "Augustsson, Lennart",
    author = "Augustsson, Lennart",
    title = "Compiling Lazy Functional Languages, Part II",
    school = "Department of Computer Sciences,
              Chalmers University of Technology",
    address = "Goteborg, Sweden",
    year = 1987,
    annote = "LML, G-Machine, graph reduction"
}

@inProceedings{
    Augustsson88a,
    key = "Augustsson, Lennart",
    author = "Augustsson, Lennart",
    title = "The nu G-machine",
    booktitle = "Proceedings of the Workshop on Implementation of Lazy
                 Functional Languages, Aspenas, Sweden (to appear)",
    month = "September 5-8",
    year = 1988,
    annote = "Parallel Graph Reduction, Lambda Calculus"
}

@inProceedings{
    Bloss88a,
    key = "Bloss, Adrienne",
    author = "Bloss, Adrienne and Hudak, Paul and Young, Jonathan",
    title = "Code Optimizations for Lazy Evaluation",
    booktitle = "Proceedings of the Workshop on Implementation of Lazy
                 Functional Languages, Aspenas, Sweden (to appear)",
    month = "September 5-8",
    year = 1988,
    annote = "Graph Reduction, Lambda Calculus"
}

@inProceedings{
    Burn88a,
    key = "Burn, Geoffrey L.",
    author = "Burn, Geoffrey L.",
    title = "{A Shared Memory Parallel G-machine Based on the Evaluation
              Transformer Model of Computation}",
    booktitle = "Proceedings of the Workshop on Implementation of Lazy
                 Functional Languages, Aspenas, Sweden (to appear)",
    month = "September 5-8",
    year = 1988,
    annote = "Graph Reduction, Lambda Calculus"
}

@inProceedings{
    Burn88b,
    key = "Burn, Geoffrey L.",
    author = "Burn, Geoffrey L.",
    title = "{Developing a Distributed Memory Architecture for Parallel Graph Reduction}",
    booktitle = "Proceedings of the Workshop on Implementation of Lazy
                 Functional Languages, Aspenas, Sweden (to appear)",
    month = "September 5-8",
    year = 1988,
    annote = "Graph Reduction, Lambda Calculus"
}

@inProceedings{
    Burn88c,
    key = "Burn, Geoffrey L.",
    author = "Burn, Geoffrey L., {Peyton Jones}, Simon L. and Robson, J.D.",
    title = "{The Spineless G-Machine",
    booktitle = "Proceedings of the ACM Conference on Lisp and Functional Programming,
                 Snowbird, Utah",
    month = "July 25-27",
    year = 1988,
    annote = "Graph Reduction, Lambda Calculus"
}

@inProceedings{
    Cardelli84d,
    key = "Cardelli, Luca",
    author = "Cardelli, Luca",
    title = "Compiling a Functional Language",
    booktitle = "Proceedings of the ACM Conference on Lisp and Functional
                 Programming, Austin, Texas",
    year = "1984",
    month = "August 6-8",
    pages = "208-217",
    annote = "ML"
}

@inProceedings{
    Clack86a,
    key = "Clack, Chris",
    author = "Clack, Chris and Peyton-Jones, Simon L.",
    title = "The Four-Stroke Reduction Engine",
    booktitle = "Proceedings of the 1986 ACM Conference on Lisp and Functional
                 Programming, Cambridge, Mass.",
    year = 1986,
    month = "August 4-6",
    pages = "220-232",
    annote = "parallel graph reduction"
}

@article{
    Cousineau87,
    key = "Cousineau, G and Curien, Pierre-Louis and Mauny, Michel",
    author = "Cousineau, G and Curien, Pierre-Louis and Mauny, Michel",
    title = "The Categorical Abstract Machine",
    journal = "Science of Computer Programming",
    volume = 8,
    year = "1987",
    pages = "173-202",
    annote = "ML, CAM, Categorical Combinators"
}

@inProceedings{
    Fairbairn85,
    key = "Fairbairn, Jon",
    author = "Fairbairn, Jon",
    title = "Removing Redundant Laziness from Supercombinators",
    booktitle = "Proc. 1985 Workshop on Implementations of
                 Functional Languages, Goteborg, Sweden",
    organization = "Chalmers University of Technology",
    year = 1985,
    month = "February",
    annote = "Ponder, strictness, lazy evaluation"
}

@inProceedings{
    Fairbairn87a,
    key = "Fairbairn87, Jon",
    author = "Fairbairn, Jon and Wray, Stuart C.",
    title = "TIM: A Simple, Lazy Abstract Machine to Execute Supercombinators",
    booktitle = "Proceedings of the 1987 Functional Programming and
                 Computer Architecture Conference, Portland, Oregon",
    year = 1987,
    month = "September",
    pages = "34-45",
    annote = "non-strictness, continuations"
}

@inProceedings{
    Goldberg86,
    key = "Goldberg86, Benjamin and Hudak, Paul",
    author = "Goldberg, Benjamin and Hudak, Paul",
    title = "Alfalfa: Distributed Graph Reduction on a Hypercube Multiprocessor",
    booktitle = "{Proceedings of the Workshop on Graph Reduction,
                 Santa Fe, New Mexico, USA,
                 (Springer-Verlag LNCS 279).}",
    year = 1986,
    month = "September/October",
    pages = "94-113"
}

@inProceedings{
    Goldberg88a,
    key = "Goldberg, Benjamin",
    author = "Goldberg, Benjamin",
    title = "Buckwheat: Graph Reduction on a Shared Memory Multiprocessor",
    booktitle = "{Proceedings of the 1988 ACM Conference on Lisp and Functional Programming,
                  Snowbird, Utah}",
    year = 1988,
    month = "July 25-27",
    pages = "40-51"
}

@PhDThesis{
    Goldberg88a,
    key = "Goldberg, Benjamin",
    author = "Goldberg, Benjamin",
    title = "Multiprocessor Execution of Functional Programs",
    school = "Department of Computer Science,
              Yale University",
    year = 1988,
    annote = "Scheme, T"
}

@inProceedings{
    Halstead84a,
    key = "Halstead, Robert H.",
    author = "Halstead, Robert H.",
    title = "Implementation of Multilisp: Lisp on a Multiprocessor",
    booktitle = "Proceedings of the ACM Conference on Lisp and Functional
                 Programming, Austin, Texas",
    year = "1984",
    month = "August 6-8",
    pages = "9-17",
    annote = "Scheme"
}

@inProceedings{
    Hughes82,
    key = "Hughes,R.J.M.",
    author = "Hughes,R.J.M.",
    title = "Super-Combinators",
    booktitle = "Proc. 1982 ACM Symp. on Lisp and Functional Programming,
                 Pittsburgh, PA",
    organization = "ACM",
    year = 1982,
    month = "August",
    pages = "1-10",
    annote = "Graph Reduction,  functional languages"
}

@article{
    Johnsson84,
    key = "Johnsson,T.",
    author = "Johnsson,T.",
    title = "Efficient Compilation of Lazy Evaluation",
    journal = "ACM SIGPLAN Notices",
    volume = 19,
    number = 6,
    year = 1984,
    month = "June",
    pages = "58-69",
    note = "Proc. ACM SIGPLAN '84 Symposium on Compiler Construction",
    annote = "ML, lambda-lifting, super-combinators, G-machine"
}

@inProceedings{
    Johnsson85,
    key = "Johnsson, Thomas",
    author = "Johnsson, Thomas",
    title = "Lambda Lifting: Transforming Programs to Recursive Equations",
    booktitle = "Springer-Verlag LNCS 201 (Proc. Functional Programming
                 Languages and Computer Architecture, Nancy, France)",
    year = "1985",
    month = "September",
    annote = "ML, super-combinators, G-machine"
}

@inProceedings{
    Johnsson86a,
    key = "Johnsson86, Thomas",
    author = "Johnsson, Thomas",
    title = "Target Code Generation from G-Machine Code",
    booktitle = "Proceedings of the Workshop on Graph Reduction,
                 Santa Fe, New Mexico, USA,
                 (Springer-Verlag LNCS 279).",
    note = "(also Programming Methodology Group Report 39,
             Department of Computer Science,
             Chalmers University of Technology and University of Goteborg,
             S-421 96 Goteborg, Sweden)",
    year = "1986",
    month = "September/October",
    annote = "LML, functional languages"
}

@PhDThesis{
    Johnsson88a,
    key = "Johnsson, Thomas",
    author = "Johnsson, Thomas",
    title = "Compiling Lazy Functional Languages",
    school = "Department of Computer Sciences,
              Chalmers University of Technology",
    address = "Goteborg, Sweden",
    year = 1987,
    annote = "LML, G-Machine, graph reduction"
}

@article{
    Kranz86a,
    key = "Kranz86, David",
    author = "Kranz, David and Kelsey, R. and Rees, Jonathan
              and Hudak, Paul and Philbin, J. and Adams, N.",
    title = "{ORBIT:  An Optimizing Compiler for Scheme}",
    journal = "ACM SIGPLAN Notices",
    year = 1986,
    volume = 21,
    number = 7,
    pages = "219-233",
    month = "July",
    note= "(Proceedings of the {SIGPLAN} 86 Symposium on Compiler Construction)",
    annote = "Lisp, functional languages"
}

@PhDThesis{
    Kranz88a,
    key = "Kranz, David",
    author = "Kranz, David",
    title = "ORBIT: An Optimizing Compiler for Scheme",
    school = "Department of Computer Science,
              Yale University",
    year = 1988,
    annote = "Scheme, T"
}

@article{
    Landin64,
    key = "Landin, Peter J.",
    author = "Landin, Peter J.",
    title = "The Mechanical Evaluation of Languages",
    journal = "Computer Journal",
    volume = 6,
    number = 4,
    year = 1964,
    month = "January",
    pages = "308-320",
    annote = "ISWIM, applicative languages, SECD machines"
}

@inProceedings{
    Peyton-Jones85,
    key = "Peyton Jones, Simon L.",
    author = "{Peyton Jones}, Simon L. and Clack,C. and Harris,N.",
    title = "GRIP - a Parallel Graph Reduction Machine",
    booktitle = "Proc. 1985 Workshop on Implementations of
                 Functional Languages, Goteborg, Sweden",
    organization = "Chalmers University of Technology",
    year = 1985,
    month = "February",
    annote = "Combinators"
}

@Book{
    Peyton-Jones87a,
    key = "Peyton Jones87, Simon L.",
    author = "{Peyton Jones}, Simon L."
    title = "The Implementation of Functional Programming Languages",
    publisher = "Prentice Hall",
    year = 1987,
    annote = "Combinators, G-Machine"
}

@inProceedings{
    Peyton-Jones87b,
    key = "Peyton Jones87, Simon L. and Clack, Chris and Salkild, Jon and Hardie, Mark ",
    author = "{Peyton Jones}, Simon L. and Clack, Chris and Salkild, Jon and Hardie, Mark ",
    title = "{GRIP -- A High Performance Architecture for Parallel Graph Reduction}",
    booktitle = "{Proceedings of the 3rd. International Conference on
                  Functional Programming and Computer Architecture, Portland, Oregon}",
    year = "1987",
    month = "September",
    annote = "Combinators, G-Machine"
}

@misc{
    Peyton-Jones87c,
    key = "Peyton Jones, Simon L.",
    author = "{Peyton Jones}, Simon L.",
    title = "{The tag is dead -- long live the packet}",
    month = "October 22",
    year = 1987,
    note = "Note to FP e-mailing list",
    annote = "Graph Reduction, Lambda Calculus"
}

@article{
    Peyton-Jones88a,
    key = "Peyton Jones, Simon L.",
    author = "{Peyton Jones}, Simon L.",
    title = "{FLIC --- a Functional Language Intermediate Code}",
    journal = "ACM SIGPLAN Notices",
    volume = 23,
    number = 8,
    year = 1988,
    month = "August",
    pages = "30-48",
    note = "Also: Internal Note 2048,
            Department of Computer Science, University College London,
            Gower St., London WC1E 6BT",
    annote = "Graph Reduction, Lambda Calculus"
}

@inProceedings{
    Peyton-Jones88b,
    key = "Peyton Jones, Simon L.",
    author = "{Peyton Jones}, Simon L.",
    title = "{The Spineless Tagless G-machine}",
    booktitle = "Proceedings of the Workshop on Implementation of Lazy
                 Functional Languages, Aspenas, Sweden (to appear)"
    month = "September 5-8",
    year = 1988,
    annote = "Graph Reduction, Lambda Calculus"
}

@techreport{
    Steele78c,
    key = "{Steele Jr.}, Guy Lewis",
    author = "{Steele Jr.}, Guy Lewis",
    title = "{RABBIT:  A Compiler for SCHEME}",
    institution = "Massachusetts Institute of Technology Artificial Intelligence Laboratory",
    year = 1978,
    month = "May",
    number = "AI-TR-474",
    address = "Cambridge, MA",
    annote = "Lisp, functional languages"
}

@techReport{
    Traub86,
    key = "Traub86, Kenneth R.",
    author = "Traub, Kenneth R.",
    title = "A Compiler for the MIT Tagged-Token Dataflow Architecture",
    institution = "MIT Laboratory for Computer Science,
                   545 Technology Square,
                   Cambridge, MA 02139",
    number = "LCS TR-370",
    year = "1986",
    month = "August",
    school = "(Master's Thesis, Dept. of Electrical Engineering and Computer
               Science, MIT)",
    annote = "Functional Languages, Id"
}

@PhdThesis{
    Traub88a,
    key = "Traub88, Kenneth R.",
    author = "Traub, Kenneth R.",
    title = "Sequential Implementation of Lenient
             Programming Languages",
    school = "Massachusetts Institute of Technology",
    year = "1988",
    month = "May",
    note = "Also: TR-417,
                  MIT Laboratory for Computer Science,
                  545 Technology Square,
                  Cambridge, MA 02139",
    annote = "Functional Languages, Id"
}

-------

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 13 Sep 88 15:54:48 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA00400@BLOOM-BEACON.MIT.EDU>; Tue, 13 Sep 88 15:44:46 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 12 Sep 88 23:21:16 GMT
From: mailrus!umich!kfr@ohio-state.arpa  (Karl F. Ruehr)
Organization: University of Michigan EECS Dept. Ann Arbor
Subject: Re: Lambda Calculus Books
Message-Id: <1147@zippy.eecs.umich.edu>
References: <8809121446.AA07392@zohar>, <8809121545.AA01198@cheetah.ucdavis.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


  "The Lambda Calculus: its Syntax and Semantics", Henk Barendregt.
North-Holland (first edition, 1981; revised edition, 1984).  Approx.
$35.00 in paperback (look in a library first).

   This is the modern encyclopedic reference work on the lambda calculus
   and combinatory logic.  It is probably not of much use to anyone who
   isn't really committed to deep study: the first 70 pages (of 611
   total) are probably more than sufficient introduction for most needs,
   and it does not generally address computer science-related issues.  
   A wonder of modern typography.  Photographs of several famous
   theorists.  At least one fun exercise (6.8.14 on page 149.

  "Introduction to Combinators and Lambda Calculus", Roger Hindley and
Jonathan Seldin.  London Mathematical Society Student Texts #1,
Cambridge U. Press, 1986.  Price unknown, but probably < $35.00.

   This is a shorter, more relaxed introduction to the subject (not much
   model theory, for example, though see Chapter 12).  More suitable for
   curiosity-seekers, but still not exactly oriented toward the computer
   scientist specifically.  Produced from typewriter proofs.  Cute
   Appendix # 3.

  "The Calculi of Lambda Conversion", Alonzo Church.  Princeton
University Press, 1941.

   The original work (or very close to it) on lambda calculus (for
   combinatory logic, see Curry & Feys' "Combinatory Logic" or
   Schoenfinkel's work of 1924 (reprinted in "The Sourcebook for
   Mathematical Logic" (title?))).  Of mostly historical interest,
   though not to be dismissed.  Not much relevance to programming.


  The only books/works I can think of that would be helpful for
  functional language implementers, etc. would be:

  -- the Peyton-Jones book mentioned in the original article;
  -- perhaps a recent book by Glaser, Tinkin and Hill (the names are only
     approximate); I haven't read the book, but I recall that it has a chapter
     on lambda calculus.  "Functional Programming" probably in title.
  -- "Functional Programming" by Peter Henderson.  Prentice-Hall,
     "red-and-white binding series".  Perhaps the best bet besides
     Peyton-Jones.
  -- "Recursive Programming Techniques" by Burge (a bit out of date, but
     a real gold-mine of techniques, etc.

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 13 Sep 88 05:09:35 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA18098@BLOOM-BEACON.MIT.EDU>; Tue, 13 Sep 88 04:55:58 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 12 Sep 88 17:35:08 GMT
From: agate!saturn!venus.ucsc.edu!kjell@presto.ig.com  (Kjell Post,,,4238760)
Organization: University of California, Santa Cruz; CIS/CE
Subject: Proceedings on Lisp and Functional Programming
Message-Id: <4808@saturn.ucsc.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


What is the procedure for obtaining the "Lisp and functional
Programming" proceedings from ACM?

Has there been four or five so far?

-------------------------------------------------------------------------------
   Y F = F(Y F)                    ! Kjell Post, Dept of Comp & Info Sciences
"This superamazing, clever thing"  ! University of California, Santa Cruz
		-- G.J.Sussman     ! Email: kjell@saturn.ucsc.edu

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 12 Sep 88 20:54:39 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA09992@BLOOM-BEACON.MIT.EDU>; Mon, 12 Sep 88 20:51:53 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 12 Sep 88 17:32:59 GMT
From: linus!watro@husc6.harvard.edu  (Ronald J. Watro)
Organization: The MITRE Corp., Bedford, MA
Subject: Question on Combinator Reduction
Message-Id: <39820@linus.UUCP>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


Is there anywhere in the literature a correctness proof for
combinator reduction using the cyclic Y-rule, as described,
for example, in Peyton-Jones' book on implementing functional
languages?  I have looked at several papers on Graph Rewriting,
including one by Barendregt et. al. in the 87 PARLE conference,
but I cannot find this result.

-- 
Dr. Ronald J. Watro   The MITRE Corporation, MS A040, Burlington RD,
                      Bedford, MA 01730  USA      617-271-8390
ARPA:   watro%linus@mitre-bedford.ARPA
UUCP:   ...{decvax,utzoo,philabs,security,allegra,genrad}!linus!watro

Received: from clover.ucdavis.edu (TCP 20036034401) by MC.LCS.MIT.EDU 12 Sep 88 11:47:17 EDT
Received: from cheetah.ucdavis.edu by clover.ucdavis.edu (5.59/4.7)
	id AA09313; Mon, 12 Sep 88 08:41:26 PDT
Received: by cheetah.ucdavis.edu (AIX  2.2/3.14)
	id AA01198; Mon, 12 Sep 88 08:45:06 PDT
Message-Id: <8809121545.AA01198@cheetah.ucdavis.edu>
To: scheme@mc.lcs.mit.edu
Subject: Re: Lambda Calculus Books 
In-Reply-To: Your message of Mon, 12 Sep 88 10:46:13 -0500.
             <8809121446.AA07392@zohar> 
Date: Mon, 12 Sep 88 08:45:04 -0800
From: Phil Windley <windley@cheetah.ucdavis.edu>


I've seen a book by Barendregt (I think the spelling's right) on lambda
calculus.  Is it any good?

Phil Windley                          |  windley@iris.ucdavis.edu
Division of Computer Science          |  ucbvax!ucdavis!iris!windley
College of Engineering                |  (916) 752-7324 (or 3168)
University of California, Davis       |  Davis, CA 95616

Received: from zohar (TCP 2206400256) by MC.LCS.MIT.EDU 12 Sep 88 10:39:25 EDT
Received: by ZOHAR.AI.MIT.EDU; Mon, 12 Sep 88 10:46:13 edt
Date: Mon, 12 Sep 88 10:46:13 edt
From: gjs@ZOHAR.AI.MIT.EDU (Gerald Jay Sussman)
Message-Id: <8809121446.AA07392@zohar>
To: SEB1525%draper.com@RELAY.CS.NET
Cc: scheme@mc.lcs.mit.edu
In-Reply-To: "Steve Bacher (Batchman)"'s message of Mon, 12 Sep 88 07:20 EDT <8809121227.AA28967@zurich>
Subject: Lambda Calculus Books

Church's book is pretty irrelevent and unnecessary these days.  If you
want something theoretical about Lambda Calculus read Stoy.  You
certainly don't need anything more hairy than SICP to read
Peyton-Jones.

Received: from RELAY.CS.NET (TCP 1201000005) by MC.LCS.MIT.EDU 12 Sep 88 08:18:00 EDT
Received: from relay2.cs.net by RELAY.CS.NET id aa23449; 12 Sep 88 8:12 EDT
Received: from draper.com by RELAY.CS.NET id ad14648; 12 Sep 88 8:06 EDT
Date: Mon, 12 Sep 88 07:20 EDT
From: "Steve Bacher (Batchman)" <SEB1525%draper.com@RELAY.CS.NET>
Subject: Lambda Calculus Books
To: scheme@mc.lcs.mit.edu
X-VMS-To: SCHEME

From:	CCFVX3::SEB1525      "Steve Bacher (Batchman)" 12-SEP-1988 07:12
To:	IN%"jeschke@iuvax.cs.indiana.EDU",SEB1525     
Subj:	RE: Re: Intermediate Lambda Calculus --> Machine code

Would you say that Alonzo Church's book on lambda calculus is a 
prerequisite to the Peyton-Jones book?  Or is it reasonable to dig in
without a thorough background in lambda calculus?
(John McCarthy once admitted that he had understood only a small part of
Church's lambda calculus prior to inventing Lisp - he didn't read the
whole book.)

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU  9 Sep 88 06:38:35 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA11245@BLOOM-BEACON.MIT.EDU>; Fri, 9 Sep 88 06:25:52 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 8 Sep 88 20:45:29 GMT
From: uoregon!markv@beaver.cs.washington.edu  (Mark VandeWettering)
Organization: University of Oregon, Computer Science, Eugene OR
Subject: Re: Intermediate Lambda Calculus --> Machine code
Message-Id: <2718@uoregon.uoregon.edu>
References: <4742@saturn.ucsc.edu>, <12502@iuvax.cs.indiana.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

In article <12502@iuvax.cs.indiana.edu> jeschke@iuvax.UUCP (Eric Jeschke) writes:
>
>    "The Implementation of Functional Programming Languages" by Simon
>Peyton-Jones is a good book for this.    It basically describes the
>state-of-the-art in sequential implementations: pattern matching, typing,
>optimization and supercombinator generation.
>There is a very thorough treatment of the lambda calculus spanning several
>chapters.   I highly recommend it.

	I was going to recommend this book as well.  A MUST-HAVE for you
	shelf if you are at all interested in compiling declarative
	languages.  More raw brainpower went into this book than you
	could find in 1000 hours at a library.  It is well organized (in
	spite of several chapters being written by different authors)
	and very thorough.


	This book encouraged me to pursue a Master's thesis in the topic
	of parallel implementation of functional languages based upon
	the lambda calculus.

mark vandewettering

Received: from XX.LCS.MIT.EDU (CHAOS 2420) by MC.LCS.MIT.EDU  8 Sep 88 14:24:36 EDT
Received: from BLOOM-BEACON.MIT.EDU by XX.LCS.MIT.EDU with TCP/SMTP; Thu 8 Sep 88 14:25:14-EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA22048@BLOOM-BEACON.MIT.EDU>; Thu, 8 Sep 88 14:21:13 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 8 Sep 88 17:48:37 GMT
From: jeschke@iuvax.cs.indiana.edu  (Eric Jeschke)
Organization: Indiana University CSCI, Bloomington
Subject: Re: Intermediate Lambda Calculus --> Machine code
Message-Id: <12502@iuvax.cs.indiana.edu>
References: <4742@saturn.ucsc.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


    "The Implementation of Functional Programming Languages" by Simon
Peyton-Jones is a good book for this.    It basically describes the
state-of-the-art in sequential implementations: pattern matching, typing,
optimization and supercombinator generation.
There is a very thorough treatment of the lambda calculus spanning several
chapters.   I highly recommend it.

Eric
-- 
Eric
  jeschke@iuvax.cs.indiana.edu

Gimme shelter.

Received: from XX.LCS.MIT.EDU (CHAOS 2420) by MC.LCS.MIT.EDU  8 Sep 88 05:24:20 EDT
Received: from BLOOM-BEACON.MIT.EDU by XX.LCS.MIT.EDU with TCP/SMTP; Thu 8 Sep 88 05:23:09-EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA11036@BLOOM-BEACON.MIT.EDU>; Thu, 8 Sep 88 05:18:54 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 6 Sep 88 17:53:22 GMT
From: pasteur!agate!saturn!venus.ucsc.edu!kjell@ames.arpa  (Kjell Post)
Organization: University of California, Santa Cruz; CIS/CE
Subject: Intermediate Lambda Calculus --> Machine code
Message-Id: <4742@saturn.ucsc.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


I am looking for articles, books etc that describes various ways
of compiling intermediate lambda calculus (eg, produced by a 
compiler for a functional language or a denotational description
of any programming language) to real machine code. The work that
I've seen usually employs some abstract machine (SECD, G, CAM etc)
or relies on a selected set of combinators (Wand, Sethi).

Email please. Thanks.

-------------------------------------------------------------------------------
   Y F = F(Y F)                    ! Kjell Post, Dept of Comp & Info Sciences
"This superamazing, clever thing"  ! University of California, Santa Cruz
		-- G.J.Sussman     ! Email: kjell@saturn.ucsc.edu

Received: from MITVMA.MIT.EDU (TCP 2227000003) by MC.LCS.MIT.EDU  6 Sep 88 16:41:44 EDT
Received: from MITVMA.MIT.EDU by MITVMA.MIT.EDU (IBM VM SMTP R1.1) with BSMTP id 3432; Tue, 06 Sep 88 16:39:24 EDT
Received: from BUACCA.BITNET by MITVMA.MIT.EDU (Mailer X1.25) with BSMTP id
 3431; Tue, 06 Sep 88 16:39:23 EDT
Received: by BUACCA (Mailer X1.25) id 6261; Tue, 06 Sep 88 16:40:01 EDT
Date:    Tue, 06 Sep 88  16:38:54 EDT
From:    "Peter Mager" <met9i7n%BUACCA.BITNET@MITVMA.MIT.EDU>
Subject: Seminar announcement
To: scheme@mc.lcs.mit.edu,met9i7n@buacca

The following seminar may be of interest to you.
                         ACM GREATER BOSTON CHAPTER SICPLAN

                             Thursday, September 8, 1988
                                       8 P.M.

                     Bolt Beranek and Newman, Newman auditorium
                              70 Fawcett St., Cambridge

                     Parallel Symbolic Computing Using Multilisp
                               Robert H. Halstead, Jr.
                           Laboratory for Computer Science
                                         MIT

          Multilisp  is  an  extension  of  the  Lisp  dialect  Scheme  with
        additional  operators  and   additional   semantics   for   parallel
        execution.  The  principal parallelism construct in Multilisp is the
        "future," which exhibits  some  features  of  both  eager  and  lazy
        evaluation.   Multilisp  has  been  implemented,  and  runs  on  the
        shared-memory   Concert   multiprocessor,  using  as  many   as   34
        processors.  The implementation uses interesting techniques for task
        scheduling and garbage collection.  The task scheduler helps control
        excessive  resource  utilization by means of  an  unfair  scheduling
        policy;  the  garbage  collector  uses  a  multiprocessor  algorithm
        modeled after the incremental garbage collector of Baker.

          Current work focuses on making Multilisp a more humane programming
        environment, on expanding the power of  Multilisp  to  express  task
        scheduling policies, and on  measuring  the  properties of Multilisp
        programs with the goal of designing  a  parallel  architecture  well
        tailored for efficient  Multilisp  execution.  The talk will briefly
        describe  Multilisp,  discuss  the  areas of current  activity,  and
        outline  the   direction  of  the  Multilisp  project  with  special
        attention to the areas of task scheduling and architecture design.
 



                  ACM GREATER BOSTON CHAPTER SICPLAN

 Dear Colleague,

   Our September speaker,  Bert  Halstead, is Associate Professor of
 Computer Science and  Engineering  at MIT's Laboratory for Computer
 Science.  He is best known for pioneering Lisp multiprocessing  and
 the concept of futures.

   Larry  Snyder's  talk  last   month   showed   us  a  programming
 environment  that  supports  multiprocessing  and  explained   some
 capabilites that can help make such environments more useful.   Two
 local  conferences  this  month  are addressing similar  issues  of
 computer   support   for   software   engineering   and    parallel
 programming.   CASE  '88 was held at the Hyatt Hotel  in  Cambridge
 July  12-14.  Contact  Pam  Meyer  at  Intek  494-8200  x1988   for
 information about proceedings.  PPEALS, the ACM/SIGPLAN  conference
 on Parallel Programming: Experience with  Applications,  Languages,
 and Systems  will  be held in New Haven, Conn.  July 17-19. Contact
 Bill Gropp or Judy Terrell  at  Yale University, Dept.  of Computer
 Science 203-432-1200. Both  are  said to have outstanding technical
 programs.

   Other talks currently planned include:

   -  Tim Teitelbaum on "What's New with the Cornell Synthesizer" in
      November,

   -  Mayer Schwartz on the use of hypertext in software development
      support systems in December,

   -  and

   -  Reidar  Conradi  on the Trondheim programming  environment  in
      January.

   In addition, we are  planning  a  full  day  PDS  seminar on code
 generation techniques, tentatively scheduled for Saturday,  October
 15.  The  main  speaker  will  be  Professor Robert Henry from  the
 University of Washington, who will give a somewhat extended version
 of the  tutorial  he gave at the SIGPLAN '88 conference in Atlanta,
 with  emphasis  on  extending   Graham  Glanville  techniques.   In
 addition, we are inviting leading  compiler  experts  from  Apollo,
 DEC, U. Mass.  Boston  and  other  places  to  discuss  alternative
 techniques and current problems and issues including interaction of
 register allocation and  optimization  with code generation and use
 of  dynamic  programming  and  constraint  rules  to  improve  code
 generation efficiency.

   We  will  be  meeting  for  dinner  as  usual   at  Joyce  Chen's
 restaurant, 390 Rindge Ave., Cambridge at  6:00  p.m.   before  the
 meeting.  If you wish to come, please call Karen Kelley or "Sigplan
 dinner" at Intermetrics (661-1840) as  early  as possible so we can
 make the appropriate dinner reservation.


                                    Peter Mager
                                    chairperson, Boston SICPLAN


 

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU  5 Sep 88 02:07:20 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA03308@BLOOM-BEACON.MIT.EDU>; Mon, 5 Sep 88 01:50:51 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 4 Sep 88 16:54:19 GMT
From: mnetor!utzoo!yunexus!oz@uunet.uu.net  (Ozan Yigit)
Organization: York U. Computing Services - Magic Group
Subject: Scheme standard group: anything happening ??
Message-Id: <851@yunexus.UUCP>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

Isn't there supposed to be a "scheme standard" group formed and
working ?? What is happening with it ?? When would there be a working 
paper, some progress report, something ?? It has been quite a while 
since we heard [April 8] about its formation.  Chris Haynes,
Will Clinger: What is cooking ??

oz
-- 
Crud that is not paged	        | Usenet: ...!utzoo!yunexus!oz
is still crud. 			|   ...uunet!mnetor!yunexus!oz
	andrew@alice		| Bitnet: oz@[yulibra|yuyetti]
				| Phonet: +1 416 736-5257x3976

Received: from EDDIE.MIT.EDU by MC.LCS.MIT.EDU via Chaosnet; 3 SEP 88  16:18:57 EDT
Received: by EDDIE.MIT.EDU with UUCP with smail2.5 with sendmail-5.45/4.7 id <AA11580@EDDIE.MIT.EDU>; Sat, 3 Sep 88 16:17:20 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA13476@BLOOM-BEACON.MIT.EDU>; Sat, 3 Sep 88 05:58:06 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 2 Sep 88 17:21:42 GMT
From: att!chinet!mcdchg!clyde!watmath!utgpu!utzoo!yunexus!oz@bloom-beacon.mit.edu  (Ozan Yigit)
Organization: York U. Computing Services - Magic Group
Subject: Scheme Bibliography (Sept. 1988) Notes, Additions.
Message-Id: <850@yunexus.UUCP>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

Notes:
	o Scheme Bibliography will probably appear as a section
	  in Lisp Pointers, titled "Readings In Scheme".

	o Noone appears to have any additions to the bibliography,
	  as I have a total "contributor's silence".

	o Well, foo. they missed :-). Four entries were added, as
	  included at the end of this article, in diff -c format. 
	  [Use patch program to bring your database up-to-date:
	  in the directory containing scheme.bib:  patch <this-article]
	  [Non-Unix folk, send mail for a copy of the full database 
	  if needed.]

	o I Received much mail about the biblio. Nice to see 
	  that it is useful to so many.

	o Abstracts needed: If you have any abstracts (or could
	  put together one) for the entries in the biblio, it
	  would really be appreciated. Abstracts would make the
	  bibliography much more useful. [Any takers ??]

	o Happy Scheming...

The latest addition to the biblio (included in the diff)

%A Olin Shivers
%T Control Flow Analysis in Scheme
%J Proceedings of the Sigplan 1988 Conterence on Programming Language
Design and Implementation
%P 164-174
%C Atlanta, Georgia
%D June 1988
%K schflow

Abstract:

Traditional flow analysis techniques, such as the ones typically
employed by optimizing Fortran compilers do not work for Scheme-like
languages. This paper presents a flow analysis technique - control flow
analysis - which is applicable to Scheme-like languages.

=============== updates for scheme.bib

*** scheme.bib	Fri Sep  2 12:51:53 1988
--- scheme.bib.new	Fri Sep  2 12:25:21 1988
***************
*** 35,40 ****
--- 35,41 ----
  %P 153-162
  %I ACM
  %D 1977
+ %K ultimate
  
  %A Guy Lewis Steele, Jr.
  %T Macaroni is Better than Spaghetti
***************
*** 43,48 ****
--- 44,50 ----
  %P 60-66
  %O Special joint issue of SIGPLAN Notices 12(8) and SIGART Newsletter 64
  %D August 1977
+ %K macaroni
  
  %A Mitchell Wand
  %T Continuation-Based Program Transformation Strategies
***************
*** 52,57 ****
--- 54,68 ----
  %P 174-180
  %D 1978
  
+ %A Mitchell Wand
+ %A Daniel P. Friedman
+ %T Compiling lambda expressions using continuations and
+ factorizations
+ %J Journal of Computer Languages
+ %V 3
+ %P 241-263
+ %D 1978
+ 
  %A Guy Lewis Steele, Jr.
  %A Gerald Jay Sussman
  %T The Revised Report on Scheme, a Dialect of Lisp
***************
*** 58,63 ****
--- 69,75 ----
  %R MIT Artificial Intelligence Memo 452
  %C Cambridge, Mass.
  %D January 1978
+ %K r-report
  
  %A Guy Lewis Steele, Jr.
  %T Rabbit: a Compiler for Scheme
***************
*** 64,69 ****
--- 76,82 ----
  %R MIT Artificial Intelligence Laboratory Technical Report 474
  %C Cambridge, Mass.
  %D May 1978
+ %K rabbit
  
  %A Guy Lewis Steele, Jr.
  %A Gerald Jay Sussman
***************
*** 74,79 ****
--- 87,99 ----
  %D May 1978
  %K modularity
  
+ %A Uwe F. Pleban
+ %T The Standard Semantics of a Subset of SCHEME, a Dialect of LISP
+ %R Computer Science Technical Report TR-79-3
+ %I University of Kansas
+ %C Lawrence, Kansas
+ %D July 1979
+ 
  %A Drew McDermott
  %T An Efficient Environment Allocation Scheme in an Interpreter
  for a Lexically-Scoped Lisp
***************
*** 91,96 ****
--- 111,124 ----
  %I The Lisp Conference, P.O. Box 487, Redwood Estates CA.
  %D 1980
  
+ %A Uwe F. Pleban
+ %T A Denotational Approach to Flow Analysis and Optimization of
+ SCHEME, A Dialect of LISP
+ %R Ph.D. Dissertation
+ %I University of Kansas
+ %C Lawrence, Kansas
+ %D 1980
+ 
  %A Guy Lewis Steele, Jr.
  %T Compiler Optimization Based on Viewing LAMBDA as RENAME + GOTO
  %B AI: An MIT Perspective
***************
*** 99,104 ****
--- 127,133 ----
  %I MIT Press
  %C Cambridge, Mass.
  %D 1980
+ %K rename+goto
  
  %A Guy Lewis Steele, Jr.
  %A Gerald Jay Sussman
***************
*** 107,112 ****
--- 136,142 ----
  %P 163-172
  %I The Lisp Conference
  %D 1980
+ %K lazy
  
  %A Mitchell Wand
  %T Continuation-Based Multiprocessing
***************
*** 135,140 ****
--- 165,171 ----
  %P 10-21
  %D July 1981
  %I IEEE
+ %K scheme79
  
  %A John Batali
  %A Edmund Goodhue
***************
*** 164,169 ****
--- 195,201 ----
  Functional Programming
  %P 114-122
  %D 1982
+ %K T
  
  %A Gerald Jay Sussman
  %T LISP, Programming and Implementation
***************
*** 202,207 ****
--- 234,240 ----
  %C Bloomington, Indiana
  %D February 1983
  %O Superceded by Computer Science Technical Report 153, 1985
+ %K scheme311
  
  %A William Clinger
  %T The Scheme 311 compiler: An Exercise in Denotational Semantics
***************
*** 209,215 ****
  Functional Programming
  %P 356-364
  %D 1984
! %K comp311
  
  %A Daniel P. Friedman
  %A Christopher T. Haynes
--- 242,248 ----
  Functional Programming
  %P 356-364
  %D 1984
! %K compile311
  
  %A Daniel P. Friedman
  %A Christopher T. Haynes
***************
*** 261,276 ****
--- 294,319 ----
  %I S. B. Thesis, MIT Department of Electrical Engineering and Computer
  Science
  %D January 1984
+ %K liar
  
+ %A Richard Schooler
+ %A James W. Stamos
+ %T Proposal For a Small Scheme Implementation
+ %R MIT Lab for Computer Science Memo TM-267
+ %C Cambridge, Mass.
+ %D October 1984
+ 
  %T MIT Scheme Manual, Seventh Edition
  %I Department of Electrical Engineering and Computer Science, MIT
  %C Cambridge, Mass.
  %D September 1984
+ %K mitscheme
  
  %T MacScheme Reference Manual
  %I Semantic Microsystems
  %C Sausalito, Calif.
  %D 1985
+ %K macscheme
  
  %A Harold Abelson
  %A Gerald Jay Sussman
***************
*** 279,285 ****
  %I MIT Press
  %C Cambridge, Mass.
  %D 1985
! %K sicp
  
  %A William Clinger
  %A Daniel P. Friedman
--- 322,328 ----
  %I MIT Press
  %C Cambridge, Mass.
  %D 1985
! %K siocp
  
  %A William Clinger
  %A Daniel P. Friedman
***************
*** 450,455 ****
--- 493,499 ----
  %P 151-161
  %D August 1986
  %O To appear in Lisp and Symbolic Computation
+ %K hygienic
  
  %A Mitchell Wand
  %T The mystery of the tower revealed: a non-reflective
***************
*** 457,462 ****
--- 501,507 ----
  %J Proceedings of the 1986 ACM Symposium on LISP and Functional Programming
  %P 298-307
  %D August 1986
+ %K tower
  
  %E Jonathan A. Rees
  %E William Clinger
***************
*** 465,470 ****
--- 510,516 ----
  %V 21
  %N 12
  %D December 1986
+ %K rrrrs
  
  %A Christopher T. Haynes
  %T Logic Continuations
***************
*** 544,554 ****
  %P 206-223
  %D 1987
  
- %T A syntactic theory of sequential control
  %A Matthias Felleisen
  %A Daniel P. Friedman
  %A Eugene E. Kohlbecker
  %A Bruce Duba
  %J Theoretical Computer Science
  %V 52
  %P 205-237
--- 590,600 ----
  %P 206-223
  %D 1987
  
  %A Matthias Felleisen
  %A Daniel P. Friedman
  %A Eugene E. Kohlbecker
  %A Bruce Duba
+ %T A syntactic theory of sequential control
  %J Theoretical Computer Science
  %V 52
  %P 205-237
***************
*** 571,576 ****
--- 617,623 ----
  %P 109-121
  %I Pergamon Press
  %D 1987
+ %K engines
  
  %A Matthias Felleisen
  %T The Calculi of lambda-v-cs conversion: a syntactic
***************
*** 608,616 ****
  %C Bloomington, Indiana
  %D October 1987
  
- %T Embedding continuations in procedural objects
  %A Christopher T. Haynes
  %A Daniel P. Friedman
  %J ACM Transactions on Programming Languages and Systems
  %V 9
  %N 4
--- 655,663 ----
  %C Bloomington, Indiana
  %D October 1987
  
  %A Christopher T. Haynes
  %A Daniel P. Friedman
+ %T Embedding continuations in procedural objects
  %J ACM Transactions on Programming Languages and Systems
  %V 9
  %N 4
***************
*** 671,676 ****
--- 718,724 ----
  and Functional Programming
  %C Salt Lake City, Utah.
  %D July 1988
+ %K macrology
  
  %A Matthias Felleisen
  %A Mitchell Wand
***************
*** 683,688 ****
--- 731,745 ----
  %C Salt Lake City, Utah.
  %D July 1988
  
+ %A Olin Shivers
+ %T Control Flow Analysis in Scheme
+ %J Proceedings of the Sigplan 1988 Conterence on Programming Language
+ Design and Implementation
+ %P 164-174
+ %C Atlanta, Georgia
+ %D June 1988
+ %K schflow
+ 
  %A John Franco
  %A Daniel P. Friedman
  %T Creating Efficient Programs by Exchanging Data for Procedures
***************
*** 690,700 ****
  %I Indiana University
  %C Bloomington, Indiana
  %D March 1988
- 
- %A Mitchell Wand
- %A Daniel P. Friedman
- %T Compiling lambda expressions using continuations and
- factorizations
- %J Computer Languages 3
- %D 241-263
- %D 1978
--- 747,749 ----


oz
-- 
Crud that is not paged	        | Usenet: ...!utzoo!yunexus!oz
is still crud. 			|   ...uunet!mnetor!yunexus!oz
	andrew@alice		| Bitnet: oz@[yulibra|yuyetti]
				| Phonet: +1 416 736-5257x3976

Received: from cs.utah.edu (TCP 1200000004) by MC.LCS.MIT.EDU 31 Aug 88 17:29:33 EDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA13482; Wed, 31 Aug 88 15:28:18 MDT
Received: by car.utah.edu (5.54/utah-2.0-leaf)
	id AA06495; Wed, 31 Aug 88 15:28:14 MDT
Date: Wed, 31 Aug 88 15:28:14 MDT
From: carr%car@cs.utah.edu (Harold Carr)
Message-Id: <8808312128.AA06495@car.utah.edu>
To: scheme@mc.lcs.mit.edu
Subject: Gabriel benchmarks in Scheme

A while back Will Clinger sent out his set of Gabriel benchmarks which
he had rewritten in Scheme.  I have sent a message directly to him
asking for a copy, but I get no reply.  Perhaps he is on vacation.
But I need them now (so I don't have to write them myself).  Does
anyone have a copy they can send me or know of a machine from which I
can ftp a copy?

Thanks,
Harold

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 31 Aug 88 00:08:12 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA14412@BLOOM-BEACON.MIT.EDU>; Tue, 30 Aug 88 23:59:06 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 29 Aug 88 22:19:04 GMT
From: mcvax!unido!inria!crin!masini@uunet.uu.net  (Gerald MASINI)
Organization: C.R.I.N
Subject: Bibliography database
Message-Id: <594@crin.crin.fr>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

Our site has been disconnected from the net for a few days, so I don't
know if this kind of thing has already been posted.
Here is the bibliography database posted some time ago by (apologies,
I've lost the header of the transaction !), converted into the BibTeX
format. The entries are sorted in alphabetical order, and then in
chronological order. The field KEYWORD is of my own and can be ignored.
Some entries are not complete and are followed by the unknown fields as
comments. I've added two entries (steele79, greussay84) to the database.
I would be very pleased to receive your eventual corrections, new entries
or any comments.
Thanx in advance.

---- cut here ---- cut here ---- cut here ---- cut here ---- cut here ----

% ---- ABBREVIATIONS

@string{ail = "Artificial Intelligence Laboratory, MIT"}
@string{aim = "AI Memo"}
@string{at = "Austin, Texas"}
@string{cacm = "Communications of the ACM"}
@string{cm = "Cambridge, Massachusetts"}
@string{jacm = "Journal of the ACM"}
@string{lc80 = "Conference Record of the 1980 Lisp Conference"}
@string{mitp = "MIT Press"}
@string{pp = "Pittsburgh, Pennsylvania"}
@string{sv = "Springer-Verlag"}
@string{slfp82 = "Proceedings of the 1982 ACM Conference
                  on Lisp and Functional Programming"}
@string{slfp84 = "Proceedings of the 1984 ACM Conference
                  on Lisp and Functional Programming"}
@string{slfp86 = "Proceedings of the 1986 ACM Conference
                  on Lisp and Functional Programming"}

% ---- DATABASE

% ---- aaaa

@BOOK{abelson85,
  AUTHOR = {H. Abelson and G.J. Sussman and J. Sussman},
  TITLE = {{Structure and Interpretation of Computer Programs}},
  PUBLISHER = mitp,
  ADDRESS = cm,
  YEAR = 1985,
  KEYWORDS = {scheme}}

% ---- bbbb

@INPROCEEDINGS{bartley86,
  AUTHOR = {D.H. Bartley and J.C. Jensen},
  TITLE = {{The Implementation of PC Scheme}},
  BOOKTITLE = slfp86,
  YEAR = 1986,
  PAGES = {86--93},
  KEYWORDS = {scheme}}
%%%%%%%%%%%%%%%%  ADDRESS = {},
@INPROCEEDINGS{batali82,
  AUTHOR = {J. Batali and E. Goodhue and C. Hanson and H. Shrobe
            and R.M. Stallman and G.J. Sussman},
  TITLE = {{The Scheme-81 Architecture --- System and Chip}},
  BOOKTITLE = {{Proceedings of the Conference on Advanced Research in VLSI}},
  YEAR = 1982,
  PAGES = {69--77},
  KEYWORDS = {scheme}}
%%%%%%%%%%%%%%%% ADDRESS = {},

% ---- cccc

@INPROCEEDINGS{clinger84,
  AUTHOR = {W. Clinger},
  TITLE = {{The Scheme 311 Compiler: An Exercise in Denotational Semantics}},
  BOOKTITLE = slfp84,
  ADDRESS = at,
  YEAR = 1984,
  PAGES = {356--364},
  KEYWORDS = {scheme}}
@TECHREPORT{clinger85,
  AUTHOR = {W. Clinger},
  TITLE = {{The Revised Revised Report on Scheme, or An Uncommon Lisp}},
  TYPE = aim,
  NUMBER = 848,
  INSTITUTION = ail,
  ADDRESS = cm,
  YEAR = 1985,
  KEYWORDS = {scheme}}
@TECHREPORT{clinger85a,
  AUTHOR = {W. Clinger},
  TITLE = {{The Revised Revised Report on Scheme, or An Uncommon Lisp}},
  NUMBER = 174,
  INSTITUTION = {Computer Science Department, Indiana University},
  YEAR = 1985,
  KEYWORDS = {scheme}}

% ---- dddd

@INPROCEEDINGS{dybvig86,
  AUTHOR = {R.K. Dybvig and D.P. Friedman and C.T. Haynes},
  TITLE = {{Expansion-Passing Style: Beyond Conventional Macros}},
  BOOKTITLE = slfp86,
  YEAR = 1986,
  PAGES = {143--150},
  KEYWORDS = {scheme}}
%%%%%%%%%%%%%%%%  ADDRESS = {},
@BOOK{dybvig87,
  AUTHOR = {R.K. Dybvig},
  TITLE = {{The Scheme Programming Language}},
  PUBLISHER = {Prentice-Hall},
  ADDRESS = {Englewood Cliffs, New Jersey},
  YEAR = 1987,
  KEYWORDS = {scheme}}

% ---- eeee

@TECHREPORT{eisenberg85,
  AUTHOR = {M.A. Eisenberg},
  TITLE = {{Bochser: An Integrated Scheme Programming System}},
  NUMBER = 349,
  INSTITUTION = {MIT},
  ADDRESS = cm,
  YEAR = 1985,
  KEYWORDS = {scheme}}

% ---- ffff

@MISC{feeley86,
  AUTHOR = {M. Feeley and G. LaPalme},
  TITLE = {{Closure Generation Based on Viewing LAMBDA
            as EPSILON plus COMPILE}},
  YEAR = 1986,
  KEYWORDS = {scheme}}
%%%%%%%%%%%%%%%% HOWPUBLISHED = {},
@MASTERTHESIS{feeley86a,
  AUTHOR = {M. Feeley},
  TITLE = {{\it Deux approches \`{a} l'implantation du language Scheme}},
  SCHOOL = {D\'{e}partement d'Informatique et de Recherche
            Op\'{e}rationelle, Universit\'{e} de Montreal},
  YEAR = 1986,
  KEYWORDS = {scheme}}
@ARTICLE{feeley87,
  AUTHOR = {M. Feeley and G. LaPalme},
  TITLE = {{Using Cloures for Code Generation}},
  JOURNAL = {{Computer Languages}},
  VOLUME = 12,
  NUMBER = 1,
  YEAR = 1987,
  PAGES = {47--66},
  KEYWORDS = {scheme}}
@ARTICLE{felleisen86,
  AUTHOR = {M. Felleisen and D.P. Friedman},
  TITLE = {{A Closer Look at Export and Import Statements}},
  JOURNAL = {Computer Languages},
  VOLUME = 11,
  NUMBER = 1,
  PAGES = {29--37},
  YEAR = 1986,
  KEYWORDS = {scheme}}
@INPROCEEDINGS{felleisen86a,
  AUTHOR = {M. Felleisen and D.P. Friedman and E.E. Kohlbecker and B. Duba},
  TITLE = {{Reasoning with Continuations}},
  BOOKTITLE = {Proceedings of the Symposium on Logic in Computer Science},
  ADDRESS = {Washigton DC},
  YEAR = 1986,
  PAGES = {131--141},
  KEYWORDS = {scheme}}
@TECHREPORT{fessenden83,
  AUTHOR = {C. Fessenden and W. Clinger and D.P. Friedman and C.T. Haynes},
  TITLE = {{Scheme 311, version 4. Reference Manual}},
  TYPE = {Computer Science Technical Report},
  NUMBER = 137,
  INSTITUTION = {Indiana University},
  YEAR = 1983,
  KEYWORDS = {scheme}}
@INCOLLECTION{friedman84,
  AUTHOR = {D.P. Friedman and C.T. Haynes and E.E. Kohlbecker},
  TITLE = {{Programming with Continuations}},
  BOOKTITLE = {{Program Transformation and Programming Environments}},
  EDITOR = {P. Pepper},
  PUBLISHER = sv,
  YEAR = 1984,
  PAGES = {263--274},
  KEYWORDS = {scheme}}
@INPROCEEDINGS{friedman85,
  AUTHOR = {D.P. Friedman and C.T. Haynes},
  TITLE = {{Constraining Control}},
  BOOKTITLE = {{Proceedings of the 12th Annual Symposium 
                on Principles of Programming Languages}},
  YEAR = 1985,
  PAGES = {245--254},
  KEYWORDS = {scheme}}
%%%%%%%%%%%%%%%%  ADDRESS = {},
@TECHREPORT{friedman85a,
  AUTHOR = {D.P. Friedman and C.T. Haynes and E.E. Kohlbecker and M. Wand},
  TITLE = {{Scheme 84 Interim Reference Manual}},
  NUMBER = 153,
  INSTITUTION = {Computer Science Department, Indiana University},
  YEAR = 1985,
  KEYWORDS = {scheme}}
@BOOK{friedman87,
  AUTHOR = {D.P. Friedman and M. Felleisen},
  TITLE = {{The Little LISPer}},
  PUBLISHER = mitp,
  ADDRESS = cm,
  YEAR = 1987,
  KEYWORDS = {scheme}}

% ---- gggg

@INPROCEEDINGS{greussay84,
  AUTHOR = {P. Greussay},
  TITLE = {{Pr\'{e}sentation de SCHEME \`{a} partir d'exemples}},
  BOOKTITLE = {Actes des 2\`{e}mes Journ\'{e}es d'Etude
               sur les Langages Orient\'{e} Objets.
               Bigre+Globule No. 41},
  ADDRESS = {Brest},
  YEAR = 1984,
  PAGES = {5--41},
  KEYWORDS = {scheme}}

% ---- hhhh

@INPROCEEDINGS{haynes84,
  AUTHOR = {C.T. Haynes and D.P. Friedman},
  TITLE = {{Engines Build Process Abstractions}},
  BOOKTITLE = slfp84,
  ADDRESS = at,
  YEAR = 1984,
  PAGES = {18--24},
  KEYWORDS = {scheme}}
@INPROCEEDINGS{haynes84a,
  AUTHOR = {C.T. Haynes and D.P. Friedman and M. Wand},
  TITLE = {{Continuations and Coroutines}},
  BOOKTITLE = slfp84,
  ADDRESS = at,
  YEAR = 1984,
  PAGES = {293--298},
  KEYWORDS = {scheme}}
@ARTICLE{haynes86,
  AUTHOR = {C.T. Haynes and D.P. Friedman and M. Wand},
  TITLE = {{Obtaining Coroutines with Continuations}},
  JOURNAL = {Computer Languages},
  VOLUME = 11,
  NUMBER = {3--4},
  YEAR = 1986,
  PAGES = {143--153},
  KEYWORDS = {scheme}}
@INPROCEEDINGS{haynes86a,
  AUTHOR = {C.T. Haynes},
  TITLE = {{Logic Continuations}},
  BOOKTITLE = {{Proceedings of the 3rd International Conference
               on Logic Programming}},
  YEAR = 1986,
  PAGES = {671--685},
  KEYWORDS = {scheme}}
%%%%%%%%%%%%%%%% ADDRESS = {},
@INPROCEEDINGS{henderson82,
  AUTHOR = {P. Henderson},
  TITLE = {{Functional Geometry}},
  BOOKTITLE = slfp82,
  ADDRESS = pp,
  YEAR = 1982,
  PAGES = {179--187},
  KEYWORDS = {scheme}}

% ---- kkkk

@PHDTHESIS{kohlbecker86,
  AUTHOR = {E.E. Kohlbecker},
  TITLE = {{Syntactic Extensions in the Programming Language Lisp}},
  SCHOOL = {Indiana University},
  YEAR = 1986,
  KEYWORDS = {scheme}}
@BOOK{kranz86,
  AUTHOR = {D. Kranz and R. Kelsey and J.A. Rees and P. Hudak
            and J. Philbin and N.I. Adams},
  BOOKTITLE = {{Proceedings of the SIGPLAN 1986 Symposium
                on Compiler Construction}},
  YEAR = 1986,
  PAGES = {219--233},
  KEYWORDS = {scheme}}
%%%%%%%%%%%%%%%%  TITLE = {},
%%%%%%%%%%%%%%%%  ADDRESS = {},

% ---- mmmm

@INPROCEEDINGS{mcdermott80,
  AUTHOR = {D. McDermott},
  TITLE = {{An Efficient Environment Allocation Scheme
            in an Interpreter for a Lexically-Scoped Lisp}},
  BOOKTITLE = lc80,
  YEAR = 1980,
  PAGES = {154--162},
  KEYWORDS = {scheme}}
%%%%%%%%%%%%%%%%  ADDRESS = {},
@INPROCEEDINGS{muchnick80a,
  AUTHOR = {S.S. Muchnick and U.F. Pleban},
  TITLE = {{A Semantic Comparison of Lisp and Scheme}},
  BOOKTITLE = lc80,
  YEAR = 1980,
  PAGES = {56--65},
  KEYWORDS = {scheme}}
%%%%%%%%%%%%%%%% ADDRESS = {},

% ---- rrrr

@INPROCEEDINGS{rees82,
  AUTHOR = {J.A. Rees and N.I. Adams},
  TITLE = {{T: A Dialect of Lisp or, LAMBDA: The Ultimate Software Tool}},
  BOOKTITLE = slfp82,
  ADDRESS = pp,
  YEAR = 1982,
  PAGES = {114--122},
  KEYWORDS = {scheme}}
@MANUAL{rees84,
  AUTHOR = {J.A. Rees and N.I. Adams and J.R. Meehan},
  TITLE = {{The T Manual}},
  EDITION = {Fourth},
  ORGANIZATION = {Computer Science Department, Yale University},
  YEAR = 1984,
  KEYWORDS = {scheme}}
@INPROCEEDINGS{reynolds72,
  AUTHOR = {J. Reynolds},
  TITLE = {{Definitional Interpreters
            for Higher Order Programming Languages}},
  YEAR = 1972,
  PAGES = {717--740},
  KEYWORDS = {scheme}}
%%%%%%%%%%%%%%%%  BOOKTITLE = {{ACM Conference Proceedings}}, ????
%%%%%%%%%%%%%%%%  ADDRESS = {},
@MISC{rozas84,
  AUTHOR = {G.J. Rozas},
  TITLE = {{\it Liar, an Algol-Like Compiler for Scheme}},
  HOWPUBLISHED = {{S.B. Thesis, MIT Department of Electrical
                   Engineering and Computer Science}},
  YEAR = 1984,
  KEYWORDS = {scheme}}

% ---- ssss

@INPROCEEDINGS{srivastava85,
  AUTHOR = {A. Srivastava and D. Oxley and A. Srivastava},
  TITLE = {{An (Other) Integration of Logic and Functional Programming}},
  BOOKTITLE = {Proceedings of the Symposium on Logic Programming},
  YEAR = 1985,
  PAGES = {254--260},
  KEYWORDS = {scheme}}
%%%%%%%%%%%%%%%%  ADDRESS = {},
@TECHREPORT{steele76,
  AUTHOR = {G.L. Steele Jr. and G.J. Sussman},
  TITLE = {{Lambda, the Ultimate Imperative}},
  TYPE = aim,
  NUMBER = 353,
  INSTITUTION = ail,
  ADDRESS = cm,
  YEAR = 1976,
  KEYWORDS = {scheme}}
@TECHREPORT{steele76a,
  AUTHOR = {G.L. Steele Jr.},
  TITLE = {{Lambda, the Ultimate Declarative}},
  TYPE = aim
  NUMBER = 379,
  INSTITUTION = ail,
  ADDRESS = cm,
  YEAR = 1976,
  KEYWORDS = {scheme}}
@INPROCEEDINGS{steele77,
  AUTHOR = {G.L. Steele Jr.},
  TITLE = {{Debunking the ``Expensive Procedure Call'' Myth,
            or Procedure Call Implementations Considered Harmful,
            or LAMBDA, the Ultimate GOTO}},
  YEAR = 1977,
  PAGES = {153--162},
  KEYWORDS = {scheme}}
%%%%%%%%%%%%%%%%  BOOKTITLE = {ACM Conference Proceedings}, ????
%%%%%%%%%%%%%%%%  ADDRESS = {},
@INPROCEEDINGS{steele77a,
  AUTHOR = {G.L. Steele Jr.},
  TITLE = {{Macaroni is Better than Spaghetti}},
  BOOKTITLE = {{Proceedings of the Symposium
                on Artificial Intelligence and Programming Languages}},
  YEAR = 1977,
  PAGES = {60--66},
  KEYWORDS = {scheme}}
%%%%%%%%%%%%%%%%  ADDRESS = {},
@TECHREPORT{steele78,
  AUTHOR = {G.L. Steele Jr. and G.J. Sussman},
  TITLE = {{The Revised Report on Scheme, a Dialect of Lisp}},
  TYPE = aim,
  NUMBER = 452,
  INSTITUTION = ail,
  ADDRESS = cm,
  YEAR = 1978,
  KEYWORDS = {scheme}}
@TECHREPORT{steele78a,
  AUTHOR = {G.L. Steele Jr.},
  TITLE = {{Rabbit: A Compiler for Scheme}},
  NUMBER = 474,
  INSTITUTION = ail,
  ADDRESS = cm,
  YEAR = 1978,
  KEYWORDS = {scheme}}
@TECHREPORT{steele78a,
  AUTHOR = {G.L. Steele Jr. and G.J. Sussman},
  TITLE = {{The Art of the Interpreter,
            or the Modularity Complex (parts zero, one, and two)}},
  TYPE = aim,
  NUMBER = 453,
  INSTITUTION = ail,
  YEAR = 1978,
  KEYWORDS = {scheme}}
@TECHREPORT{steele79,
  AUTHOR = {G.L. Steele Jr. and G.J. Sussman},
  TITLE = {{Design of LISP-Based Processors
            or, SCHEME: A Dielectric LISP
            or, Finite Memories Considered Harmful
            or, LAMBDA: The Ultimate Opcode}},
  TYPE = aim,
  NUMBER = 514,
  INSTITUTION = ail,
  ADDRESS = cm,
  YEAR = {1979},
  KEYWORDS = {scheme}}
@INCOLLECTION{steele80,
  AUTHOR = {G.L. Steele Jr.},
  TITLE = {{Compiler Optimization Based on Viewing LAMBDA as RENAME + GOTO}},
  BOOKTITLE = {{AI: An MIT Perspective}},
  EDITOR = {R.H. Brown},
  PUBLISHER = mitp,
  ADDRESS = cm,
  YEAR = 1980,
  KEYWORDS = {scheme}}
@INPROCEEDINGS{steele80a,
  AUTHOR = {G.L. Steele Jr. and G.J. Sussman},
  TITLE = {{The Dream of a Lifetime: A Lazy Variable Extent Mechanism}},
  BOOKTITLE = lc80,
  YEAR = 1980,
  PAGES = {163--172},
  KEYWORDS = {scheme}}
%%%%%%%%%%%%%%%%  ADDRESS = {},
@ARTICLE{steele80b,
  AUTHOR = {G.L. Steele Jr. and G.J. Sussman},
  TITLE = {{Design of a Lisp-Based Processor}},
  JOURNAL = cacm,
  VOLUME = 23,
  NUMBER = 11,
  PAGES = {628--645},
  YEAR = 1980,
  KEYWORDS = {scheme}}
@TECHREPORT{sussman75,
  AUTHOR = {G.J. Sussman and G.L. Steele Jr.},
  TITLE = {{Scheme: An Interpreter for Extended Lambda Calculus}},
  TYPE = aim,
  NUMBER = 349,
  INSTITUTION = ail,
  ADDRESS = cm,
  YEAR = 1975,
  KEYWORDS = {scheme}}
@ARTICLE{sussman81,
  AUTHOR = {G.J. Sussman and J. Holloway and G.L. Steele Jr. and A. Bell},
  TITLE = {{Scheme-79 --- Lisp on a Chip}},
  VOLUME = 14,
  NUMBER = 7,
  YEAR = 1981,
  PAGES = {10--21},
  KEYWORDS = {scheme}}
%%%%%%%%%%%%%%%%  JOURNAL = {IEEE Computer},

% ---- wwww

@ARTICLE{wand78,
  AUTHOR = {M. Wand},
  TITLE = {{Continuation-Based Program Transformation Strategies}},
  JOURNAL = jacm,
  VOLUME = 27,
  NUMBER = 1,
  YEAR = 1978,
  PAGES = {174--180},
  KEYWORDS = {scheme}}
@INPROCEEDINGS{wand80,
  AUTHOR = {M. Wand},
  TITLE = {{Continuation-Based Multiprocessing}},
  BOOKTITLE = lc80,
  YEAR = 1980,
  PAGES = {19--28},
  KEYWORDS = {scheme}}
%%%%%%%%%%%%%%%%  ADDRESS = {},
@INCOLLECTION{wand86,
  AUTHOR = {M. Wand},
  TITLE = {{From Interpreter to Compiler: A Representational Derivation}},
  BOOKTITLE = {{Programs as Data Objects}},
  PUBLISHER = {Springer-Verlag Lecture Notes},
  YEAR = 1986,
  KEYWORDS = {scheme}}
%%%%%%%%%%%%%%%%  PAGES = {},

---- cut here ---- cut here ---- cut here ---- cut here ---- cut here ----
-- 
Ge'rald MASINI        CRIN (Centre de Recherche en Informatique de Nancy)
uucp:  masini@crin.crin.fr
post:  CRIN   B.P. 239   54506 Vandoeuvre-les-Nancy Cedex   FRANCE
phone: +33  83.91.21.45

Received: from Think.COM (TCP 1201000006) by MC.LCS.MIT.EDU 30 Aug 88 13:19:41 EDT
Return-Path: <gls@Think.COM>
Received: from joplin.think.com ([192.31.181.10]) by Think.COM; Tue, 30 Aug 88 13:10:57 EDT
Received: by joplin.think.com; Tue, 30 Aug 88 13:17:38 EDT
Date: Tue, 30 Aug 88 13:17:38 EDT
From: gls@Think.COM
Message-Id: <8808301717.AA28656@joplin.think.com>
To: oz@yunexus.arpa
Cc: Think.COM!gls@ai.toronto.edu, scheme@mc.lcs.mit.edu
In-Reply-To: Ozan Yigit's message of Mon, 29 Aug 88 14:34:39 EDT <8808291834.AA15954@yunexus.UUCP>
Subject: Scheme Bibliography (Aug. 1988)

   Date: 	Mon, 29 Aug 88 14:34:39 EDT
   From: oz@yunexus.arpa (Ozan Yigit)
   ...
   Ps: I have ordered a copy of your rabbit report from NTIS. Do you
   happen to have a machine-readable copy of the compiler + vm ??

No, I'm afraid not.  Unless they still exist on old MIT backup
tapes, they're gone.
--Guy

Date: Tue, 23 Aug 88 11:02:34 EDT
From: Scheme Requestee <SCHREQ@MC.LCS.MIT.EDU>
Subject:  info-cscheme-request
To: SCHEME@MC.LCS.MIT.EDU
Message-ID: <470902.880823.SCHREQ@MC.LCS.MIT.EDU>

Date: Mon, 15 Aug 88 11:06:19 pdt
From: Eric Benson <edsel!eb@labrea.stanford.edu>
To:   scheme-request@mc.lcs.mit.edu
Re:   Periodic noise message; list policy reiterated

To be added to info-cscheme, send mail to

info-cscheme-request@zurich.ai.mit.edu

not

info-cscheme-maintainer@zurich.ai.mit.edu

The latter address bounces back.  You should update your general
information message.

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 22 Aug 88 23:57:11 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA00208@BLOOM-BEACON.MIT.EDU>; Mon, 22 Aug 88 23:54:52 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 23 Aug 88 02:01:10 GMT
From: lee@louie.udel.edu  (Hong Ryul Lee)
Organization: University of Delaware
Subject: Parallel Scheme(Lisp) on Sequent
Message-Id: <3791@louie.udel.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


 We are trying to install MIT 'fscheme' on the Sequent parallel processor
 to run LISP programs.

 If someone has already been using 'fscheme' or any other parallel LISP on
 Sequent, we would like to receive some information.

 Or if on going of installation, we would like to exchange informations.

 Also if you know anyone working parallel Lisp on Sequent, please let me know 
 his/her name and address.
 

 Hong Lee  (lee@louie.udel.edu)

 Dept of Computer Science
 University of Delaware

Received: from Think.COM (TCP 1201000006) by MC.LCS.MIT.EDU 22 Aug 88 14:30:59 EDT
Return-Path: <gls@Think.COM>
Received: from joplin.think.com ([192.31.181.10]) by Think.COM; Mon, 22 Aug 88 14:30:09 EDT
Received: by joplin.think.com; Mon, 22 Aug 88 14:29:52 EDT
Date: Mon, 22 Aug 88 14:29:52 EDT
From: gls@Think.COM
Message-Id: <8808221829.AA03276@joplin.think.com>
To: attcan!utzoo!yunexus!oz@uunet.uu.net
Cc: scheme@mc.lcs.mit.edu
In-Reply-To: (Ozan Yigit's message of 16 Aug 88 22:01:38 GMT <842@yunexus.UUCP>
Subject: Scheme Bibliography (Aug. 1988)

This is a wonderful resource!  Thank you for your efforts.

However, there is a bug.  I spell my name with no comma before
the "Jr.".  (Leslie Lamport cites this fact in the LaTeX manual,
page 142.  Unfortunately his solution to the problem is incorrect.
The correct inverted form is "Steele, Guy L., Jr." and not
"Steele Jr., Guy L.")

--Guy

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 20 Aug 88 06:45:36 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA07576@BLOOM-BEACON.MIT.EDU>; Sat, 20 Aug 88 06:39:30 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 19 Aug 88 17:18:00 GMT
From: attcan!utzoo!yunexus!oz@uunet.uu.net  (Ozan Yigit)
Organization: York U. Computing Services - Magic Group
Subject: Re: Rabbit report. (NTIS)
Message-Id: <847@yunexus.UUCP>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

Many thanks to those who have responded to my query. I decided
to order it from NTIS, as it would have been just as costly
to have someone else photocopy their own report and mail it to
me. In case others are interested, here is the info:

NTIS# :	ADA061996			PHONE : (703) 487 4650
COST  :	25.00 (paper copy)
PAGES :	276

%A Guy Lewis Steele, Jr.
%T Rabbit: a Compiler for Scheme
%R MIT Artificial Intelligence Laboratory Technical Report 474
%C Cambridge, Mass.
%D May 1978

oz
-- 
Crud that is not paged	        | Usenet: ...!utzoo!yunexus!oz
is still crud. 			|   ...uunet!mnetor!yunexus!oz
	andrew@alice		| Bitnet: oz@[yulibra|yuyetti]
				| Phonet: +1 416 736-5257x3976

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 19 Aug 88 06:29:49 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA05816@BLOOM-BEACON.MIT.EDU>; Fri, 19 Aug 88 06:22:16 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 18 Aug 88 03:15:22 GMT
From: attcan!utzoo!yunexus!oz@uunet.uu.net  (Ozan Yigit)
Organization: York U. Computing Services - Magic Group
Subject: Scheme biblio. (acknowledgements)
Message-Id: <844@yunexus.UUCP>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

In my previous posting, I forgot to acknowledge the contributions
of Ken Dickey, Dan Friedman and Mark MacLennan. Also forgot to mention
that the core of the bibliography was shamelessy snarfed [months ago]
from R^3 Report on Scheme.

Many thnx. Looking forward to additional contributions: Tech Reports,
Articles, Implementation Descriptions, whatever. Scheme all the way.

oz
-- 
Crud that is not paged	        | Usenet: ...!utzoo!yunexus!oz
is still crud. 			|   ...uunet!mnetor!yunexus!oz
	andrew@alice		| Bitnet: oz@[yulibra|yuyetti]
				| Phonet: +1 416 736-5257x3976

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 17 Aug 88 07:16:33 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA11198@BLOOM-BEACON.MIT.EDU>; Wed, 17 Aug 88 07:03:41 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 16 Aug 88 22:01:38 GMT
From: attcan!utzoo!yunexus!oz@uunet.uu.net  (Ozan Yigit)
Organization: York U. Computing Services - Magic Group
Subject: Scheme Bibliography (Aug. 1988)
Message-Id: <842@yunexus.UUCP>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

BIB/REFER Database on SCHEME

This posting contains is a reasonable bibliography database on Scheme
(a crystal in the muddy language landscape), BIB/REFER format,
containing 82 entries sorted by date and first author, for your
perusal, corrections and enjoyment. I do not consider it complete
nor correct, hence your contributions and/or corrections are
gratefully accepted.

[Note: this posting also contains a r2bib (BibTeX) translation of the
database. I think BibTeX format is losing. If anyone knows of a better
bibliography format suitable for TeX, please let me know.]

So, here it is for your enjoyment. Happy Scheming...	oz

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#		"End of shell archive."
# Contents:  tags.doc scheme.bib scheme.bibtex
# Wrapped by oz@yunexus on Tue Aug 16 18:00:48 1988
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'tags.doc' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'tags.doc'\"
else
echo shar: Extracting \"'tags.doc'\" \(422 characters\)
sed "s/^X//" >'tags.doc' <<'END_OF_FILE'
XBIB (UofArizona) Field Tags
X
X%A	- Author's name
X%B	- Title of the book containing item
X%C	- City of publication
X%D	- Date
X%E	- Editor(s) of book containing item
X%F 	- Caption
X%G	- Government (NTIS) ordering number
X%I	- Issuer (publisher)
X%J	- Journal name
X%K	- Keys for searching
X%N	- Issue number
X%O	- Other information
X%P	- Page(s) of article
X%R	- Technical report number
X%S	- Series title
X%T	- Title
X%V	- Volume number
END_OF_FILE
if test 422 -ne `wc -c <'tags.doc'`; then
    echo shar: \"'tags.doc'\" unpacked with wrong size!
fi
# end of 'tags.doc'
fi
if test -f 'scheme.bib' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'scheme.bib'\"
else
echo shar: Extracting \"'scheme.bib'\" \(15607 characters\)
sed "s/^X//" >'scheme.bib' <<'END_OF_FILE'
X
X%A John Reynolds
X%T Definitional Interpreters for Higher Order Programming Languages
X%J ACM Conference Proceedings
X%P 717-740
X%I ACM
X%D 1972
X
X%A Gerald Jay Sussman
X%A Guy Lewis Steele, Jr.
X%T Scheme: an Interpreter for Extended Lambda Calculus
X%R MIT Artificial Intelligence Memo 349
X%C Cambridge, Mass.
X%D December 1975
X
X%A Guy Lewis Steele, Jr.
X%A Gerald Jay Sussman
X%T Lambda, the Ultimate Imperative
X%R MIT Artificial Intelligence Memo 353
X%C Cambridge, Mass.
X%D March 1976
X%K imperative
X
X%A Guy Lewis Steele, Jr.
X%T Lambda, the Ultimate Declarative
X%R MIT Artificial Intelligence Memo 379
X%C Cambridge, Mass.
X%D November 1976
X%K declarative
X
X%A Guy Lewis Steele, Jr.
X%T Debunking the ``Expensive Procedure Call'' Myth, or Procedure Call
XImplementations Considered Harmful, or LAMBDA, the Ultimate GOTO
X%J ACM Conference Proceedings
X%P 153-162
X%I ACM
X%D 1977
X
X%A Guy Lewis Steele, Jr.
X%T Macaroni is Better than Spaghetti
X%J Proceedings of the Symposium on Artificial Intelligence and
XProgramming Languages
X%P 60-66
X%O Special joint issue of SIGPLAN Notices 12(8) and SIGART Newsletter 64
X%D August 1977
X
X%A Mitchell Wand
X%T Continuation-Based Program Transformation Strategies
X%J Journal of the ACM
X%V 27
X%N 1
X%P 174-180
X%D 1978
X
X%A Guy Lewis Steele, Jr.
X%A Gerald Jay Sussman
X%T The Revised Report on Scheme, a Dialect of Lisp
X%R MIT Artificial Intelligence Memo 452
X%C Cambridge, Mass.
X%D January 1978
X
X%A Guy Lewis Steele, Jr.
X%T Rabbit: a Compiler for Scheme
X%R MIT Artificial Intelligence Laboratory Technical Report 474
X%C Cambridge, Mass.
X%D May 1978
X
X%A Guy Lewis Steele, Jr.
X%A Gerald Jay Sussman
X%T The Art of the Interpreter, or the Modularity Complex
X(parts zero, one, and two)
X%R MIT Artificial Intelligence Memo 453
X%C Cambridge, Mass.
X%D May 1978
X%K modularity
X
X%A Drew McDermott
X%T An Efficient Environment Allocation Scheme in an Interpreter
Xfor a Lexically-Scoped Lisp
X%J Conference Record of the 1980 Lisp Conference
X%P 154-162
X%I The Lisp Conference, P.O. Box 487, Redwood Estates CA.
X%D 1980
X%O Proceedings reprinted by ACM
X
X%A Steven S. Muchnick
X%A Uwe F. Pleban
X%T A Semantic Comparison of Lisp and Scheme
X%J Conference Record of the 1980 Lisp Conference
X%P 56-65
X%I The Lisp Conference, P.O. Box 487, Redwood Estates CA.
X%D 1980
X
X%A Guy Lewis Steele, Jr.
X%T Compiler Optimization Based on Viewing LAMBDA as RENAME + GOTO
X%B AI: An MIT Perspective
X%E Patrick Henry Winston
X%E Richard Henry Brown
X%I MIT Press
X%C Cambridge, Mass.
X%D 1980
X
X%A Guy Lewis Steele, Jr.
X%A Gerald Jay Sussman
X%T The Dream of a Lifetime: a Lazy Variable Extent Mechanism
X%J Conference Record of the 1980 Lisp Conference
X%P 163-172
X%I The Lisp Conference
X%D 1980
X
X%A Mitchell Wand
X%T Continuation-Based Multiprocessing
X%J Conference Record of the 1980 Lisp Conference
X%P 19-28
X%I The Lisp Conference
X%D 1980
X
X%A Guy Lewis Steele, Jr.
X%A Gerald Jay Sussman
X%T Design of a Lisp-based Processor
X%J CACM
X%V 23
X%N 11
X%P 628-645
X%D November 1980
X
X%A Gerald Jay Sussman
X%A Jack Holloway
X%A Guy Lewis Steele, Jr.
X%A Alan Bell
X%T Scheme-79 - Lisp on a Chip
X%J IEEE Computer
X%V 14
X%N 7
X%P 10-21
X%D July 1981
X%I IEEE
X
X%A John Batali
X%A Edmund Goodhue
X%A Chris Hanson
X%A Howie Shrobe
X%A Richard M. Stallman
X%A Gerald Jay Sussman
X%T The Scheme-81 Architecture - System and Chip
X%J Proceedings, Conference on Advanced Research in VLSI
X%P 69-77
X%E Paul Penfield, Jr.
X%C Artech House, Dedham MA.
X%D 1982
X%K scheme81
X
X%A Peter Henderson
X%T Functional Geometry
X%J Conference Record of the 1982 ACM Symposium on Lisp and
XFunctional Programming
X%P 179-187
X%D 1982
X
X%A Jonathan A. Rees
X%A Norman I. Adams
X%T T: A Dialect of Lisp or, LAMBDA: The Ultimate Software Tool
X%J Conference Record of the 1982 ACM Symposium on Lisp and
XFunctional Programming
X%P 114-122
X%D 1982
X
X%A Gerald Jay Sussman
X%T LISP, Programming and Implementation
X%B Functional Programming and its Applications
X%E Darlington, Henderson, Turner
X%I Cambridge University Press
X%C London
X%D 1982
X
X%A Pee Hong Chen 
X%A W.Y. Chi
X%A E.M. Ost
X%A L.D. Sabbagh 
X%A G. Springer
X%T Scheme Graphics Reference Manual
X%R Computer Science Technical Report No. 145
X%I Indiana University 
X%C Bloomington, Indiana
X%D August 1983
X
X%A Pee Hong Chen
X%A Daniel P. Friedman
X%T Prototyping data flow by translation into Scheme
X%R Computer Science Technical Report #147
X%I Indiana University
X%C Bloomington, Indiana
X%D August 1983
X
X%A Carol Fessenden
X%A William Clinger
X%A Daniel P. Friedman
X%A Christopher T. Haynes
X%T Scheme 311 version 4 Reference Manual
X%R Computer Science Technical Report 137
X%I Indiana University
X%C Bloomington, Indiana
X%D February 1983
X%O Superceded by Computer Science Technical Report 153, 1985
X
X%A William Clinger
X%T The Scheme 311 compiler: An Exercise in Denotational Semantics
X%J Conference Record of the 1984 ACM Symposium on Lisp and
XFunctional Programming
X%P 356-364
X%D 1984
X%K comp311
X
X%A Daniel P. Friedman
X%A Christopher T. Haynes
X%A Eugene E. Kohlbecker
X%T Programming with Continuations
X%B Program Transformation and Programming Environments
X%P 263-274
X%E P. Pepper
X%I Springer-Verlag
X%D 1984
X
X%A Christopher T. Haynes
X%A Daniel P. Friedman
X%T Engines Build Process Abstractions
X%J Conference Record of the 1984 ACM Symposium on Lisp and
XFunctional Programming
X%C Austin, TX.
X%P 18-24
X%D 1984
X
X%A Christopher T. Haynes
X%A Daniel P. Friedman
X%A Mitchell Wand
X%T Continuations and Coroutines
X%J Conference Record of the 1984 ACM Symposium on Lisp and
XFunctional Programming
X%C Austin, TX.
X%P 293-298
X%D 1984
X
X%A Daniel P. Friedman
X%A Mitchell Wand
X%T Reification: reflection without metaphysics
X%J Conference Record of the 1984 ACM Symposium on LISP and Functional
XProgramming
X%C Austin, TX.
X%P 348-355
X%D August 1984
X
X%A Jonathan A. Rees
X%A Norman I. Adams
X%A James R. Meehan
X%T The T manual, fourth edition
X%I Yale University Computer Science Department
X%D January 1984
X
X%A Guillermo J. Rozas
X%T Liar, an Algol-like Compiler for Scheme
X%I S. B. Thesis, MIT Department of Electrical Engineering and Computer
XScience
X%D January 1984
X
X%T MIT Scheme Manual, Seventh Edition
X%I Department of Electrical Engineering and Computer Science, MIT
X%C Cambridge, Mass.
X%D September 1984
X
X%T MacScheme Reference Manual
X%I Semantic Microsystems
X%C Sausalito, Calif.
X%D 1985
X
X%A Harold Abelson
X%A Gerald Jay Sussman
X%A Julie Sussman
X%T Structure and Interpretation of Computer Programs
X%I MIT Press
X%C Cambridge, Mass.
X%D 1985
X%K sicp
X
X%A William Clinger
X%A Daniel P. Friedman
X%A Mitchell Wand
X%T A Scheme for a Higher-Level Semantic Algebra
X%B Algebraic Methods in Semantics
X%E J. Reynolds, M. Nivat
X%P 237-250
X%I Cambridge University Press
X%C London
X%D 1985
X
X%A Amitabh Srivastava
X%A Don Oxley
X%A Aditya Srivastava
X%T An (other) Integration of Logic and Functional Programming
X%J Proceedings of the Symposium on Logic Programming
X%P 254-260
X%I IEEE
X%D 1985
X
X%E William Clinger
X%T The Revised Revised Report on Scheme, or An Uncommon Lisp
X%R MIT Artificial Intelligence Memo 848
X%C Cambridge, Mass.
X%O Also published as Computer Science Department Technical Report 174,
XIndiana University, June 1985
X%D August 1985
X%K rrrs
X
X%A Daniel P. Friedman
X%A Christopher T. Haynes
X%T Constraining Control
X%J Proceedings of the Twelfth Annual Symposium on Principles of
XProgramming Languages
X%C New Orleans, LA.
X%P 245-254
X%I ACM
X%D January 1985
X
X%A Daniel P. Friedman
X%A Christopher T. Haynes
X%A Eugene E. Kohlbecker
X%A Mitchell Wand
X%T Scheme 84 Interim Reference Manual
X%R Computer Science Technical Report 153
X%I Indiana University
X%C Bloomington, Indiana
X%D January 1985
X%K scheme84
X
X%A Peehong Chen
X%A L. David Sabbagh
X%T Scheme as an Interactive Graphics Programming Environment
X%R Computer Science Technical Report No. 166
X%I Indiana University
X%C Bloomington, Indiana
X%D March 1985
X
X%T TI Scheme Language Reference Manual
X%I Texas Instruments, Inc.
X%O Preliminary version 1.0
X%D November 1985
X
X%A Michael A. Eisenberg
X%T Bochser: An Integrated Scheme Programming System
X%R MIT Computer Science Technical Report 349
X%C Cambridge, Mass.
X%D October 1985
X%K bochser
X
X%T Transliterating Prolog into Scheme
X%A Matthias Felleisen
X%R Computer Science Technical Report #182
X%I Indiana University
X%C Bloomington, Indiana
X%D October 1985
X
X%A David H. Bartley
X%A John C. Jensen
X%T The Implementation of PC Scheme
X%J Proceedings of the 1986 ACM Conference on Lisp
Xand Functional Programming
X%P 86-93
X%D 1986
X%K pcscheme
X
X%A R. Kent Dybvig
X%A Daniel P. Friedman
X%A Christopher T. Haynes
X%T Expansion-Passing style: Beyond Conventional Macros
X%J Proceedings of the 1986 ACM Conference on Lisp and
XFunctional Programming
X%P 143-150
X%D 1986
X
X%A Marc Feeley
X%A Guy LaPalme
X%T Closure Generation based on viewing LAMBDA as EPSILON plus COMPILE
X%O Submitted for Publication
X%D 1986
X
X%A Matthias Felleisen
X%A Daniel P. Friedman
X%T A Closer Look At Export and Import Statements
X%J Journal of Computer Languages
X%V 11
X%N 1
X%P 29-37
X%I Pergamon Press
X%D 1986
X
X%A Daniel P. Friedman
X%A Matthias Felleisen
X%T The Little LISPer: Second Edition
X%I Science Research Associates, Inc.
X%C Palo Alto, California
X%D 1986
X
X%A Christopher T. Haynes
X%A Daniel P. Friedman
X%A Mitchell Wand
X%T Obtaining Coroutines With Continuations
X%J Journal of Computer Languages
X%V 11
X%N 3/4
X%P 143-153
X%I Pergamon Press
X%D 1986
X
X%A Mitchell Wand
X%T Finding the Source of Type Errors
X%J Conference Record of the Thirteenth Annual Symposium on
XPrinciples of Programming Languages
X%P 38-43
X%I ACM
X%C St. Peterburg, Fla.
X%D 1986
X
X%A Mitchell Wand
X%T From Interpreter to Compiler: A Representational Derivation
X%B Programs as Data Objects
X%I Springer-Verlag Lecture Notes
X%D 1986
X
X%A Matthias Felleisen
X%A Daniel P. Friedman
X%T Control operators, the SECD-machine, and the lambda-calculus
X%J 3rd Working Conference on the Formal Description of
XProgramming Concepts
X%C Ebberup, Denmark
X%P 193-219
X%D August 1986
X
X%A Eugene E. Kohlbecker
X%T Syntactic Extensions in the Programming Language Lisp
X%R Computer Science Technical Report #199 (PhD Dissertation)
X%I Indiana University
X%C Bloomington, Indiana
X%D August 1986
X
X%A Eugene E. Kohlbecker
X%A Daniel P. Friedman
X%A Matthias Felleisen
X%A Bruce Duba
X%T Hygienic macro expansion
X%J Symposium on LISP and Functional Programming
X%P 151-161
X%D August 1986
X%O To appear in Lisp and Symbolic Computation
X
X%A Mitchell Wand
X%T The mystery of the tower revealed: a non-reflective
Xdescription of the reflective tower
X%J Proceedings of the 1986 ACM Symposium on LISP and Functional Programming
X%P 298-307
X%D August 1986
X
X%E Jonathan A. Rees
X%E William Clinger
X%T Revised^3 Report on the Algorithmic Language Scheme
X%J ACM Sigplan Notices
X%V 21
X%N 12
X%D December 1986
X
X%A Christopher T. Haynes
X%T Logic Continuations
X%J Proceedings of the Third International Conference on
XLogic Programming
X%P 671-685
X%I Springer-Verlag
X%D Jul 1986
X
X%A Matthias Felleisen
X%A Daniel P. Friedman
X%A Eugene E. Kohlbecker
X%A Bruce Duba
X%T Reasoning with Continuations
X%J Proceedings of the Symposium on Logic in Computer Science
X%P 131-141
X%I IEEE Computer Society Press
X%C Washigton DC
X%D June 1986
X
X%A David Kranz
X%A Richard Kelsey
X%A Jonathan A. Rees
X%A Paul Hudak
X%A James Philbin
X%A Norman I. Adams
X%T Orbit: An Optimizing Compiler for Scheme
X%J Proceedings of the SIGPLAN '86 Symposium on Compiler
XConstruction
X%P 219-233
X%I ACM
X%O Published as SIGPLAN Notices 21(7), July 1986
X%D June 1986
X%K orbit
X
X%A Marc Feeley
X%T Deux Approches a' L'implantation du Language Scheme
X%I M.Sc. Thesis, De'partement d'Informatique et de Recherche
XOpe'rationelle, University of Montreal
X%D May 1986
X
X%A R. Kent Dybvig
X%T The Scheme Programming Language
X%I Prentice-Hall, Inc.
X%C Englewood Cliffs, New Jersey
X%D 1987
X%K splang
X
X%A Marc Feeley
X%A Guy LaPalme
X%T Using Cloures for Code Generation
X%J Journal of Computer Languages
X%V 12
X%N 1
X%P 47-66
X%I Pergamon Press
X%D 1987
X
X%A Matthias Felleisen
X%T Reflections on Landin's J-Operator: A Partly Historical Note
X%J Journal of Computer Languages
X%V 12
X%N 3/4
X%P 197-207
X%I Pergamon Press
X%D 1987
X
X%A Matthias Felleisen
X%A Daniel P. Friedman
X%T A Reduction Semantics for Imperative Higher-Order Languages
X%J Parallel Architectures and Languages Europe
X%E De Bakker, Nijman and Treleaven
X%B Lecture Notes in Computer Science
X%V 259
X%I Springer-Verlag
X%C Berlin
X%P 206-223
X%D 1987
X
X%T A syntactic theory of sequential control
X%A Matthias Felleisen
X%A Daniel P. Friedman
X%A Eugene E. Kohlbecker
X%A Bruce Duba
X%J Theoretical Computer Science
X%V 52
X%P 205-237
X%D 1987
X
X%A Daniel P. Friedman
X%A Matthias Felleisen
X%T The Little LISPer
X%I MIT Press
X%D 1987
X%O Trade Edition
X%K littlelisper
X
X%A Christopher T. Haynes
X%A Daniel P. Friedman
X%T Abstracting Timed Preemption with Engines
X%J Journal of Computer Languages
X%V 12
X%N 2
X%P 109-121
X%I Pergamon Press
X%D 1987
X
X%A Matthias Felleisen
X%T The Calculi of lambda-v-cs conversion: a syntactic
Xtheory of control and state in imperative higher-order programming
Xlanguages
X%R Computer Science Technical Report #226. (PhD Dissertation)
X%I Indiana University
X%C Bloomington, Indiana
X%D August 1987
X
X%A Matthias Felleisen
X%A Daniel P. Friedman
X%A Bruce Duba
X%A John Merrill
X%T Beyond Continuations
X%R Computer Science Dept. Technical Report #216
X%I Indiana University
X%C Bloomington, Indiana
X%D February, 1987
X
X%A Matthias Felleisen
X%A Daniel P. Friedman
X%T A calculus for assignments in higher-order languages
X%J Conference Record of the 14th Annual ACM Symposium on Principles of
XProgramming Languages
X%C Munich, West Germany
X%P 314-345
X%D January 1987
X
X%A Matthias Felleisen
X%A Daniel P. Friedman
X%T A Syntactic Theory of Sequential State
X%R Computer Science Dept. Technical Report #230
X%I Indiana University
X%C Bloomington, Indiana
X%D October 1987
X
X%T Embedding continuations in procedural objects
X%A Christopher T. Haynes
X%A Daniel P. Friedman
X%J ACM Transactions on Programming Languages and Systems
X%V 9
X%N 4
X%P 582-598
X%D October 1987
X
X%A Michael Eisenberg
X%T Programming In Scheme
X%E Harold Abelson
X%I Scientific Press
X%C Redwood City, CA
X%D 1988
X
X%A Mitchell Wand
X%A Daniel P. Friedman
X%T The Mystery of the Tower Revealed: A Non-Reflective
XDescription of the Reflective Tower
X%B Meta-Level Architectures and Reflection
X%E P. Maes and D. Nardi
X%I Elsevier Sci. Publishers B.V. (North Holland)
X%P 111-134
X%D 1988
X%O Also to appear in Lisp and Symbolic Computation
X
X%A Daniel P. Friedman
X%A Mitchell Wand
X%A Christopher T. Haynes
X%A Eugene E. Kohlbecker
X%T Programming Languages: Their Abstractions, Representations,
Xand Implementations
X%I M.I.T. Press and McGraw Hill
X%D 1988-1989
X%O in progress
X
X%A George Springer
X%A Daniel P. Friedman
X%T An Introduction to the Art of Programming in Scheme
X%D 1988-1989
X%O in progress
X
X%A Harold Abelson
X%A Gerald Jay Sussman
X%T Lisp: A Langauge for Stratified Design
X%J BYTE
X%D February 1988
X%P 207-218
X
X%A William Clinger
X%T Semantics of Scheme
X%J BYTE
X%D February 1988
X%P 221-227
X
X%A Alan Bawden
X%A Jonathan Rees
X%T Syntactic Closures
X%J Proceedings of the 1988 ACM Symposium on LISP
Xand Functional Programming
X%C Salt Lake City, Utah.
X%D July 1988
X
X%A Matthias Felleisen
X%A Mitchell Wand
X%A Daniel P. Friedman
X%A Bruce Duba
X%T Abstract Continuations: A Mathematical Semantics for
XHandling Functional Jumps
X%J Proceedings of the 1988 ACM Symposium on LISP
Xand Functional Programming
X%C Salt Lake City, Utah.
X%D July 1988
X
X%A John Franco
X%A Daniel P. Friedman
X%T Creating Efficient Programs by Exchanging Data for Procedures
X%R Computer Science Technical Report #245
X%I Indiana University
X%C Bloomington, Indiana
X%D March 1988
X
X%A Mitchell Wand
X%A Daniel P. Friedman
X%T Compiling lambda expressions using continuations and
Xfactorizations
X%J Computer Languages 3
X%D 241-263
X%D 1978
END_OF_FILE
if test 15607 -ne `wc -c <'scheme.bib'`; then
    echo shar: \"'scheme.bib'\" unpacked with wrong size!
fi
# end of 'scheme.bib'
fi
if test -f 'scheme.bibtex' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'scheme.bibtex'\"
else
echo shar: Extracting \"'scheme.bibtex'\" \(20265 characters\)
sed "s/^X//" >'scheme.bibtex' <<'END_OF_FILE'
X@article{key1,
X	author =	"John Reynolds",
X	year =		"1972",
X	publisher =	"ACM",
X	journal =	"ACM Conference Proceedings",
X	pages =		"717-740",
X	title =		"Definitional Interpreters for Higher Order Programming Languages"
X}
X
X@techreport{key2,
X	author =	"Gerald Jay Sussman and Guy Lewis Steele, Jr.",
X	address =	"Cambridge, Mass.",
X	year =		"December 1975",
X	title =		"Scheme: an Interpreter for Extended Lambda Calculus"
X}
X
X@techreport{imperative,
X	author =	"Guy Lewis Steele, Jr. and Gerald Jay Sussman",
X	address =	"Cambridge, Mass.",
X	year =		"March 1976",
X	title =		"Lambda, the Ultimate Imperative"
X}
X
X@techreport{declarative,
X	author =	"Guy Lewis Steele, Jr.",
X	address =	"Cambridge, Mass.",
X	year =		"November 1976",
X	title =		"Lambda, the Ultimate Declarative"
X}
X
X@article{key5,
X	author =	"Guy Lewis Steele, Jr.",
X	year =		"1977",
X	publisher =	"ACM",
X	journal =	"ACM Conference Proceedings",
X	pages =		"153-162",
X	title =		"Debunking the ``Expensive Procedure Call'' Myth, or Procedure Call Implementations Considered Harmful, or LAMBDA, the Ultimate GOTO"
X}
X
X@article{key6,
X	author =	"Guy Lewis Steele, Jr.",
X	year =		"August 1977",
X	journal =	"Proceedings of the Symposium on Artificial Intelligence and Programming Languages",
X	pages =		"60-66",
X	title =		"Macaroni is Better than Spaghetti"
X}
X
X@article{key7,
X	author =	"Mitchell Wand",
X	year =		"1978",
X	journal =	"Journal of the ACM",
X	number =	"1",
X	pages =		"174-180",
X	title =		"Continuation-Based Program Transformation Strategies",
X	volume =	"27"
X}
X
X@techreport{key8,
X	author =	"Guy Lewis Steele, Jr. and Gerald Jay Sussman",
X	address =	"Cambridge, Mass.",
X	year =		"January 1978",
X	title =		"The Revised Report on Scheme, a Dialect of Lisp"
X}
X
X@techreport{key9,
X	author =	"Guy Lewis Steele, Jr.",
X	address =	"Cambridge, Mass.",
X	year =		"May 1978",
X	title =		"Rabbit: a Compiler for Scheme"
X}
X
X@techreport{modularity,
X	author =	"Guy Lewis Steele, Jr. and Gerald Jay Sussman",
X	address =	"Cambridge, Mass.",
X	year =		"May 1978",
X	title =		"The Art of the Interpreter, or the Modularity Complex (parts zero, one, and two)"
X}
X
X@article{key11,
X	author =	"Drew McDermott",
X	year =		"1980",
X	publisher =	"The Lisp Conference, P.O. Box 487, Redwood Estates CA.",
X	journal =	"Conference Record of the 1980 Lisp Conference",
X	pages =		"154-162",
X	title =		"An Efficient Environment Allocation Scheme in an Interpreter for a Lexically-Scoped Lisp"
X}
X
X@article{key12,
X	author =	"Steven S. Muchnick and Uwe F. Pleban",
X	year =		"1980",
X	publisher =	"The Lisp Conference, P.O. Box 487, Redwood Estates CA.",
X	journal =	"Conference Record of the 1980 Lisp Conference",
X	pages =		"56-65",
X	title =		"A Semantic Comparison of Lisp and Scheme"
X}
X
X@book{key13,
X	author =	"Guy Lewis Steele, Jr.",
X	booktitle =	"AI: An MIT Perspective",
X	address =	"Cambridge, Mass.",
X	year =		"1980",
X	editor =	"Patrick Henry Winston Richard Henry Brown",
X	publisher =	"MIT Press",
X	title =		"Compiler Optimization Based on Viewing LAMBDA as RENAME + GOTO"
X}
X
X@article{key14,
X	author =	"Guy Lewis Steele, Jr. and Gerald Jay Sussman",
X	year =		"1980",
X	publisher =	"The Lisp Conference",
X	journal =	"Conference Record of the 1980 Lisp Conference",
X	pages =		"163-172",
X	title =		"The Dream of a Lifetime: a Lazy Variable Extent Mechanism"
X}
X
X@article{key15,
X	author =	"Mitchell Wand",
X	year =		"1980",
X	publisher =	"The Lisp Conference",
X	journal =	"Conference Record of the 1980 Lisp Conference",
X	pages =		"19-28",
X	title =		"Continuation-Based Multiprocessing"
X}
X
X@article{key16,
X	author =	"Guy Lewis Steele, Jr. and Gerald Jay Sussman",
X	year =		"November 1980",
X	journal =	"CACM",
X	number =	"11",
X	pages =		"628-645",
X	title =		"Design of a Lisp-based Processor",
X	volume =	"23"
X}
X
X@article{key17,
X	author =	"Gerald Jay Sussman and Jack Holloway and Guy Lewis Steele, Jr. and Alan Bell",
X	year =		"July 1981",
X	publisher =	"IEEE",
X	journal =	"IEEE Computer",
X	number =	"7",
X	pages =		"10-21",
X	title =		"Scheme-79 - Lisp on a Chip",
X	volume =	"14"
X}
X
X@article{scheme81,
X	author =	"John Batali and Edmund Goodhue and Chris Hanson and Howie Shrobe and Richard M. Stallman and Gerald Jay Sussman",
X	address =	"Artech House, Dedham MA.",
X	year =		"1982",
X	editor =	"Paul Penfield, Jr.",
X	journal =	"Proceedings, Conference on Advanced Research in VLSI",
X	pages =		"69-77",
X	title =		"The Scheme-81 Architecture - System and Chip"
X}
X
X@article{key19,
X	author =	"Peter Henderson",
X	year =		"1982",
X	journal =	"Conference Record of the 1982 ACM Symposium on Lisp and Functional Programming",
X	pages =		"179-187",
X	title =		"Functional Geometry"
X}
X
X@article{key20,
X	author =	"Jonathan A. Rees and Norman I. Adams",
X	year =		"1982",
X	journal =	"Conference Record of the 1982 ACM Symposium on Lisp and Functional Programming",
X	pages =		"114-122",
X	title =		"T: A Dialect of Lisp or, LAMBDA: The Ultimate Software Tool"
X}
X
X@book{key21,
X	author =	"Gerald Jay Sussman",
X	booktitle =	"Functional Programming and its Applications",
X	address =	"London",
X	year =		"1982",
X	editor =	"Darlington, Henderson, Turner",
X	publisher =	"Cambridge University Press",
X	title =		"LISP, Programming and Implementation"
X}
X
X@techreport{key22,
X	author =	"Pee Hong Chen and W.Y. Chi and E.M. Ost and L.D. Sabbagh and G. Springer",
X	address =	"Bloomington, Indiana",
X	year =		"August 1983",
X	publisher =	"Indiana University",
X	title =		"Scheme Graphics Reference Manual"
X}
X
X@techreport{key23,
X	author =	"Pee Hong Chen and Daniel P. Friedman",
X	address =	"Bloomington, Indiana",
X	year =		"August 1983",
X	publisher =	"Indiana University",
X	title =		"Prototyping data flow by translation into Scheme"
X}
X
X@techreport{key24,
X	author =	"Carol Fessenden and William Clinger and Daniel P. Friedman and Christopher T. Haynes",
X	address =	"Bloomington, Indiana",
X	year =		"February 1983",
X	publisher =	"Indiana University",
X	title =		"Scheme 311 version 4 Reference Manual"
X}
X
X@article{comp311,
X	author =	"William Clinger",
X	year =		"1984",
X	journal =	"Conference Record of the 1984 ACM Symposium on Lisp and Functional Programming",
X	pages =		"356-364",
X	title =		"The Scheme 311 compiler: An Exercise in Denotational Semantics"
X}
X
X@book{key26,
X	author =	"Daniel P. Friedman and Christopher T. Haynes and Eugene E. Kohlbecker",
X	booktitle =	"Program Transformation and Programming Environments",
X	year =		"1984",
X	editor =	"P. Pepper",
X	publisher =	"Springer-Verlag",
X	pages =		"263-274",
X	title =		"Programming with Continuations"
X}
X
X@article{key27,
X	author =	"Christopher T. Haynes and Daniel P. Friedman",
X	address =	"Austin, TX.",
X	year =		"1984",
X	journal =	"Conference Record of the 1984 ACM Symposium on Lisp and Functional Programming",
X	pages =		"18-24",
X	title =		"Engines Build Process Abstractions"
X}
X
X@article{key28,
X	author =	"Christopher T. Haynes and Daniel P. Friedman and Mitchell Wand",
X	address =	"Austin, TX.",
X	year =		"1984",
X	journal =	"Conference Record of the 1984 ACM Symposium on Lisp and Functional Programming",
X	pages =		"293-298",
X	title =		"Continuations and Coroutines"
X}
X
X@article{key29,
X	author =	"Daniel P. Friedman and Mitchell Wand",
X	address =	"Austin, TX.",
X	year =		"August 1984",
X	journal =	"Conference Record of the 1984 ACM Symposium on LISP and Functional Programming",
X	pages =		"348-355",
X	title =		"Reification: reflection without metaphysics"
X}
X
X@book{key30,
X	author =	"Jonathan A. Rees and Norman I. Adams and James R. Meehan",
X	year =		"January 1984",
X	publisher =	"Yale University Computer Science Department",
X	title =		"The T manual, fourth edition"
X}
X
X@book{key31,
X	author =	"Guillermo J. Rozas",
X	year =		"January 1984",
X	publisher =	"S. B. Thesis, MIT Department of Electrical Engineering and Computer Science",
X	title =		"Liar, an Algol-like Compiler for Scheme"
X}
X
X@book{key32,
X	address =	"Cambridge, Mass.",
X	year =		"September 1984",
X	publisher =	"Department of Electrical Engineering and Computer Science, MIT",
X	title =		"MIT Scheme Manual, Seventh Edition"
X}
X
X@book{key33,
X	address =	"Sausalito, Calif.",
X	year =		"1985",
X	publisher =	"Semantic Microsystems",
X	title =		"MacScheme Reference Manual"
X}
X
X@book{sicp,
X	author =	"Harold Abelson and Gerald Jay Sussman and Julie Sussman",
X	address =	"Cambridge, Mass.",
X	year =		"1985",
X	publisher =	"MIT Press",
X	title =		"Structure and Interpretation of Computer Programs"
X}
X
X@book{key35,
X	author =	"William Clinger and Daniel P. Friedman and Mitchell Wand",
X	booktitle =	"Algebraic Methods in Semantics",
X	address =	"London",
X	year =		"1985",
X	editor =	"J. Reynolds, M. Nivat",
X	publisher =	"Cambridge University Press",
X	pages =		"237-250",
X	title =		"A Scheme for a Higher-Level Semantic Algebra"
X}
X
X@article{key36,
X	author =	"Amitabh Srivastava and Don Oxley and Aditya Srivastava",
X	year =		"1985",
X	publisher =	"IEEE",
X	journal =	"Proceedings of the Symposium on Logic Programming",
X	pages =		"254-260",
X	title =		"An (other) Integration of Logic and Functional Programming"
X}
X
X@techreport{rrrs,
X	address =	"Cambridge, Mass.",
X	year =		"August 1985",
X	editor =	"William Clinger",
X	title =		"The Revised Revised Report on Scheme, or An Uncommon Lisp"
X}
X
X@article{key38,
X	author =	"Daniel P. Friedman and Christopher T. Haynes",
X	address =	"New Orleans, LA.",
X	year =		"January 1985",
X	publisher =	"ACM",
X	journal =	"Proceedings of the Twelfth Annual Symposium on Principles of Programming Languages",
X	pages =		"245-254",
X	title =		"Constraining Control"
X}
X
X@techreport{scheme84,
X	author =	"Daniel P. Friedman and Christopher T. Haynes and Eugene E. Kohlbecker and Mitchell Wand",
X	address =	"Bloomington, Indiana",
X	year =		"January 1985",
X	publisher =	"Indiana University",
X	title =		"Scheme 84 Interim Reference Manual"
X}
X
X@techreport{key40,
X	author =	"Peehong Chen and L. David Sabbagh",
X	address =	"Bloomington, Indiana",
X	year =		"March 1985",
X	publisher =	"Indiana University",
X	title =		"Scheme as an Interactive Graphics Programming Environment"
X}
X
X@book{key41,
X	year =		"November 1985",
X	publisher =	"Texas Instruments, Inc.",
X	title =		"TI Scheme Language Reference Manual"
X}
X
X@techreport{bochser,
X	author =	"Michael A. Eisenberg",
X	address =	"Cambridge, Mass.",
X	year =		"October 1985",
X	title =		"Bochser: An Integrated Scheme Programming System"
X}
X
X@techreport{key43,
X	author =	"Matthias Felleisen",
X	address =	"Bloomington, Indiana",
X	year =		"October 1985",
X	publisher =	"Indiana University",
X	title =		"Transliterating Prolog into Scheme"
X}
X
X@article{pcscheme,
X	author =	"David H. Bartley and John C. Jensen",
X	year =		"1986",
X	journal =	"Proceedings of the 1986 ACM Conference on Lisp and Functional Programming",
X	pages =		"86-93",
X	title =		"The Implementation of PC Scheme"
X}
X
X@article{key45,
X	author =	"R. Kent Dybvig and Daniel P. Friedman and Christopher T. Haynes",
X	year =		"1986",
X	journal =	"Proceedings of the 1986 ACM Conference on Lisp and Functional Programming",
X	pages =		"143-150",
X	title =		"Expansion-Passing style: Beyond Conventional Macros"
X}
X
X@misc{key46,
X	author =	"Marc Feeley and Guy LaPalme",
X	year =		"1986",
X	title =		"Closure Generation based on viewing LAMBDA as EPSILON plus COMPILE"
X}
X
X@article{key47,
X	author =	"Matthias Felleisen and Daniel P. Friedman",
X	year =		"1986",
X	publisher =	"Pergamon Press",
X	journal =	"Journal of Computer Languages",
X	number =	"1",
X	pages =		"29-37",
X	title =		"A Closer Look At Export and Import Statements",
X	volume =	"11"
X}
X
X@book{key48,
X	author =	"Daniel P. Friedman and Matthias Felleisen",
X	address =	"Palo Alto, California",
X	year =		"1986",
X	publisher =	"Science Research Associates, Inc.",
X	title =		"The Little LISPer: Second Edition"
X}
X
X@article{key49,
X	author =	"Christopher T. Haynes and Daniel P. Friedman and Mitchell Wand",
X	year =		"1986",
X	publisher =	"Pergamon Press",
X	journal =	"Journal of Computer Languages",
X	number =	"3/4",
X	pages =		"143-153",
X	title =		"Obtaining Coroutines With Continuations",
X	volume =	"11"
X}
X
X@article{key50,
X	author =	"Mitchell Wand",
X	address =	"St. Peterburg, Fla.",
X	year =		"1986",
X	publisher =	"ACM",
X	journal =	"Conference Record of the Thirteenth Annual Symposium on Principles of Programming Languages",
X	pages =		"38-43",
X	title =		"Finding the Source of Type Errors"
X}
X
X@book{key51,
X	author =	"Mitchell Wand",
X	booktitle =	"Programs as Data Objects",
X	year =		"1986",
X	publisher =	"Springer-Verlag Lecture Notes",
X	title =		"From Interpreter to Compiler: A Representational Derivation"
X}
X
X@article{key52,
X	author =	"Matthias Felleisen and Daniel P. Friedman",
X	address =	"Ebberup, Denmark",
X	year =		"August 1986",
X	journal =	"3rd Working Conference on the Formal Description of Programming Concepts",
X	pages =		"193-219",
X	title =		"Control operators, the SECD-machine, and the lambda-calculus"
X}
X
X@techreport{key53,
X	author =	"Eugene E. Kohlbecker",
X	address =	"Bloomington, Indiana",
X	year =		"August 1986",
X	publisher =	"Indiana University",
X	title =		"Syntactic Extensions in the Programming Language Lisp"
X}
X
X@article{key54,
X	author =	"Eugene E. Kohlbecker and Daniel P. Friedman and Matthias Felleisen and Bruce Duba",
X	year =		"August 1986",
X	journal =	"Symposium on LISP and Functional Programming",
X	pages =		"151-161",
X	title =		"Hygienic macro expansion"
X}
X
X@article{key55,
X	author =	"Mitchell Wand",
X	year =		"August 1986",
X	journal =	"Proceedings of the 1986 ACM Symposium on LISP and Functional Programming",
X	pages =		"298-307",
X	title =		"The mystery of the tower revealed: a non-reflective description of the reflective tower"
X}
X
X@article{key56,
X	year =		"December 1986",
X	editor =	"Jonathan A. Rees William Clinger",
X	journal =	"ACM Sigplan Notices",
X	number =	"12",
X	title =		"Revised^3 Report on the Algorithmic Language Scheme",
X	volume =	"21"
X}
X
X@article{key57,
X	author =	"Christopher T. Haynes",
X	year =		"Jul 1986",
X	publisher =	"Springer-Verlag",
X	journal =	"Proceedings of the Third International Conference on Logic Programming",
X	pages =		"671-685",
X	title =		"Logic Continuations"
X}
X
X@article{key58,
X	author =	"Matthias Felleisen and Daniel P. Friedman and Eugene E. Kohlbecker and Bruce Duba",
X	address =	"Washigton DC",
X	year =		"June 1986",
X	publisher =	"IEEE Computer Society Press",
X	journal =	"Proceedings of the Symposium on Logic in Computer Science",
X	pages =		"131-141",
X	title =		"Reasoning with Continuations"
X}
X
X@article{orbit,
X	author =	"David Kranz and Richard Kelsey and Jonathan A. Rees and Paul Hudak and James Philbin and Norman I. Adams",
X	year =		"June 1986",
X	publisher =	"ACM",
X	journal =	"Proceedings of the SIGPLAN '86 Symposium on Compiler Construction",
X	pages =		"219-233",
X	title =		"Orbit: An Optimizing Compiler for Scheme"
X}
X
X@book{key60,
X	author =	"Marc Feeley",
X	year =		"May 1986",
X	publisher =	"M.Sc. Thesis, De'partement d'Informatique et de Recherche Ope'rationelle, University of Montreal",
X	title =		"Deux Approches a' L'implantation du Language Scheme"
X}
X
X@book{splang,
X	author =	"R. Kent Dybvig",
X	address =	"Englewood Cliffs, New Jersey",
X	year =		"1987",
X	publisher =	"Prentice-Hall, Inc.",
X	title =		"The Scheme Programming Language"
X}
X
X@article{key62,
X	author =	"Marc Feeley and Guy LaPalme",
X	year =		"1987",
X	publisher =	"Pergamon Press",
X	journal =	"Journal of Computer Languages",
X	number =	"1",
X	pages =		"47-66",
X	title =		"Using Cloures for Code Generation",
X	volume =	"12"
X}
X
X@article{key63,
X	author =	"Matthias Felleisen",
X	year =		"1987",
X	publisher =	"Pergamon Press",
X	journal =	"Journal of Computer Languages",
X	number =	"3/4",
X	pages =		"197-207",
X	title =		"Reflections on Landin's J-Operator: A Partly Historical Note",
X	volume =	"12"
X}
X
X@article{key64,
X	author =	"Matthias Felleisen and Daniel P. Friedman",
X	booktitle =	"Lecture Notes in Computer Science",
X	address =	"Berlin",
X	year =		"1987",
X	editor =	"De Bakker, Nijman and Treleaven",
X	publisher =	"Springer-Verlag",
X	journal =	"Parallel Architectures and Languages Europe",
X	pages =		"206-223",
X	title =		"A Reduction Semantics for Imperative Higher-Order Languages",
X	volume =	"259"
X}
X
X@article{key65,
X	author =	"Matthias Felleisen and Daniel P. Friedman and Eugene E. Kohlbecker and Bruce Duba",
X	year =		"1987",
X	journal =	"Theoretical Computer Science",
X	pages =		"205-237",
X	title =		"A syntactic theory of sequential control",
X	volume =	"52"
X}
X
X@book{littlelisper,
X	author =	"Daniel P. Friedman and Matthias Felleisen",
X	year =		"1987",
X	publisher =	"MIT Press",
X	title =		"The Little LISPer"
X}
X
X@article{key67,
X	author =	"Christopher T. Haynes and Daniel P. Friedman",
X	year =		"1987",
X	publisher =	"Pergamon Press",
X	journal =	"Journal of Computer Languages",
X	number =	"2",
X	pages =		"109-121",
X	title =		"Abstracting Timed Preemption with Engines",
X	volume =	"12"
X}
X
X@techreport{key68,
X	author =	"Matthias Felleisen",
X	address =	"Bloomington, Indiana",
X	year =		"August 1987",
X	publisher =	"Indiana University",
X	title =		"The Calculi of lambda-v-cs conversion: a syntactic theory of control and state in imperative higher-order programming languages"
X}
X
X@techreport{key69,
X	author =	"Matthias Felleisen and Daniel P. Friedman and Bruce Duba and John Merrill",
X	address =	"Bloomington, Indiana",
X	year =		"February, 1987",
X	publisher =	"Indiana University",
X	title =		"Beyond Continuations"
X}
X
X@article{key70,
X	author =	"Matthias Felleisen and Daniel P. Friedman",
X	address =	"Munich, West Germany",
X	year =		"January 1987",
X	journal =	"Conference Record of the 14th Annual ACM Symposium on Principles of Programming Languages",
X	pages =		"314-345",
X	title =		"A calculus for assignments in higher-order languages"
X}
X
X@techreport{key71,
X	author =	"Matthias Felleisen and Daniel P. Friedman",
X	address =	"Bloomington, Indiana",
X	year =		"October 1987",
X	publisher =	"Indiana University",
X	title =		"A Syntactic Theory of Sequential State"
X}
X
X@article{key72,
X	author =	"Christopher T. Haynes and Daniel P. Friedman",
X	year =		"October 1987",
X	journal =	"ACM Transactions on Programming Languages and Systems",
X	number =	"4",
X	pages =		"582-598",
X	title =		"Embedding continuations in procedural objects",
X	volume =	"9"
X}
X
X@book{key73,
X	author =	"Michael Eisenberg",
X	address =	"Redwood City, CA",
X	year =		"1988",
X	editor =	"Harold Abelson",
X	publisher =	"Scientific Press",
X	title =		"Programming In Scheme"
X}
X
X@book{key74,
X	author =	"Mitchell Wand and Daniel P. Friedman",
X	booktitle =	"Meta-Level Architectures and Reflection",
X	year =		"1988",
X	editor =	"P. Maes and D. Nardi",
X	publisher =	"Elsevier Sci. Publishers B.V. (North Holland)",
X	pages =		"111-134",
X	title =		"The Mystery of the Tower Revealed: A Non-Reflective Description of the Reflective Tower"
X}
X
X@book{key75,
X	author =	"Daniel P. Friedman and Mitchell Wand and Christopher T. Haynes and Eugene E. Kohlbecker",
X	year =		"1988-1989",
X	publisher =	"M.I.T. Press and McGraw Hill",
X	title =		"Programming Languages: Their Abstractions, Representations, and Implementations"
X}
X
X@misc{key76,
X	author =	"George Springer and Daniel P. Friedman",
X	year =		"1988-1989",
X	title =		"An Introduction to the Art of Programming in Scheme"
X}
X
X@article{key77,
X	author =	"Harold Abelson and Gerald Jay Sussman",
X	year =		"February 1988",
X	journal =	"BYTE",
X	pages =		"207-218",
X	title =		"Lisp: A Langauge for Stratified Design"
X}
X
X@article{key78,
X	author =	"William Clinger",
X	year =		"February 1988",
X	journal =	"BYTE",
X	pages =		"221-227",
X	title =		"Semantics of Scheme"
X}
X
X@article{key79,
X	author =	"Alan Bawden and Jonathan Rees",
X	address =	"Salt Lake City, Utah.",
X	year =		"July 1988",
X	journal =	"Proceedings of the 1988 ACM Symposium on LISP and Functional Programming",
X	title =		"Syntactic Closures"
X}
X
X@article{key80,
X	author =	"Matthias Felleisen and Mitchell Wand and Daniel P. Friedman and Bruce Duba",
X	address =	"Salt Lake City, Utah.",
X	year =		"July 1988",
X	journal =	"Proceedings of the 1988 ACM Symposium on LISP and Functional Programming",
X	title =		"Abstract Continuations: A Mathematical Semantics for Handling Functional Jumps"
X}
X
X@techreport{key81,
X	author =	"John Franco and Daniel P. Friedman",
X	address =	"Bloomington, Indiana",
X	year =		"March 1988",
X	publisher =	"Indiana University",
X	title =		"Creating Efficient Programs by Exchanging Data for Procedures"
X}
X
X@article{key82,
X	author =	"Mitchell Wand and Daniel P. Friedman",
X	year =		"241-263 1978",
X	journal =	"Computer Languages 3",
X	title =		"Compiling lambda expressions using continuations and factorizations"
X}
X
END_OF_FILE
if test 20265 -ne `wc -c <'scheme.bibtex'`; then
    echo shar: \"'scheme.bibtex'\" unpacked with wrong size!
fi
# end of 'scheme.bibtex'
fi
echo shar: End of shell archive.
exit 0
-- 
Crud that is not paged	        | Usenet: ...!utzoo!yunexus!oz
is still crud. 			|   ...uunet!mnetor!yunexus!oz
	andrew@alice		| Bitnet: oz@[yulibra|yuyetti]
				| Phonet: +1 416 736-5257x3976

Received: from cs.utah.edu (TCP 1200000004) by MC.LCS.MIT.EDU 16 Aug 88 16:24:21 EDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA26479; Tue, 16 Aug 88 13:37:41 MDT
Received: by cons.utah.edu (5.54/utah-2.0-leaf)
	id AA22021; Tue, 16 Aug 88 13:37:35 MDT
Date: Tue, 16 Aug 88 13:37:35 MDT
From: kessler%cons@cs.utah.edu (Robert R. Kessler)
Message-Id: <8808161937.AA22021@cons.utah.edu>
To: common-lisp@sail.stanford.edu, scheme@mc.lcs.mit.edu, fp@cs.yale.edu
Cc: dswise@iuvax.cs.indiana.edu
Subject: A Quick Note on the Last L&FP Conference


One of the rumblings that I heard at the conference was that a number
of people didn't receive their copies of the Advance Program mailing
from ACM.  Thus, it made it more difficult to register.  If any of you
are members of SIGPLAN, SIGART, or SIGACT and you did not receive a
copy of the program some time in May, would you please send David Wise
a message (dswise@iuvax.cs.indiana.edu).  He is trying to collect
actual data on the hits and misses of the mailing.  Please send him
your name, mailing address at which you receive ACM materials, and
your ACM number if you have it.

Thanks.
Bob.

Received: from REAGAN.AI.MIT.EDU (CHAOS 13065) by MC.LCS.MIT.EDU 14 Aug 88 13:57:08 EDT
Received: from QUESTION-AUTHORITY.AI.MIT.EDU by REAGAN.AI.MIT.EDU via CHAOS with CHAOS-MAIL id 129473; Sun 14-Aug-88 13:56:52 EDT
Date: Sun, 14 Aug 88 13:57 EDT
From: Scheme Requestee <SCHREQ@MC.LCS.MIT.EDU>
Subject: Periodic noise message; list policy reiterated
To: scheme@MC.LCS.MIT.EDU
Message-ID: <"19880814175700.5.schreq@MC"@QUESTION-AUTHORITY.AI.MIT.EDU>

[I periodically send this message in order to show the mailing list
policy blurb to people who may not have already seen it, and in order to
weed out bad addresses from the list.  You can ignore this message if
you've already seen something like it.]


General information about the Scheme mailing list:

- The list is not moderated.  If you send mail to scheme@mc.lcs.mit.edu,
it will be forwarded to the hundreds (thousands?) of list members on the
ARPA Internet, CSNET, BITNET, Usenet, JUNET, etc.  If you have any doubt
about the suitability of your message for this audience, send it to
scheme-request@mc.lcs.mit.edu instead, and your message will be either
answered or forwarded.

- Avoid sending messages concerning MIT's scheme implementation (C
Scheme) to the list; users of the many other Scheme implementations
don't generally care to see such messages.  There is a separate list,
info-cscheme@zurich.ai.mit.edu, for this purpose.  To be added to that
list, send mail to info-cscheme-maintainer@zurich.ai.mit.edu.

- Similarly for T (Yale Scheme): send requests to
T-Discussion-Request@mc.lcs.mit.edu.

- Send administrative requests to scheme-request@mc.lcs.mit.edu.  If
your machine is scheduled to change its name or routing, or to go off
the net, or if you move, please send mail to scheme-request so your
entry can be changed.

- Problem addresses on the list will be quietly removed from the list.
Your address may become invalid due to no fault of your own, and/or
without your being aware of it.  For example, if your system becomes
inaccessible from the Internet for a week, of if it changes its name,
messages to you will bounce, and your entry will be removed from the
list.  If you don't get any Scheme list messages for, say, a month, you
might want to send a message to scheme-request to verify that you're
still on.

- If you send a message and receive mailer error reports in reply,
forward the error reports to scheme-request@mc.lcs.mit.edu.

- If you think there will be more than one person at your site who wants
to be on the list, please set up a local redistribution list.

- There is bidirectional forwarding between Usenet's comp.lang.scheme
and the Internet Scheme list.

- Messages are archived in the following files:
	LSPMAI; SCHEME MAIL1   on host AI.AI.MIT.EDU   [oldest messages]
	LSPMAI; SCHEME MAIL2   on host AI.AI.MIT.EDU
	LSPMAI; SCHEME MAIL3   on host AI.AI.MIT.EDU
	LSPMAI; SCHEME MAIL4   on host AI.AI.MIT.EDU
	LSPMAI; SCHEME MAIL    on host MC.LCS.MIT.EDU  [newest messages]
Note that there are spaces in these filenames, so you may have to type
double quotes at your FTP program.  If you don't have Internet FTP access,
tough luck.

- There is a file on host AI.AI.MIT.EDU, "LSPMAI; SCHEME IMPLS", that
has brief descriptions of available scheme implementations and how to
get them.  If you want a copy of this file, but you don't have Internet
FTP access, send a request to scheme-request.

					Jonathan Rees
					14 August 1988

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 14 Aug 88 03:27:51 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA19905@BLOOM-BEACON.MIT.EDU>; Sun, 14 Aug 88 03:22:00 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 14 Aug 88 06:23:53 GMT
From: dewey.soe.berkeley.edu!oster@ucbvax.berkeley.edu  (David Phillip Oster)
Organization: School of Education, UC-Berkeley
Subject: Re: Scheme for the Mac?
Message-Id: <25632@ucbvax.BERKELEY.EDU>
References: <9848@eddie.MIT.EDU>, <8808101711.AA00210@kaplan.cs.uiuc.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

If you want to get truly intimate with scheme, you might consider siod
(scheme in one definition.)
gjc%bucsf.bu.edu@bu-it.bu.edu (George J. Carrette)
is responsible for it. He distributes it as source code, and it runs on
the mac.

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 12 Aug 88 06:28:33 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA03329@BLOOM-BEACON.MIT.EDU>; Fri, 12 Aug 88 05:23:44 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 11 Aug 88 13:43:22 GMT
From: mmm!com50!pai!erc@umn-cs.arpa  (Eric Johnson)
Organization: Prime Automation, Inc., Burnsville, MN
Subject: Re: XSCHEME
Message-Id: <133@pai.UUCP>
References: <8808102011.AA26849@renoir.Berkeley.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

In article <8808102011.AA26849@renoir.Berkeley.EDU>, maddox@RENOIR.BERKELEY.EDU (William Maddox) writes:
> 
> Is there anywhere on the net where I can FTP a copy of XSCHEME?
> XSCHEME is an implementation of Scheme by David Betz, author of XLISP,
> a small and highly portable Common Lisp (psuedo-)subset written in C.
> Bill Maddox
> ucbvax!renoir!maddox
> maddox@renoir.berkeley.edu

The latest XScheme is available on the Byte Information eXchange (BIX).
When I asked David Betz about posting XLisp to Usenet, he wrote that
eventually he wanted to post XScheme, but at the time (about a month ago)
XScheme was not finished enough (in his opinion) for posting. (Someone
beat me to the XLisp posting, so I haven't pursued the matter
further.  When David Betz is satisfied XScheme is post-able, I
certainly wouldn't mind submitting it to a sources moderator. For now,
your best bet is to try BIX.)

I've been very impressed with Betz's work, especially since
XLisp helped me through an AI course (being able to work on
a PC, Mac and Unix workstation with the same program certainly
helped). 

What I'm hoping for now is an XProlog.

-Eric


-- 
Eric F. Johnson          | Phone +1 612-894-0313             | Are we
Prime Automation,Inc     | UUCP:   bungia!pai!erc            | having
12201 Wood Lake Drive    | UUCP:   sun!tundra!pai!erc        | fun
Burnsville, MN 55337 USA | DOMAIN: erc@pai.mn.org            | yet?

Received: from renoir.Berkeley.EDU (TCP 20010101004) by MC.LCS.MIT.EDU 10 Aug 88 16:13:09 EDT
Received: by renoir.Berkeley.EDU (5.59/1.29)
	id AA26849; Wed, 10 Aug 88 13:11:13 PDT
Date: Wed, 10 Aug 88 13:11:13 PDT
From: maddox@renoir.Berkeley.EDU (William Maddox)
Message-Id: <8808102011.AA26849@renoir.Berkeley.EDU>
To: scheme@mc.lcs.mit.edu
Subject: XSCHEME


Is there anywhere on the net where I can FTP a copy of XSCHEME?
XSCHEME is an implementation of Scheme by David Betz, author of XLISP,
a small and highly portable Common Lisp (psuedo-)subset written in C.

I am also interested in any other Scheme implementation that is
freely distributable in source form, easily ported to a 68K Unix 
box, and economical in its use of resources (runs well in 2 meg or less).

Bill Maddox
ucbvax!renoir!maddox
maddox@renoir.berkeley.edu

Received: from a.cs.uiuc.edu (TCP 1200600045) by MC.LCS.MIT.EDU 10 Aug 88 13:13:13 EDT
Received: from kaplan.cs.uiuc.edu by a.cs.uiuc.edu with SMTP (UIUC-5.52/9.7)
	id AA26313; Wed, 10 Aug 88 12:08:17 CDT
Received: by kaplan.cs.uiuc.edu (3.2/9.7)
	id AA00210; Wed, 10 Aug 88 12:11:01 CDT
Date: Wed, 10 Aug 88 12:11:01 CDT
From: kaplan%kaplan.cs.uiuc.edu@a.cs.uiuc.edu (Simon Kaplan)
Message-Id: <8808101711.AA00210@kaplan.cs.uiuc.edu>
To: fenchurch.mit.edu!jbs@eddie.mit.edu
Cc: scheme@mc.lcs.mit.edu
In-Reply-To: (Jeff Siegal's message of 10 Aug 88 05:47:08 GMT <9848@eddie.MIT.EDU>
Subject: Scheme for the Mac?

the best scheme available exists on the mac, it's sold by semantic
microsystems in portland oregon, their numbber is (503) 643-4539.

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 10 Aug 88 03:57:59 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA06826@BLOOM-BEACON.MIT.EDU>; Wed, 10 Aug 88 02:47:02 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 10 Aug 88 05:47:08 GMT
From: fenchurch.mit.edu!jbs@eddie.mit.edu  (Jeff Siegal)
Organization: MIT EE/CS Computer Facilities, Cambridge, MA
Subject: Scheme for the Mac?
Message-Id: <9848@eddie.MIT.EDU>
References: <838@yunexus.UUCP>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

A friend is looking for a Scheme package for the Mac for learning
purposes.  Any recommendations?

Jeff Siegal

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU  9 Aug 88 18:12:38 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA26954@BLOOM-BEACON.MIT.EDU>; Tue, 9 Aug 88 17:54:46 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 8 Aug 88 18:08:10 GMT
From: attcan!utzoo!yunexus!oz@uunet.uu.net  (Ozan Yigit)
Organization: York U. Computing Services - Magic Group
Subject: "rabbit" report needed.
Message-Id: <838@yunexus.UUCP>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

I need a copy of the rabbit report, and I believe MIT is
out of prints. Would someone who has the report be willing
to mail me a photocopy ? [will pay for the photocopying and
mailing costs] Please respond via e-mail.

thnx in advance.	oz
			
-- 
Crud that is not paged	        | Usenet: ...!utzoo!yunexus!oz
is still crud. 			|   ...uunet!mnetor!yunexus!oz
	andrew@alice		| Bitnet: oz@[yulibra|yuyetti]
				| Phonet: +1 416 736-5257x3976

Received: from Think.COM (TCP 1201000006) by MC.LCS.MIT.EDU  2 Aug 88 08:35:30 EDT
Return-Path: <gls@Think.COM>
Received: from brigit.think.com by Think.COM; Tue, 2 Aug 88 08:28:04 EDT
Received: by brigit.think.com; Tue, 2 Aug 88 08:30:26 EDT
Date: Tue, 2 Aug 88 08:30:26 EDT
From: gls@Think.COM
Message-Id: <8808021230.AA22090@brigit.think.com>
To: scheme@mc.lcs.mit.edu
Subject: Continuations and multiple values

Here I write down some of the ideas I put forward on multiple values
at the Scheme meeting of Sunday, July 24, 1988.

Different Lisp dialects have different theories about how to handle
multiple values when the "wrong" number are returned.  The main point
of this note is that the implementation of these theories can be
moved out of CWCC and into VALUES, which can be written as user-level
code provided that some simple predicates are provided.

Let us suppose that every continuation accepts noly the "correct"
number of values.  In other words, the continuation for evaluating
a subform of a combination requires one value; the continuation
for evaluating an IF predicate requires one value; and the continuation
for evaluating a non-final subform of BEGIN requires zero values.
Define (WITH-VALUES thunk f) to call the thunk with a continuation
that accepts as many arguments as f does.  (In effect the continuation
is the composition of the continuation of the WITH-VALUES form with f.)

Then the simplest definition of VALUES is:

(define (values . r) (cwcc (lambda (k) (apply k r))))

Let the predicate (ACCEPTS? f n) be true if f will accept n arguments,
and false otherwise.  (This is generally useful for writing interpreters.)

Suppose we want to allow excess values to be ignored.  We can then
write:

(define (values . r)
  (define (ignore-excess-values k z)
    (if (accepts? k (length z))
	(apply k z)
	(if (null z)
	    (apply k r)      ;take the error with all values
	    (ignore-excess-values k (cdr z)))))
  (cwcc (lambda (k) (ignore-excess-values k r))))

A similar technique can be used to provide extra #F values as well if not
enough values were provided.  (We don't know when to stop, but every
continuation must accept some number of values, so the process must
terminate.)

(define (values . r)
  (define (ignore-excess-values k z)
    (if (accepts? k (length z))
	(apply k z)
	(if (null z)
	    (supply-default-falses k r)
	    (ignore-excess-values k (cdr z)))))
  (define (supply-default-falses k z)
    (if (accepts? k (length z))
	(apply k z)
	(supply-default-falses k (cons '#f z))))
  (cwcc (lambda (k) (ignore-excess-values k r))))

Now the assumption that a BEGIN continuation requires exactly zero values
is a bit stringent.  This may be a good thing; perhaps one ought to mark
explicitly where a value is being discarded.  One might have the syntax

(void x)  ->  (with-values (lambda () x) (lambda r (values)))

and then write

(begin (set! x 3)
       (void (valued-function-with-side-effect x))
       (+ x 1))

where we assume that  set!  is already defined to return zero values.
If this arrangement is not acceptable then perhaps BEGIN continuations
should accept 0 or 1 value, discarding the value if any.

Another paradigm we might wish to emulate is that where VALUES may
not be used except with continuations explicitly created by WITH-VALUES.
Here are two ways to do that; one requires a new predicate, and the
other is a crock.

If we have a predicate (WITH-VALUES-CONTINUATION? f) that is true
precisely of continuations created by WITH-VALUES, then we write simply

(define (values . r)
  (cwcc (lambda (k)
	  (if (with-values-continuation? k)
	      ...
	      (error)))))

On the other hand, instead of requiring such a built-in predicate
we can take advantage of the fact that no other continuation takes
more than one value (this is the crock):

(define old-with-values with-values)

(define (with-values thunk f)
  (old-with-values thunk (lambda (foo bar . r) (apply f r))))

(define (values . r)
  (cwcc (lambda (k)
          (if (accepts? k 2) (apply k (cons #f (cons #f r))) (error)))))

The "foo bar" arguments ensure that only a VALUES can correctly provide the
values to a WITH-VALUES.  The ACCEPTS? test determines whether the
continuation K was actually provided by a WITH-VALUES.

--Guy Steele

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 31 Jul 88 02:56:35 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA18269@BLOOM-BEACON.MIT.EDU>; Sun, 31 Jul 88 02:46:09 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 31 Jul 88 06:18:30 GMT
From: killer!elg@ames.arpa  (Eric Green)
Organization: The Unix(R) Connection, Dallas, Texas
Subject: Amiga C-Scheme?
Message-Id: <5037@killer.DALLAS.TX.US>
References: <1774@vu-vlsi.Villanova.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

In message <1774@vu-vlsi.Villanova.EDU>, sword@vu-vlsi.Villanova.EDU (David Talmage) says:
>Has anyone ported C-Scheme to the Amiga?  I've got the sources on my
>VAXen here at Villanova.  Is it worth my time to try to make C-Scheme
>run on my 2.5 MByte Amiga?

C-Scheme will probably run quite slowly on an Amiga (it's no
speed-demon on the Pyramid 90x machines at school). The memory image
on the Pyramids is around 2 megabytes, so you should be able to fit it
into memory. But you wouldn't be able to have much else in the
machine.

I would say that it wasn't worth it, but it depends on how much you
want Scheme. If you do decide to try it, make sure you have the latest
copy of C-Scheme from the Free Software Foundation. Between the 16.xx
Emacs tapes and the 17.xx Emacs tapes, C-Scheme was changed in fairly
major ways to make it more portable (I had a hard time bringing the
16.xx version up on the Pyramids, while the 17.xx version came up with
no problem at all).

--
Eric Lee Green    ..!{ames,decwrl,mit-eddie,osu-cis}!killer!elg
          Snail Mail P.O. Box 92191 Lafayette, LA 70509              
       MISFORTUNE, n. The kind of fortune that never misses.

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 30 Jul 88 01:41:19 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA19144@BLOOM-BEACON.MIT.EDU>; Sat, 30 Jul 88 01:29:57 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 30 Jul 88 03:05:18 GMT
From: vu-vlsi!sword@psuvax1.psu.edu  (David Talmage)
Organization: Villanova Univ. EE Dept.
Subject: Amiga C-Scheme?
Message-Id: <1774@vu-vlsi.Villanova.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

Has anyone ported C-Scheme to the Amiga?  I've got the sources on my
VAXen here at Villanova.  Is it worth my time to try to make C-Scheme
run on my 2.5 MByte Amiga?

David Talmage
Villanova University/University Computing and Information Services
talmage@excalibur.UUCP
talmage@vuvaxcom.BITNET

Received: from MITVMA.MIT.EDU (TCP 2227000003) by MC.LCS.MIT.EDU 28 Jul 88 06:52:33 EDT
Received: from MITVMA.MIT.EDU by MITVMA.MIT.EDU (IBM VM SMTP R1.1) with BSMTP id 4278; Thu, 28 Jul 88 06:50:17 EDT
Received: from DB0TUI6.BITNET (ZTUBTFAL) by MITVMA.MIT.EDU (Mailer X1.25) with
 BSMTP id 4277; Wed, 27 Jul 88 12:52:43 EDT
Received: by tub.UUCP; Wed, 27 Jul 88 18:48:10 +0200; AA08383
Received: by tub-tfs.uucp (3.2/SMI-3.0DEV3)
        id AA03879; Wed, 27 Jul 88 18:43:57 +0200
Date: Wed, 27 Jul 88 18:43:57 +0200
From: alti%tub-tfs.uucp%TUB.BITNET@MITVMA.MIT.EDU (Thorsten Altenkirch)
Message-Id: <8807271643.AA03879@tub-tfs.uucp>
In-Reply-To: Jerry Jackson's message as of Jul 26, 13:53.
X-Mailer: Mail User's Shell (6.3 6/25/88)
To: pyramid!uunet!mc.lcs.mit.edu!scheme-request@tub.UUCP,
        esosun!jackson%seismo.css.gov@tub.BITNET
Subject: Re: binding and assignment
Cc: scheme%mc.lcs.mit.edu@tub.BITNET

() It occurred to me that there is an inconsistency in the scheme/lisp
() treatment of assignment when it comes to symbols -- in all other
() cases assignment means changing the contents of a cell of some kind,
() while assignment to a symbol is treated as a renaming operation.  I
() figured this had resulted from the functional programming perspective
() -- a binding is simply the name for a value in a particular context...
()
() It seems non-intuitive that assigning to "a" is actually removing
() the name "a" from some value and naming a different value "a".

I don't understand what you mean. You assign values to symbols and
this is realized by modifying the innermost environment, where the
symbol is bound.

You can use this scheme to define any mutable data structure. Consider
following implementation of cons (see also Abelson/Sussman,"The structure
and the interpretation of Computer Programs", pp 207) :

(define (my-cons x y)
   (lambda (m)
      (cond ((eq? m 'car) x)
            ((eq? m 'cdr) y)
            ((eq? m 'set-car!) (lambda (v) (set! x v)))
            ((eq? m 'set-cdr!) (lambda (v) (set! y v))))))

(define my-car (x) (x 'my-car))
(define my-cdr (x) (x 'my-cdr))
(define my-set-car! (x v) ((x 'set-car!) v))
(define my-set-cdr! (x v) ((x 'set-cdr!) v))

These implementation of cons is heavily influenced by the
representation of data structures in the lambda calculus. But you have
no assignment in the lambda calculus. I found it quite interesting how
well a very general assignment and lambda calculus can live together
(if you have call-by-name semantics).

() I thought that a slightly different model might be useful.

However your idea with the "var"- form is not so bad. (I only can't
understand the reasons you gave). A thing like this is realized in ML
(which is also a functional, but typed language, developed at
Edinburgh, from Robin Milner et al.)

They have a type 'a ref ('a is a type-variable) with the following
operations :

ref : 'a -> 'a ref
!   : 'a ref -> 'a
(op :=) : 'a ref * 'a -> unit   (* op means infix & unit is novalue).

A simple example (see R.Harpers "Introduction to Standard ML", p. 36):
(- is what the user types in, > are the systems responses).

- val x = ref 0;
> val x = ref(0) : int ref
- !x;
> 0 : int
- x := 3;
> () : unit
- !x;
> 3 : int

As might be clear you can use ref as a part of every data structure.

() This produces several benefits:
()
() 1) the 'setf' form of CL is obtained for free in a much less
() kludgey way -- e.g. after:
() ...
() 4) assignment becomes completely consistent and only one assignment
() special form is needed instead of one for each type of mutable data --
() It is no longer necessary to have vector-set!, set-car!,...

OK. But you export more about the implementation of a data type. No
problems with vectors and things like this, but if you implement a
more complex data type, you may decide to change the implementation
w.o. changing the interface. That becomes impossible, if your export
includes referential types.

() 2) built-in functions can be defined at the top level without using the
() 'var' form so that they cannot be redefined...
() ...
() 6) inlining (or direct linking -- not through a symbol) of built-ins
() is now allowable without constraints

I think that's more a point of the module structure of your program.
You often use modules and you don't want to change them, not only the
primitive functions. It should be possible to declare these different
usages of modules. (CommonLisp has package to realize modules, but it
lacks the possibility to declare a package as read-only).

() 3) the need for things like "named-lambda" is lessened -- If a recursive
() function is defined without using 'var', the value will never change
() and you get the effect of a named-lambda for free

named-lambda is a derivative from rec, and rec is the fixed-point
combinator. I think this is the onliest semantical clean way tp define
recursion. You should get an error if you use a variable on a point
where it is not defined. (That's the way ML works).

() 5) quoted constants are now actually guaranteed to be constant --
() no more accidental program modification

This should be garanteed by the production system, independenly of the
philosophy of assignments.

Thorsten

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 27 Jul 88 22:55:15 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA15325@BLOOM-BEACON.MIT.EDU>; Wed, 27 Jul 88 22:45:49 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 27 Jul 88 21:58:30 GMT
From: quintus!ok@unix.sri.com  (Richard A. O'Keefe)
Organization: Quintus Computer Systems, Inc.
Subject: Re:  Scheme shellscripts
Message-Id: <203@quintus.UUCP>
References: <880716144458.6.JAMES@GREEN-GRASS.LCS.MIT.EDU>, <1700@kalliope.rice.edu>, <12601@agate.BERKELEY.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

In article <12601@agate.BERKELEY.EDU> mwm@eris.berkeley.edu (Mike Meyer) writes:
...
>Instead, try doing:
>	echo > /tmp/runscheme.$$ '(set! $* (quote ('$*')))'
>This creates a file in /tmp ...

Um, /tmp is for system programs.  /usr/tmp is the place for user temporary
files.  A number of system V utilities support the convention of trying to
create files in $TMPDIR.  It might be better, then, to do
	scheme_temp=${TMPDIR:-/usr/tmp}/runscheme.$$
	echo '(set! $* (quote ('$*')))' >$scheme_temp
You'll want to keep track of the file name so that you can delete it.

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 27 Jul 88 01:54:56 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA18235@BLOOM-BEACON.MIT.EDU>; Wed, 27 Jul 88 01:43:54 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 27 Jul 88 03:35:10 GMT
From: agate!eris!mwm@labrea.stanford.edu  (Mike (I'm in love with my car) Meyer)
Organization: Missionaria Phonibalonica
Subject: Re:  Scheme shellscripts
Message-Id: <12601@agate.BERKELEY.EDU>
References: <1666@kalliope.rice.edu>, <880716144458.6.JAMES@GREEN-GRASS.LCS.MIT.EDU>, <1700@kalliope.rice.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

In article <various@many.sites> many people write shell scripts with
lines like:

	echo > .tmp '(set! $* (quote ('$*')))'

in them. This has one nasty problem - try doing "cd /; <scheme-program>".
You'll find (well, you ought to find) that it dies - you can't create
the scratch file you want. Of course, if two people are in the
directory you're running in and running that command, you'll have
probles too.

Instead, try doing:

	echo > /tmp/runscheme.$$ '(set! $* (quote ('$*')))'

This creates a file in /tmp with the process id of the shell executing
the script in it's name. That solves both problems at once.

	<mike

--
My feet are set for dancing,				Mike Meyer
Won't you turn your music on.				mwm@berkeley.edu
My heart is like a loaded gun,				ucbvax!mwm
Won't you let the water run.				mwm@ucbjade.BITNET

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 26 Jul 88 11:55:07 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA28505@BLOOM-BEACON.MIT.EDU>; Tue, 26 Jul 88 11:49:17 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 26 Jul 88 13:53:26 GMT
From: ucsdhub!esosun!jackson@ucsd.edu  (Jerry Jackson)
Organization: SAIC, San Diego
Subject: binding and assignment
Message-Id: <238@esosun.UUCP>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu




It occurred to me that there is an inconsistency in the scheme/lisp
treatment of assignment when it comes to symbols -- in all other
cases assignment means changing the contents of a cell of some kind,
while assignment to a symbol is treated as a renaming operation.  I
figured this had resulted from the functional programming perspective
-- a binding is simply the name for a value in a particular context...

It seems non-intuitive that assigning to "a" is actually removing 
the name "a" from some value and naming a different value "a".

I thought that a slightly different model might be useful --

Let binding be an irrevocable operation.  Create a new data type
called a "variable" that has the following property -- When a variable
is returned from eval, it is dereferenced so that its contents are
returned, except when it is the first argument to a set! special form
or the result of a 'var' special form.  My intent is that 'variable'
is the only mutable data type -- I'll give a few examples before
explaining the benefits of this model:

(define fact
      (lambda (n)
	(if (< n 2)
	    1
	  (* n (fact (1- n))))))
  
defines fact as you would imagine and works the same way you would
think -- however, following this with:

(set! fact 5)

would return an error -- fact is not bound to a variable

After evaluating:

(define fact2
      (var (lambda (n)
	     (if (< n 2)
		 1
	       (* n (fact2 (1- n)))))))

(fact2 x) would give the same result as (fact x), but

(set! fact2 5) would succeed.

Note: typing "fact2" at this point would return 5, but
the expression: (var? fact2) -> t while (var? fact) -> nil


This produces several benefits: 

1) the 'setf' form of CL is obtained for free in a much less
kludgey way -- e.g. after: 

(define w (list (var 3) (var 4))) =>   w = (3 4)

evaluating:

(set! (cadr w) 5) 

would cause w to appear as: (3 5)

2) built-in functions can be defined at the top level without using the
'var' form so that they cannot be redefined...

3) the need for things like "named-lambda" is lessened -- If a recursive
function is defined without using 'var', the value will never change
and you get the effect of a named-lambda for free

4) assignment becomes completely consistent and only one assignment
special form is needed instead of one for each type of mutable data --
It is no longer necessary to have vector-set!, set-car!,...

5) quoted constants are now actually guaranteed to be constant --
no more accidental program modification 

6) inlining (or direct linking -- not through a symbol) of built-ins
is now allowable without constraints


Any comments?


+-----------------------------------------------------------------------------+
|   Jerry Jackson                       UUCP:  seismo!esosun!jackson          |
|   Geophysics Division, MS/22          ARPA:  esosun!jackson@seismo.css.gov  |
|   SAIC                                SOUND: (619)458-4924                  |
|   10210 Campus Point Drive                                                  |
|   San Diego, CA  92121                                                      |
+-----------------------------------------------------------------------------+

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 25 Jul 88 17:09:30 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA07099@BLOOM-BEACON.MIT.EDU>; Mon, 25 Jul 88 17:00:09 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 25 Jul 88 17:33:02 GMT
From: killer!pollux!ti-csl!mips!gateley@eddie.mit.edu  (John Gateley)
Organization: TI Computer Science Center, Dallas
Subject: Re: Non-upward-compatibility of Chez Scheme versions
Message-Id: <54901@ti-csl.CSNET>
References: <1709@kalliope.rice.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

In article <1709@kalliope.rice.edu> dorai@titan.rice.edu (Dorai Sitaram) writes:
>`define-macro!', the form used to define macros in older versions of 
>Chez Scheme [TM, Cadence Research Systems] is also provided in the current 
>version (along with the fancier `extend-syntax'/`with'). However, the older 
>version (v.1.1, 1985) seems more powerful (expressive) than the current one 
>(v.2.0.3, 1987)!

Just a side note: you seem to be saying that the define-macro! form is more
powerful than extend-syntax and with. This is not true. Extend-syntax can be
used to do 3-d programming (the technique you describe in your message), and
any macro. It is completely general.

John Gateley

p.s. Extend-syntax was created by Eugene Kohlbecker.

Received: from CENTRO.SOAR.CS.CMU.EDU (TCP 20000557276) by MC.LCS.MIT.EDU 24 Jul 88 21:44:25 EDT
Date: Sun Jul 24 21:43:13 1988
From: Olin.Shivers@CENTRO.SOAR.CS.CMU.EDU
To: titan!dorai@rice.edu
CC: scheme@mc.lcs.mit.edu
In-reply-to: (Dorai Sitaram's message of 24 Jul 88 21:30:40 GMT <1709@kalliope.rice.edu>
Subject: Non-upward-compatibility of Chez Scheme versions

	   (let ([null? null?])
	     (define-macro! nil? (x)
	       `(,null? ,x))		; note comma before null?

I don't use the Scheme's you use, but I think I can see at least one
problem with this macro: functions are *not* defined in Scheme to be 
self-evaluating like, for example, integers are.
So instead of: 
    ,null?
you need:
    ',null?
As in:
	(let ((null? null?))
	  (define-macro! nil? (x)
	    `(',null ,x)))

    -Olin

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 24 Jul 88 18:08:57 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA11228@BLOOM-BEACON.MIT.EDU>; Sun, 24 Jul 88 18:01:39 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 24 Jul 88 21:30:40 GMT
From: titan!dorai@rice.edu  (Dorai Sitaram)
Organization: Rice University, Houston
Subject: Non-upward-compatibility of Chez Scheme versions
Message-Id: <1709@kalliope.rice.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

`define-macro!', the form used to define macros in older versions of 
Chez Scheme [TM, Cadence Research Systems] is also provided in the current 
version (along with the fancier `extend-syntax'/`with'). However, the older 
version (v.1.1, 1985) seems more powerful (expressive) than the current one 
(v.2.0.3, 1987)!

In the old case, it is possible to specify not just text but closures in
a "macro"'s expansion pattern. For example, the following almost pointless
program,

	(let ([null? null?])
	  (define-macro! nil? (x)
	    `(,null? ,x))		; note comma before null?

works fine in v.1.1, `nil?' being a macro version of `null?'. As motivation
for using the closure `null?' rather than the variable `null?' in the above
macro expansion, one might consider that the global variable `null?' can now 
be redefined to something else, but `nil?' will always test for nil-ness.

This ruse doesn't work in v.2.0.3:
	The program (nil? 7) yields the diagnostic:
	Error: nonsensical application (#<procedure null?> 7).

Anyone know why Cadence (Dybvig?) thought fit to do away with the old
Chez's more powerful macros? {I don't know Cadence's e-mail address.}

--dorai

ps: It might be argued that there might be newer ways (possibly using `extend-
    syntax'/`with') to get the effect described above, if not with the same 
    program fragment. Nope. There just doesn't seem a way to get closures in 
    the expansion pattern in new Chez.

Received: from SUMEX-AIM.Stanford.EDU (TCP 1200000070) by MC.LCS.MIT.EDU 21 Jul 88 18:19:53 EDT
Date: Thu, 21 Jul 88 14:33:54 PDT
From: Max Hailperin <HAILPERIN@SUMEX-AIM.Stanford.EDU>
Subject: rec definition
To: scheme@mc.lcs.mit.edu
Message-ID: <12416161820.15.HAILPERIN@SUMEX-AIM.Stanford.EDU>

I know that rec was eliminated in R^3RS, but I'm curious about it's definition
in schemes where it exists.

TI PC Scheme macroexpands (rec var val) to (letrec ((var val)) var), in
compliance with R^2RS and it's own manual *provided val isn't a lambda
expression*.  On the other hand, it macroexpands (rec var (lambda argl body))
into (letrec ((var (lambda argl body))) (lambda argl (var . argl))).

The question is: why?  It can't be a bug, as it's a special case where there
is no need for one.  But I don't understand, on the other hand, what it is
intended to achieve.

If someone from TI is on the list, I'd be grateful for the real answer.
However, I'd settle for some informed speculation from others familiar
with implementations and uses of rec.  Do any other schemes implement
rec this way?  Is there any programming paradigm it makes work where the
simple definition doesn't?  (I know of one example of the reverse.)  Is
it easier to compile the fancier version into efficient code in some cases
for some reason?

Thanks.
-------

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 21 Jul 88 07:36:56 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA05899@BLOOM-BEACON.MIT.EDU>; Thu, 21 Jul 88 07:32:29 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 20 Jul 88 21:00:41 GMT
From: titan!dorai@rice.edu  (Dorai Sitaram)
Organization: Rice University, Houston
Subject: Re:  Scheme shellscripts
Message-Id: <1700@kalliope.rice.edu>
References: <1666@kalliope.rice.edu>, <880716144458.6.JAMES@GREEN-GRASS.LCS.MIT.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

James William O'Toole Jr. <james@ZERMATT.LCS.MIT.EDU> writes:

>    Date: 16 Jul 88 08:01:32 GMT
>    From: titan!dorai@rice.edu  (Dorai Sitaram)
>
>    A shellscript written in Scheme is like any other Scheme file, except that its
>    first line has to be:
>			    runschemescript "$*" '
>    and its last line:
>			    '
>
>    The quotes are used to delimit the Scheme code which forms the body of the
>    script. The script consists of a call of the Un*x command `runschemescript' 
>    with two arguments, the first being the list of arguments to the Scheme 
>    script, and the second the text of the Scheme code in the script. Thus, a 
>    Scheme shellscript is a *true* schellscript, i.e., it is callable at the Un*x 
>    command-line, though the main part of it is a piece of text which is Scheme.
>
>    The command `runschemescript' used above is a shellscript written in the usual
>    shell language. It is the following relatively simple piece of cshell:
>
>    ...
>
>    If anyone can suggest further improvement I'll be glad to hear of it.
>
>Your method, when executed, requires starting one /bin/csh to interpret
>the shellscript, another /bin/csh to interpret the ``runschemescript''
>shellscript, copying the scheme code into a temporary file, and invoking
>the scheme implementation on that file.
>
>I would suggest that you instead place your scheme code in a file whose
>first line is ``#!/bin/scheme arg''.  If your file is called foo, and
>its first line is as given above, then when you execute foo, your Unix
>will execute the command ``/bin/scheme arg foo''.  You may omit arg, or
>choose arg to be something which speeds up /bin/scheme, or tells it to
>load the file whose name follows, or whatever.  You will have to
>convince your scheme to ignore the first line of foo, of course.  This
>method avoids starting up extra shells and copying files.
>
>  --Jim

A Refresher on #!
-----------------
If `#! A A1 ...' is the first line of a shell script file whose name is B, 
calling B with args B1 ... has the same effect as calling A with args 
A1 ... B B1 ...

In the above, A has to be a full pathname of a *standard* Un*x command (like 
cat, scheme, etc), i.e., it cannot be a user-fashioned command or shell script
(I found this out thru experimentation. Why is this?).

!# no rehserfeR A
-----------------
Jim [and J A Biep Durieux (private communication)] suggest that 
#! /usr/local/scheme be the first line of a Scheme script: this has the 
unfortunate effect that all arguments to a Scheme script will be loaded as 
Scheme files [even though they are in general, just like any shell script 
arguments, *not* Scheme files]. The script file itself is loaded into Scheme, 
which is ok, provided that its first (non-Scheme) line can somehow be removed.

However, Jim and Biep are right in stating that #! can lead to a concise
and efficient implementation of Scheme scripts. Let the first line of a 
Scheme script be the line

		#! /bin/sh runschemescript

runschemescript is a Bourne script which looks like:
********************************************
foo=$1
shift
echo > .tmp '(set! $* (quote ('$*')))'
echo -n >> .tmp ';'
cat $foo >> .tmp
echo >> .tmp '(exit)'
scheme .tmp	#this line could be 'exec scheme .tmp' but I don't know if 
		#that saves anything
********************************************

A Scheme script 'ss' looks like:
********************************************
#! /bin/sh runschemescript
<a body of Scheme code which
 refers to the list of arguments
 of `ss' by the variable $*>
********************************************
This Scheme code doesn't have the restriction of not being able to use quotes
in it. It also looks less ugly with the user not having to mention $* and use
Bourne quotes in his Scheme scripts. 

ss, when called with arguments a1 ..., gets converted (by the #!) to the call

	/bin/sh runschemescript ss a1 ...

which is the same as (with one subshell invocation)

	runschemescript ss a1 ...

runschemescript then creates a .tmp file which sets a Scheme global variable
$* to a list (a1 ...) of ss's arguments; followed by the contents of the file
ss; followed by an (exit). [A judicious ';' is inserted at the right spot to 
comment out the only non-Scheme portion of the file ss: the first line (with 
#! ...).] ss can therefore be used as a regular shell script which is written 
in Scheme rather than in Bourne.

I would like the first line of Scheme script to be just

		#! runschemescript

instead of

		#! /bin/sh runschemescript

but as said earlier, only standard Un*x commands seem to be accepted by #!.
Improvements are welcome.

--dorai

Received: from RELAY.CS.NET (TCP 1201000005) by MC.LCS.MIT.EDU 21 Jul 88 01:04:35 EDT
Received: from relay2.cs.net by RELAY.CS.NET id aa16189; 20 Jul 88 23:31 EDT
Received: from uconn by RELAY.CS.NET id ab26726; 20 Jul 88 23:16 EDT
Received: by CARCVAX.ARPA  (5.51/4.7)
	id AA11311; Wed, 20 Jul 88 09:00:51 EDT
Date: Wed, 20 Jul 88 09:00:51 EDT
From: Dong-Guk Shin <shin%carcvax.uconn@RELAY.CS.NET>
To: scheme <@RELAY.CS.NET:scheme@mc.lcs.mit.edu>

Could you please foward the message given below to the right receipient
or provide me his/her correct e-address? The message should be addressed
to MIT AI LAB who is in charge of the lisp language Scheme.  
Possible names are: H. Abelson, R. Dybvig, C Haynes, G. Rozas, N. Adams, 
D. Friedman, E. Kohlbecker, G. Sussman, D. Bartley, R. Halstead,
D. Oxley, M. Wand, G. Brooks, C. Hanson, and K. Pitman.

I have been trying to send the message to the following address (given in
one of the manual) and couldn't get it through.

            INFO-CSCHEME%OZ@MC.LCS.MIT.EDU

Appreciate in advance.

***********************************************************************

Recently we have installed the Scheme on the SUNs. We have not digested 
yet how to make complete use of it. Do you have any utility files that allow
us to manipulate property lists? We do not see them in "Revised3 Report
on the Algorithmic Language Scheme".  Also we wish to know if there is
any debugging functions.

Shin


Received: from cs.utah.edu (TCP 1200000004) by MC.LCS.MIT.EDU 20 Jul 88 14:14:21 EDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA17258; Wed, 20 Jul 88 09:50:39 MDT
Received: by cons.utah.edu (5.54/utah-2.0-leaf)
	id AA03528; Wed, 20 Jul 88 09:50:19 MDT
Date: Wed, 20 Jul 88 09:50:19 MDT
From: kessler%cons@cs.utah.edu (Robert R. Kessler)
Message-Id: <8807201550.AA03528@cons.utah.edu>
To: common-lisp@sail.stanford.edu, scheme@mc.lcs.mit.edu, fp@cs.yale.edu
Cc: chaillou@inria.inria.fr, cork@rice.edu, kessler%cons@cs.utah.edu
Subject: L&FP Transportation


For those of you arriving at the Salt Lake International Airport and
wanting transportation to Snowbird, here is the information.

Canyon Transportation has van service between the airport and
Snowbird.  The charge is $10 per person, unless you are the only
person in the van, in which case the charge will be $20.  They are
planning to be at the airport between 10 am and 10 pm on Saturday the
23rd and the same hours on Sunday the 24th.  Look for ground
transportation after you claim your baggage and you should find them.
They may be stationed inside the airport near the baggage claim, or
outside at the curb.

If you need to make special arrangements with them, particularily,
outside of the 10am to 10pm hours, you may call them at the following
number: 

(800)255-1841

You can also take a taxi, but that will cost around $40.

Bob.


Received: from ZERMATT.LCS.MIT.EDU (CHAOS 17316) by MC.LCS.MIT.EDU 18 Jul 88 15:24:57 EDT
Received: from GREEN-GRASS.LCS.MIT.EDU by ZERMATT.LCS.MIT.EDU via CHAOS with CHAOS-MAIL id 174026; Sat 16-Jul-88 14:45:21 EDT
Date: Sat, 16 Jul 88 14:44 EDT
From: James William O'Toole Jr. <james@ZERMATT.LCS.MIT.EDU>
Subject: Re:  Scheme shellscripts
To: titan!dorai@rice.edu
cc: scheme@MC.LCS.MIT.EDU
In-Reply-To: <1666@kalliope.rice.edu>
Message-ID: <880716144458.6.JAMES@GREEN-GRASS.LCS.MIT.EDU>

    Date: 16 Jul 88 08:01:32 GMT
    From: titan!dorai@rice.edu  (Dorai Sitaram)

    A shellscript written in Scheme is like any other Scheme file, except that its
    first line has to be:
			    runschemescript "$*" '
    and its last line:
			    '

    The quotes are used to delimit the Scheme code which forms the body of the
    script. The script consists of a call of the Un*x command `runschemescript' 
    with two arguments, the first being the list of arguments to the Scheme 
    script, and the second the text of the Scheme code in the script. Thus, a 
    Scheme shellscript is a *true* schellscript, i.e., it is callable at the Un*x 
    command-line, though the main part of it is a piece of text which is Scheme.

    The command `runschemescript' used above is a shellscript written in the usual
    shell language. It is the following relatively simple piece of cshell:

    ...

    If anyone can suggest further improvement I'll be glad to hear of it.

Your method, when executed, requires starting one /bin/csh to interpret
the shellscript, another /bin/csh to interpret the ``runschemescript''
shellscript, copying the scheme code into a temporary file, and invoking
the scheme implementation on that file.

I would suggest that you instead place your scheme code in a file whose
first line is ``#!/bin/scheme arg''.  If your file is called foo, and
its first line is as given above, then when you execute foo, your Unix
will execute the command ``/bin/scheme arg foo''.  You may omit arg, or
choose arg to be something which speeds up /bin/scheme, or tells it to
load the file whose name follows, or whatever.  You will have to
convince your scheme to ignore the first line of foo, of course.  This
method avoids starting up extra shells and copying files.

  --Jim

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 16 Jul 88 12:58:17 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA28866@BLOOM-BEACON.MIT.EDU>; Sat, 16 Jul 88 12:50:02 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 16 Jul 88 08:01:32 GMT
From: titan!dorai@rice.edu  (Dorai Sitaram)
Organization: Rice University, Houston
Subject: Scheme shellscripts
Message-Id: <1666@kalliope.rice.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

Hi! Thought this might be of interest.

If you've tried using shellscripts to build your own Un*x commands, felt the
shell language a bit too hairy, and would rather use Scheme instead, here's a
short fix. This assumes that the available Scheme interpiler can be called
at the Un*x prompt with a file-name which is automatically loaded before 
producing the interactive loop. E.g., Chez Scheme (copyright R. Kent Dybvig).

A shellscript written in Scheme is like any other Scheme file, except that its
first line has to be:
			runschemescript "$*" '
and its last line:
			'

The quotes are used to delimit the Scheme code which forms the body of the
script. The script consists of a call of the Un*x command `runschemescript' 
with two arguments, the first being the list of arguments to the Scheme 
script, and the second the text of the Scheme code in the script. Thus, a 
Scheme shellscript is a *true* schellscript, i.e., it is callable at the Un*x 
command-line, though the main part of it is a piece of text which is Scheme.

The command `runschemescript' used above is a shellscript written in the usual
shell language. It is the following relatively simple piece of cshell:

**************************************************************************
		echo > .tmpfile '(set! $* (quote (' $1 ')))'
		echo >>.tmpfile $2
		echo >>.tmpfile '(exit)'
		scheme .tmpfile
**************************************************************************

In effect, `runschemescript' creates a temp Scheme file which sets a global 
variable $* to the list of arguments supplied to the Scheme script, runs the 
script which uses $* to refer to its arguments and exits. This file is then 
run with the Scheme interpiler. 

An example Scheme shellscript is the Scheme compiler `sc' which can be invoked
at the Un*x command-line, in makefiles, etc [like `cc']. My `sc' looks like

*******************************************************************************
runschemescript "$*" '

(case (length $*)
  [1 (compile-file (symbol->string (car $*)))]
  [2 (compile-file (symbol->string (car $*)) (symbol->string (cadr $*)))]
  [3 (let ([$1 (car $*)] [$2 (cadr $*)] [$3 (caddr $*)])
       (cond [(eq? $1 `-o)
	      (compile-file (symbol->string $3) (symbol->string $2))]
	     [(eq? $2 `-o)
	      (compile-file (symbol->string $1) (symbol->string $3))]
	     [else (printf "Bad args to sc: ~a~n" $*)]))]
  [else (printf "Bad args to sc: ~a~n" $*)])

'
******************************************************************************

$* being a simple Scheme list of symbols, any processing of arguments or
options is straightforward. Some nits are: These Scheme shellscripts 
always have to be enclosed in runschemescript "$*" ' <body> '. The quote-
character ' {a common enough character in Scheme!} cannot be used in the 
script's body as it interferes with the shell's delimiter characters--instead 
one should use the backquote ` or "quote". Typical shellscripts use other
Un*x commands in their bodies: in Ch*z Scheme, there is a function "system" 
which enables us to call Un*x commands; but this may not be available
in other Schemes. Even in this case, calling a Scheme shellscript from 
within a Scheme shellscript will have multiple invocations of the Scheme
interpreter running simultaneously, which doesn't help a whole lot in
maintaining efficiency. Strangely, one doesn't have to bother about the
same file .tmpfile being used for such nesting--once the file is loaded,
it doesn't matter if it is used for something else.

On the whole, I've found that in a Un*x environment which supports Ch*z 
Scheme, the above technique beats writing shellscripts in cshell for sheer 
ease and maneuvrability. One can then, if one chooses, convert a fully 
debugged Scheme script to a cshell script (or a C program) to recover 
efficiency.

If anyone can suggest further improvement I'll be glad to hear of it.

--dorai

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 15 Jul 88 21:43:08 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA12616@BLOOM-BEACON.MIT.EDU>; Fri, 15 Jul 88 21:38:40 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 15 Jul 88 23:56:31 GMT
From: joyce!csl!winkler@ames.arpa  (Timothy Winkler)
Organization: Computer Science Lab, SRI International
Subject: OBJ3 Release
Message-Id: <5901@csl.CSL.SRI.COM>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


Dear Colleagues:

Release 1.0 of OBJ3 is now available!

OBJ embodies basic design choices that are quite different from those of other
programming languages, even other functional programming languages.  OBJ3 is
the latest in a series of systems consisting of an interpreter and an
environment, and it has the following properties:

  1. OBJ3 is logical, in the sense that there is a logical system L such that

     * statements in OBJ3 programs are sentences in L,

     * the denotational semantics of an OBJ3 program P is an initial model
        of P, and

     * operational semantics is given by (efficient) deduction in L.

     This allows OBJ3 to be used as a theorem prover for L.  (In fact, the
     logical system L for OBJ3 is order sorted equational logic; see below.)

  2. OBJ3 has parameterized programming, which allows very flexible program
     structuring and reuse, giving the expressive power of higher order
     programming while retaining a first order logic, and supporting the
     following features:

     * objects to contain executable code, and theories to define properties;
     
     * parameterized modules, with theories to define interfaces;

     * views to define instantiation (binding) of parameterized modules, and
       to assert properties of modules, and

     * module expressions, which describe complex (sub)system as
       interconnections of given modules (possibly parameterized), and then
       actually constructs them when evaluated.

  4. OBJ3 is based on order sorted equational logic, which provides a
     rigorous basis for

     * user-definable subtypes

     * exception handling

     * multiple inheritance

     * operation overloading and

     * retracts a form of run time type checking that supports a
       strong typing which is as flexible as weak typing.

  5. OBJ3 has user-definable evaluation strategies, which

     * can be eager, lazy, or more exotic combinations, 

     * are user definable for each operation separately (rather than
       globally), and are computed by default (using strictness analysis)
       if not given explicitly.

  6. OBJ3 has pattern matching modulo associativity and/or commutativity,
     plus identity by completion.

OBJ3 also has some features that are unusual but not unique, including

  1. user definable mixfix syntax, with precedence,

  2. user-optional memoisation on an operation-by-operation basis,

  3. user-definable built-in modules for efficient implementation of
     basic abstract data types, such as numbers and characters, and

  4. module import hierarchies.

OBJ3 has been successfully used for a variety of applications, including
research and teaching in

  1. software design

  2. software specification

  3. rapid prototyping

  4. theorem proving

  5. hardware verification

  6. functional programming.

Here is a cute little proof in OBJ3:
############################################################################
---> /dir/goguen/obj/proofs/mmm.obj
---> Fermat's "little theorem": m**p=m(mod p), for p=3

obj NAT is sort Nat .
  op 0 : -> Nat .
  op s_ : Nat -> Nat [prec 1] .
  ops (_+_)(_*_) : Nat Nat -> Nat [assoc comm] .
  vars L M N : Nat .
  eq M + 0 = M .
  eq M + s N = s(M + N) .
  eq M * 0 = 0 .
  eq M * s N = (M * N)+ M .
  eq L * (M + N) = (L * M)+(L * N) .
  eq M + M + M = 0 .
endo

---> base case, m = 0
reduce 0 * 0 * 0 == 0 .

---> induction variable and hypothesis
obj VARS is extending NAT .
  op m : -> Nat .
  eq m * m * m = m .
endo
---> induction step
reduce (s m)*(s m)*(s m) == s m .
---> QED
############################################################################

OBJ3 is written in Kyoto Common Lisp (KCL) and has been compiled on Sun3's;
presumably, it can be compiled on any machine with a Common Lisp compiler.  We
can send you an executable form of OBJ3 for Sun3's, which occupies about 4
Mbytes of disk space, or you can build OBJ3 yourself from sources, which will
require about 1 Mbyte disk space for the sources and up to 3 Mbyte for the
construction.  You will also need a license for KCL, or some other Common
Lisp.  KCL needs 4 Mbytes for its sources, up to 10 Mbytes for construction,
and its executable occupies about 2 Mbytes.  Our distribution media are Sun
cartridges, and 1/2in. tape at 1600 bpi in Unix tar format.  Our shipment will
include a file of OBJ3 examples and some documentation.

If you wish to receive the OBJ3 distribution tape, please send a request to:

	   Judith Burgess, Librarian
           Computer Science Laboratory
           SRI International
           333 Ravenswood Ave.
           Menlo Park, CA 94025, USA

           Telephone: (415) 859-5924
           ARPAnet:   burgess@csl.sri.com

Judith will then send you the OBJ3 Information Form, and License Agreement,
with instructions on how to fill them out.  When you return them to us,
appropriately filled out and signed, with a check or money order for $150 in
US dollars payable to SRI International, we can then send you the tape and
documentation.

Sincerely yours,

Joseph Goguen, Jose Meseguer, and Timothy Winkler
Computer Science Laboratory
SRI International
333 Ravenswood Ave.
Menlo Park, California 94025, USA

Received: from cs.utah.edu (TCP 1200000004) by MC.LCS.MIT.EDU 12 Jul 88 12:43:17 EDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA10136; Tue, 12 Jul 88 10:42:01 MDT
Received: by cons.utah.edu (5.54/utah-2.0-leaf)
	id AA26236; Tue, 12 Jul 88 10:41:49 MDT
Date: Tue, 12 Jul 88 10:41:49 MDT
From: kessler%cons@cs.utah.edu (Robert R. Kessler)
Message-Id: <8807121641.AA26236@cons.utah.edu>
To: common-lisp@sail.stanford.edu, fp@cs.yale.edu, scheme@mc.lcs.mit.edu
Subject: L&FP Registration -- FINAL CALL


This is the final call for registration for the conference.  ACM is
accepting registration by EMAIL, so please send your information to
them (meetings@acmvm.bitnet).  Note, if you plan on using a credit
card, please include the name on the card, the type of card, the
number, and the expiration date.  Also, please include the following
information.  NOTE -- the final deadline for advance registration is
this FRIDAY, JULY 15.  Also, you will have to make your own
reservations at Snowbird by calling Snowbird Central Reservations at 
(800)453-3000 or (801)532-1700.

It looks like it will be a great conference.  We are looking forward to
seeing you there.

Bob.
====================================================================

====================== L&FP 88 Registration Form ====================


The registration fees for applications prior to June 24 are:

Student	$75
ACM or SIG (PLAN, ART, or ACT) Member Only	$250
ACM and SIG Member	$225
Non-Member	$290

The registration fees for applications after that date are:

Student	$100
ACM or SIG (PLAN, ART, or ACT) Member Only	$300
ACM and SIG Member	$275
Non-Member	$350

Additional banquet tickets (for students or guests) are $40
Additional luncheon tickets are $12.50

Make your own application form including

	Your Name
	Company/Institution
	Address
	Telephone
	E-mail Address
	Membership status in ACM and SIGPLAN/SIGART/SIGACT including
		membership number

	Your fee category (as described above)
	Your order for any extra banquet or luncheon tickets
	Total fees enclosed
	Form of payment (check/credit card)
	Credit card type (Mastercard, Visa, or Amer Express), number,
		expiration date, and signature if paying by credit card
	Mailing List Restriction: (one of No Restictions, ACM and Other
		Society Announcements, ACM Announcements)

If paying by check, make check payable (in US funds only!) to:

	ACM LFP '88

Mail your form and payment to:

	ACM LFP '88
	P.O. Box 12105
	Church Street Station
	New York, NY  10249


Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 11 Jul 88 17:11:27 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA12106@BLOOM-BEACON.MIT.EDU>; Mon, 11 Jul 88 17:01:06 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 11 Jul 88 20:43:30 GMT
From: dartvax!kinsman.dartmouth.edu!hugo@bu-cs.bu.edu
Organization: Dartmouth College
Subject: Documentation for T
Message-Id: <9203@dartvax.Dartmouth.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


Hi,

I just gleefully managed to FTP T from wheaties.ai.mit.edu only to
find out that the documentation was done in SCRIBE, and besides that,
it seemed to describe an earlier version of the system.  I was
wondering if anyone out there has a newer version of the documents
that is in either TeX, Interpress, or postscript format?

Thanks a bunch,
Pete

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU  6 Jul 88 12:33:27 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA05535@BLOOM-BEACON.MIT.EDU>; Wed, 6 Jul 88 12:32:01 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 5 Jul 88 18:39:29 GMT
From: eagle!dat@bloom-beacon.mit.edu  (D.A.Turner)
Organization: Computing Lab, University of Kent at Canterbury, UK.
Subject: Miranda (correction)
Message-Id: <5333@eagle.ukc.ac.uk>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

Miranda (correction)
-------
The arpanet address for obtaining  further  information  about  the  new
release of the Miranda functional programming system is
	mira-request%ukc@nss.cs.ucl.ac.uk
this address was garbled in an earlier message.  In fact from many sites
	mira-request@ukc.ac.uk		(uucp: mcvax!ukc!mira-request)
will  work  too.   Apologies  to  people  whose requests for information
didn't get through.

Received: from goldberg.cs.nyu.edu (TCP 20036506026) by MC.LCS.MIT.EDU  5 Jul 88 01:42:45 EDT
Received:  by goldberg.cs.nyu.edu (3.2/25-eef)
	id AA04285; Tue, 5 Jul 88 01:36:51 EDT
Date: Tue, 5 Jul 88 01:36:51 EDT
From: Ben Goldberg <goldberg@goldberg.cs.nyu.edu>
Message-Id: <8807050536.AA04285@goldberg.cs.nyu.edu>
To: scheme@mc.lcs.mit.edu, windley@iris.ucdavis.edu
Subject: Re:  ML info

    I seem to remember some discussions about ML in this group several months
    ago.  Does anyone know of work on concurrent/multiprocessing versions of ML
    or object-oriented extensions to ML?  ML seems close enough in spirit to
    Scheme that something like SCOOPS could be used as a model.

In the upcoming Lisp & FP conference, there is a paper by John Mitchell
and Lelita Jategoankar (spelling?) on ML+, an object oriented extension
to ML.

						-Ben Goldberg
						 NYU
	
	
	
	

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU  4 Jul 88 19:48:57 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA23716@BLOOM-BEACON.MIT.EDU>; Mon, 4 Jul 88 19:44:10 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 4 Jul 88 09:13:53 GMT
From: mcvax!inria!dupont@uunet.uu.net  (Francis Dupont)
Organization: INRIA, Rocquencourt. France
Subject: Re: ML info
Message-Id: <725@inria.UUCP>
References: <8807020720.AA25763@iris.ucdavis.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

> I seem to remember some discussions about ML in this group several months
> ago.  Does anyone know of work on concurrent/multiprocessing versions of ML
> or object-oriented extensions to ML?

 I am working on a parallel version of CAML (the local dialect of ML).
It is an extension of a strict+lazy system (like MultiLisp), it runs
on a shared memory multiprocessor (a Sequent Balance).
 I don't know any object-oriented extension of ML. The static (compile-time)
polymorphic type-checking of ML and objects don't work well together. But
see Luca Cardelli's languages Amber and Quest.

Francis Dupont (INRIA Rocquencourt, France)

Internet : dupont@inria.inria.fr
Uucp : mcvax!inria!dupont
X400 : /C=Fr/ADMD=PTT/PRMD=aristote/ORG=inria/OU=pommard/S=Dupont/G=Francis

Received: from RELAY.CS.NET (TCP 1201000005) by MC.LCS.MIT.EDU  3 Jul 88 16:18:54 EDT
Received: from relay2.cs.net by RELAY.CS.NET id aa04911; 3 Jul 88 16:14 EDT
Received: from carleton.edu by RELAY.CS.NET id aj18391; 3 Jul 88 16:03 EDT
Date: Fri, 1 Jul 88 16:04 CST
From: RKIRCHNE%carleton.edu@RELAY.CS.NET
Subject: Scheme for SUN 386i
To: scheme@mc.lcs.mit.edu
X-VMS-To: IN%"scheme@mc.lcs.mit.edu"

I've been using PC Scheme on a PC and Chez Scheme on our VAX.  We've
just ordered a SUN 386i.  What are our options for Scheme on this
machine?  I expect to be able to continue to use PC Scheme, but wondered
about others.  Is there any way to use SUN graphics from a Scheme?

Received: from clover.ucdavis.edu (TCP 20036034401) by MC.LCS.MIT.EDU  2 Jul 88 03:22:42 EDT
Received: from iris.ucdavis.edu by clover.ucdavis.edu (5.59/4.7)
	id AA18360; Sat, 2 Jul 88 00:12:37 PDT
Received: by iris.ucdavis.edu (5.51/3.14)
	id AA25763; Sat, 2 Jul 88 00:20:44 PDT
Message-Id: <8807020720.AA25763@iris.ucdavis.edu>
Qotw: Never attribute to malice what
      can be adequately explained by stupidity.
Pointers: (916) 752-7324/3168
To: scheme@mc.lcs.mit.edu
Subject: ML info
Date: Sat, 02 Jul 88 00:20:42 PDT
From: Phil Windley <windley@iris.ucdavis.edu>


I seem to remember some discussions about ML in this group several months
ago.  Does anyone know of work on concurrent/multiprocessing versions of ML
or object-oriented extensions to ML?  ML seems close enough in spirit to
Scheme that something like SCOOPS could be used as a model.

Phil Windley                          |  windley@iris.ucdavis.edu
Robotics Research Lab                 |  ucbvax!ucdavis!iris!windley
University of California, Davis       |

Received: from Xerox.COM (TCP 1500006350) by MC.LCS.MIT.EDU 29 Jun 88 13:51:59 EDT
Received: from Cabernet.ms by ArpaGateway.ms ; 29 JUN 88 10:46:38 PDT
Date: 29 Jun 88 10:31 PDT
From: Fischer.pa@Xerox.COM
Subject: Production quality Scheme compilers
To: scheme@MC.LCS.MIT.EDU
Message-ID: <880629-104638-2611@Xerox>

Can anyone offer a list of manufacturers who sell (or distribute) production
quality Scheme compilers?  Comments on the technology used and how that affects
benchmarks are much appreciated.

(ron)

Received: from CUNYVM.CUNY.EDU (TCP 20071000402) by MC.LCS.MIT.EDU 29 Jun 88 04:16:13 EDT
Received: from DBIUNI11.BITNET by CUNYVM.CUNY.EDU (IBM VM SMTP R1.1) with BSMTP id 4301; Wed, 29 Jun 88 03:02:41 EDT
Date: Wed, 29 Jun 88 09:02:12 EDT
To: scheme@mit-mc.ARPA
From: UHRZB001%DBIUNI11.BITNET@CUNYVM.CUNY.EDU
Comment: CROSSNET mail via SMTP@INTERBIT

from: Bernd Nienaber
      Universitaet Bielefeld
      Computer center
      Postfach 8640
D4800 Bielefeld
      W.-Germany
      Bitnet(Earn):UHRZB001@DBIUNI11

to:   INFO-CSCHEME@MIT-MC


Dear Sirs,
some users of our computer centre want to run Scheme on the HP9000/850
minicomputer. Under which conditions can we get a Scheme licence for
the HP9000/850 ?
                               Regards
                             Bernd Nienaber

Received: from F.GP.CS.CMU.EDU (TCP 20000575244) by MC.LCS.MIT.EDU 25 Jun 88 18:14:09 EDT
Date: 25 Jun 1988 17:46-EDT 
From: Barak.Pearlmutter@F.GP.CS.CMU.EDU
To: scheme@mc.lcs.mit.edu
Cc: kjl@g, unido!gmdxps!thomas@uunet.UU.NET, twleung@ATHENA.MIT.EDU,
	  death@ZERMATT.LCS.MIT.EDU, jch@citi.umich.edu,
	  voder!cullsj!jeff@bloom-beacon.mit.edu,
	  john@nsr.bioeng.washington.edu, FAUSETT@RADC-TOPS20.ARPA
Subject: FTPing Oaklisp
Message-Id: <Sat.Jun.25.17:46:54.1988/bap@F.GP.CS.CMU.EDU>

A number of people have asked if I could mail them copies of Oaklisp, or
even send tapes.  I'm very sorry, but the answer is catagorically no; I
don't even have the time to answer such mail individually.  Perhaps some
kind person will post Oaklisp to comp.sources, solving this problem for
uucp people.  (I am willing to hand carry a tape to a warm clime, like
California, if you provide the transportation.)

I have also been deluged with mail concerning problems FTPing Oaklisp,
so I am posting more extensive instructions.  The correct way to FTP
Oaklisp is as follows:

    cd where/you/want/the/stuff
    ftp doghen.boltz.cs.cmu.edu           [or 128.2.222.37 if necessary]
     user ftpguest                        [whatever your client likes here]
     password oaklisp                      [password is in lowercase]
     get oak/release.tar.Z release.tar.Z  [not a typo]
     quit
    uncompress release.tar.Z
    tar xf release.tar
    ...

NOTE: The ftp server on DOGHEN has a bug and fails if you try to switch
      directories, so don't use ftp's CD command.

						--Barak.

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 23 Jun 88 01:53:26 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA03940@BLOOM-BEACON.MIT.EDU>; Thu, 23 Jun 88 01:48:00 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 23 Jun 88 01:00:59 GMT
From: voder!cullsj!jeff@bloom-beacon.mit.edu  (Jeffrey C. Fried)
Organization: Cullinet Software, San Jose, CA
Subject: Re: Oaklisp
Message-Id: <332@cullsj.UUCP>
References: <Wed.Jun.22.00:16:47.1988.bap@F.GP.CS.CMU.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


   I am unable to FTP or anonymous UUCP, can you e-mail a copy to me?

-------------------------------------------------------------------
Jeff Fried                           UUCP: ...!ames!cullsj!jeff
                                           Reality, what a concept!
San Jose, CA, 95134 (clearly work)         San Mateo, CA  (home)
(408) 434-6636                             (415) 349-3744

Disclaimer: Opinions expressed are solely those of the author.

Received: from F.GP.CS.CMU.EDU (TCP 20000575244) by MC.LCS.MIT.EDU 22 Jun 88 00:42:16 EDT
Date: 22 Jun 1988 00:16-EDT 
From: Barak.Pearlmutter@F.GP.CS.CMU.EDU
To: mcvax!unido!gmdzi!thomas@uunet.uu.net  (Thomas Gordon)
Cc: scheme@mc.lcs.mit.edu
Subject: Re: Oaklisp
Message-Id: <Wed.Jun.22.00:16:47.1988/bap@F.GP.CS.CMU.EDU>

>>From article <8806031654.AA00871@BLOOM-BEACON.MIT.EDU>, by NETWORK@FRSAC11.BITNET:
>> 
>> Did anybody succeed in porting OAK to System V ?
>> Or to an other cpu than sun/VAX/rt ?
>
>If I recall correctly, Oaklisp is an interesting object-oriented dialect
>of Scheme that was originally implemented on the Macintosh.  I do not
>know if it has been ported anywhere, but this is the first I hear that
>it is available at all.  I would love to play with the Macintosh version.
>Does anyone know if it is available?
>
>Thomas F. Gordon		email: thomas@gmdxps.uucp

Actually, our implementation of Oaklisp was developed on a Sun, although
I will also run on most any Unix box, and probably on a Macintosh.

We aren't doing any support at all, but AT YOUR OWN RISK you can ftp a
compressed tar file of the latest release from DOGHEN.BOLTZ.CS.CMU.EDU,
user "ftpguest", password "oaklisp", file "oak/release.tar.Z".  Be sure
to use binary mode.  This isn't a real release.  No support.  You're on
your own.

						--Barak.

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 21 Jun 88 20:08:10 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA02880@BLOOM-BEACON.MIT.EDU>; Tue, 21 Jun 88 20:05:59 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 20 Jun 88 12:22:11 GMT
From: mcvax!unido!gmdzi!thomas@uunet.uu.net  (Thomas Gordon)
Organization: GMD, Sankt Augustin, F. R. Germany
Subject: Re: Oaklisp
Message-Id: <578@gmdzi.UUCP>
References: <8806031654.AA00871@BLOOM-BEACON.MIT.EDU>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

From article <8806031654.AA00871@BLOOM-BEACON.MIT.EDU>, by NETWORK@FRSAC11.BITNET:
> 
> Did anybody succeed in porting OAK to System V ?
> Or to an other cpu than sun/VAX/rt ?

If I recall correctly, Oaklisp is an interesting object-oriented dialect
of Scheme that was originally implemented on the Macintosh.  I do not
know if it has been ported anywhere, but this is the first I hear that
it is available at all.  I would love to play with the Macintosh version.
Does anyone know if it is available?


Thomas F. Gordon		email: thomas@gmdxps.uucp
GMD / F3			phone: (+49 2241) 14-2665
Schloss Birlinghoven
D-5205 Sankt Augustin 1, FRG
-- 
Thomas F. Gordon		email: thomas@gmdxps.uucp
GMD / F3			phone: (+49 2241) 14-2665
Schloss Birlinghoven
D-5205 Sankt Augustin 1, FRG

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 18 Jun 88 03:51:58 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA02927@BLOOM-BEACON.MIT.EDU>; Sat, 18 Jun 88 03:39:28 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 18 Jun 88 05:53:56 GMT
From: nyser!cmx!billo@itsgw.rpi.edu  (Bill O)
Organization: Northeast Parallel Architectures Center, Syracuse NY
Subject: Parallel Lisps for Parallel Machines
Message-Id: <533@cmx.npac.syr.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

There has been quite a bit of interest expressed in this group (and
others) regarding parallel Lisps for parallel machines.  I have been
one of the people expressing interest, and am very thankful for all of
you in Netland who helped me find the information I needed.  I
promised to post a summary of my findings, but once I started writing,
the summary turned into a small technical report. This report has now
been published in our (Northeast Parallel Architectures Center)
newsletter so, rather than chew-up net bandwidth more than I already
have, I would like to offer to send the report to anyone who is
interested.  Just email your Snail Mail address (you know, the one
with street names, zip codes, and the like) to our newsletter editor
(it's ok, I asked her if I could do this) at:

editor@cmx.npac.syr.edu

Please don't send your request to me, I'll just have to forward it to
the editor.

If you have trouble getting your email through, you could always try a 
postcard or letter addressed to:

Newsletter Editor
NPAC
250 Machinery Hall
Syracuse University
Syracuse NY 13244

Also, please feel free to request a subscription even if your interest
in parallel computation is less specific than Lisp.  Each issue (10
per year) has a technical report on some aspect of parallel
computation.

Here is what's covered in my report:

1) a brief introduction to Lisp.  Sorry to all you Lispers (hi Bjorn) --
   you'll just have to skip this section of the report.

2) an inordinately brief treatment of automatically parallelizing Lisps,
   like Parcel (for the Alliant), and Lisps with explicit synchronization
   mechanisms, like ZLISP (for the Ultracomputer).

3) fuller treatments of QLisp (Alliant), Multilisp (Encore Multimax), and
   *Lisp (Connection Machine).

4) mere mention of Multischeme, Schemes and Lisps for the BBN Butterfly,
   Linda Lisp (which is commercially available for transputers),
   CM Lisp (Connection Machine) and Paralation Lisp (Connection Machine, 
   and possibly other architectures).

5) a relatively complete bibliography covering all of the above.

   (Aside: I have heard that at this summer's ACM Parallel Processing
   conference there will be a paper by Carriero and Gelernter (et al?)
   mentioning Linda-based Lisp.  I couldn't get the details in time to
   include the reference in my bibliography.)
   
Please note that the amount of space devoted in my tech. report to any
given version of Lisp is not correlated with the importance of that
version of Lisp.  The only correlation is with my ignorance, combined
with time and space restrictions.  Also note that the mapping from
Lisps to machines isn't really a partial function as seems to be
implied by the above list -- those are just the high spots.

The tech. report does not list the email addresses of whom you need to
contact in order to get these Lisps, but if you send me a message (at
billo@cmx.npac.syr.edu) saying which one(s) you're interested in, I'll
send you any addresses that seem appropriate.  I think posting them
might be a bit presumptuous of me.

If you know of any parallel Lisps not mentioned above, I would
appreciate your letting me know.  And thanks again to all those who
responded to my parallel Lisp posting several weeks ago. Sorry for
being so slow with my summary -- been a tad busy.

Bill O'Farrell, Northeast Parallel Architectures Center at Syracuse University

Received: from AI.AI.MIT.EDU (CHAOS 3130) by MC.LCS.MIT.EDU 17 Jun 88 13:07:07 EDT
Date: Fri, 17 Jun 88 13:08:23 EDT
From: Jonathan A Rees <JAR@AI.AI.MIT.EDU>
Subject:  Online copy of the RR..R report?
To: "STEVER@IVORY.S4CC.SYMBOLICS.COM"@AI.AI.MIT.EDU
cc: scheme@MC.LCS.MIT.EDU
In-reply-to: Msg of Tue 14 Jun 88 11:18 EDT from Stephen Robbins <Stever@IVORY.S4CC.Symbolics.COM>
Message-ID: <399323.880617.JAR@AI.AI.MIT.EDU>

    Date: Tue, 14 Jun 88 11:18 EDT
    From: Stephen Robbins <Stever@IVORY.S4CC.Symbolics.COM>
    To:   scheme@mc.lcs.mit.edu
    Re:   Online copy of the RR..R report?

    Is there an online copy of the Revised^n Report available
    for internet FTP?

It appears that you can connect to ZURICH.AI.MIT.EDU, log in as
anonymous, and get the file pub/r3rs.tar.  Be sure to set binary mode
first, as the file is a unix "tape archive" file.  If you don't have
software to read such things, send mail to scheme-request@MC and
something can probably be worked out.  (I think it may exist in a
publicly accessible location on PREP.)


Received: from cs.utah.edu (TCP 1200000004) by MC.LCS.MIT.EDU 16 Jun 88 13:34:15 EDT
Received: by cs.utah.edu (5.54/utah-2.0-cs)
	id AA10510; Thu, 16 Jun 88 11:33:29 MDT
Received: by cons.utah.edu (5.54/utah-2.0-leaf)
	id AA10812; Thu, 16 Jun 88 11:33:22 MDT
Date: Thu, 16 Jun 88 11:33:22 MDT
From: kessler%cons@cs.utah.edu (Robert R. Kessler)
Message-Id: <8806161733.AA10812@cons.utah.edu>
To: scheme@mc.lcs.mit.edu
Subject: L&FP 88 Registration Forms


Apparently many people have not yet received the advance registration
forms from ACM.  Supposedly, it was sent to all members of SIGPLAN,
SIGART, and SIGACT, along with about 250 of the people who attended
the 1986 conference (according to the Post Office, this went to 16,000
people on May 10???, the remaining that went first class and overseas
were mailed before that).  Anyway, here is a pseudo electronic version
of registration form.  Please provide ACM with all of this information
detailed here.

Thanks.
Bob.

====================== L&FP 88 Registration Form ====================


The registration fees for applications prior to June 24 are:

Student	$75
ACM or SIG (PLAN, ART, or ACT) Member Only	$250
ACM and SIG Member	$225
Non-Member	$290

The registration fees for applications after that date are:

Student	$100
ACM or SIG (PLAN, ART, or ACT) Member Only	$300
ACM and SIG Member	$275
Non-Member	$350

Additional banquet tickets (for students or guests) are $40
Additional luncheon tickets are $12.50

Make your own application form including

	Your Name
	Company/Institution
	Address
	Telephone
	E-mail Address
	Membership status in ACM and SIGPLAN/SIGART/SIGACT including
		membership number

	Your fee category (as described above)
	Your order for any extra banquet or luncheon tickets
	Total fees enclosed
	Form of payment (check/credit card)
	Credit card type (Mastercard, Visa, or Amer Express), number,
		and signature if paying by credit card
	Mailing List Restriction: (one of No Restictions, ACM and Other
		Society Announcements, ACM Announcements)

If paying by check, make check payable (in US funds only!) to:

	ACM LFP '88

Mail your form and payment to:

	ACM LFP '88
	P.O. Box 12105
	Church Street Station
	New York, NY  10249



Received: from IVORY.S4CC.Symbolics.COM (TCP 20024231401) by MC.LCS.MIT.EDU 14 Jun 88 14:19:06 EDT
Received: from YELLOWSTONE.S4CC.Symbolics.COM by IVORY.S4CC.Symbolics.COM via CHAOS with CHAOS-MAIL id 182867; Tue 14-Jun-88 11:19:41 EDT
Date: Tue, 14 Jun 88 11:18 EDT
From: Stephen Robbins <Stever@IVORY.S4CC.Symbolics.COM>
Subject: Online copy of the RR..R report?
To: scheme@mc.lcs.mit.edu
Message-ID: <19880614151816.5.STEVER@YELLOWSTONE.S4CC.Symbolics.COM>

Hi,

Is there an online copy of the Revised^n Report available
for internet FTP?

- Stephen

Received: from Xerox.COM (TCP 1500006350) by MC.LCS.MIT.EDU  9 Jun 88 17:38:54 EDT
Received: from Burger.ms by ArpaGateway.ms ; 09 JUN 88 14:31:06 PDT
Sender: "Leo_Vetter.WBST207V"@Xerox.COM
Date: 9 Jun 88 13:25:50 PDT (Thursday)
Subject: Remove from Distribution
From: "Leo_Vetter.WBST207V"@Xerox.COM
To: LispUsers^.X@Xerox.COM, scheme@mc.lcs.mit.EDU,
 common-lisp@sail.stanford.EDU, info-1100@sumex-aim.stanford.EDU,
 franz-friends@berkeley.EDU, kcl@cli.COM
cc: LV.WBST207V@Xerox.COM
Reply-to: "Leo_Vetter.WBST207V"@Xerox.COM
Message-ID: <880609-143106-5374@Xerox>

Please remove me from all LISP DLs.

Thanks,

Leo Vetter

Received: from bu-it.BU.EDU (TCP 20061201050) by MC.LCS.MIT.EDU  9 Jun 88 07:12:12 EDT
Return-Path: <gjc>
Received: by bu-it.BU.EDU (5.58/4.7)
	id AA26825; Thu, 9 Jun 88 07:09:37 EDT
Date: Thu, 9 Jun 88 07:09:37 EDT
From: gjc@bu-it.BU.EDU (George J. Carrette)
Message-Id: <8806091109.AA26825@bu-it.BU.EDU>
To: scheme@mc.lcs.mit.edu
Subject: siod-v1.3 now in comp.sources.unix

Siod went out on comp.sources.unix sometime this week.
Here are some benchmark results for a random selection of
machines I happened to have handy. Not very favorable to DEC machines
compared with most other benchmarks. Someone on this list said they had
IBM 3090 timings?

Make     Model             FIB(5) FIB(10) FIB(15) FIB(20)  20/FIB(20)
Sun      4                  0.00   0.02    0.38     4.2     4.76
DIGITAL  8530(VMS)          0.00   0.07    0.78     8.5     2.35
Sun      3/280              0.00   0.10    0.88     8.5     2.35
Sun      3/180              0.02   0.15    1.56    17.5     1.14
Encore   Multimax(NS32)     0.02   0.17    1.85    20.5     0.97
DIGITAL  VS-2000            0.02   0.30    3.56    39.7     0.50
Encore   Multimax(NS16)     0.03   0.33    3.63    40.4     0.49
AMIGA    500 LATTICE C      0.00   0.00    5.00    55.0(x)  0.36
DIGITAL  11-750(4.3BSD)     0.03   0.53    5.80    66.5     0.30

Unix compilations done with the -O flag. All 68020 machines
with -f68881. Heap size of 120000 used. Timing done with standard-fib
procedure in siod.scm using SIOD Version 1.3 (which is slightly slower
than earlier versions). AMIGA 500 FIB(20) time is extrapolated from
the FIB(15) time.

 n  FIB(n)  Cons Work
 5      5      66
10     55     795
15    610    8877
20   6765   98508




Received: from Xerox.COM (TCP 1500006350) by MC.LCS.MIT.EDU  8 Jun 88 18:01:12 EDT
Received: from Cabernet.ms by ArpaGateway.ms ; 08 JUN 88 12:59:43 PDT
Date: Wed, 8 Jun 88 11:49:09 PDT
From: Pavel.pa@Xerox.COM
Subject: Call for publishable code!
To: LispUsers^.x@Xerox.COM, scheme@mc.lcs.mit.edu,
 common-lisp@sail.stanford.edu, info-1100@sumex-aim.stanford.edu,
 franz-friends@berkeley.edu, kcl@cli.com
Reply-To: Pavel.pa@Xerox.COM
Message-ID: <880608-125943-2995@Xerox>

I am the editor of the new Algorithms department of the international
newsletter/journal Lisp Pointers.  The department is intended to cater to the
perceived preferences of most Lisp hackers: they'd rather write code than
articles.  The articles in the department therefore fall into one or more of the
following three broad categories:

-- Annotated implementations of interesting and relevant algorithms that make
particularly good or novel use of the unique features of the Lisp family of
programming languages (e.g., closures, continuations, code as data,
polymorphism),

-- Annotated implementations of algorithms whose subject matter is the Lisp
family of languages (e.g., code analysis tools, iteration facilities, generic
arithmetic), and

-- Discussion of performance issues, benchmarking, or implementation experiences
for interesting algorithms written in or about the Lisp family of languages.

I am continually looking for ideas for appropriate articles for the department.
If you've got a nice hack you're proud of, or a particularly elegant piece of
code (you know, the kind that you call in one of your fellow hackers to see) and
you'd like to see it written up in the Algorithms department, please send it
along.  What you give me doesn't have to be polished or even contain any prose;
if I agree that it's appropriate for the column, I'll work with you to put
together an article around it.

Hoping to hear from you,

	Pavel Curtis
	Xerox PARC/CSL
	3333 Coyote Hill Rd.
	Palo Alto, CA  94304
	
	(415) 494-4455
	
	Pavel.pa@Xerox.Com

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU  3 Jun 88 19:44:11 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA10836@BLOOM-BEACON.MIT.EDU>; Fri, 3 Jun 88 19:39:46 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 3 Jun 88 19:23:56 GMT
From: killer!pollux!ti-csl!mips!gateley@ames.arpa  (John Gateley)
Organization: TI Computer Science Center, Dallas
Subject: Re: collect special form for streams
Message-Id: <50694@ti-csl.CSNET>
References: <294@gt-eedsp.UUCP>, <50472@ti-csl.CSNET>, <748@thalia.rice.edu>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

In article <748@thalia.rice.edu> matthias@rice.edu (Matthias Felleisen) writes:
>In article <50472@ti-csl.CSNET> gateley@mips.UUCP (John Gateley) writes:
>>In article <294@gt-eedsp.UUCP> schw@gt-eedsp.UUCP (Dave Schwartz) writes:
>>>How can the "collect" special form for streams (from Chap. 3 of
>>>[...]
>>Extend-syntax's pattern matching is not powerful enough to do this.
>>[...]
>John, what do you think of this one?  
>[Matthias's code deleted]
>
>P.S. Eugene Kohlbecker invented extend-syntax.

Hi Matthias,

As usual you are right and I am wrong. Let me rephrase it a bit:
Extend-syntax is not powerful enough to do it without using help
macros. I can generate the (car (cdr (... tuple))) pattern without
using 'with' or your rebinding of tuple, but I dont think that it
can be done as part of the collect macro without actually changing
the definition of collect. I dont want to rebind tuple because it
changes the pattern matching part of the problem. If you change the
definition, then I think you can do it. Can you prove me wrong this
time?

John

Received: from MITVMA.MIT.EDU (TCP 2227000003) by MC.LCS.MIT.EDU  3 Jun 88 10:35:05 EDT
Received: from MITVMA.MIT.EDU by MITVMA.MIT.EDU (IBM VM SMTP R1.1) with BSMTP id 2475; Fri, 03 Jun 88 10:32:23 EDT
Received: from FRSAC11.BITNET (NETWORK) by MITVMA.MIT.EDU (Mailer X1.25) with
 BSMTP id 2474; Fri, 03 Jun 88 10:32:21 EDT
Date: Fri, 03 Jun 88 16:29:43 GMT
To: scheme@mc.lcs.MIT.EDU
From: NETWORK%FRSAC11.BITNET@MITVMA.MIT.EDU
Comment: CROSSNET mail via MAILER@MITVMA
Subject: Oaklisp

Date: 3 June 1988, 16:26:54 GMT
From: NETWORK  at FRSAC11
To:   SCHEME at MC.LCS

Did anybody succeed in porting OAK to System V ?
Or to an other cpu than sun/VAX/rt ?
I tried hard with the March and May release and cant have the thing
run. (Compile quite OK. quite)

Jean-Pierre H. Dumas

network@frsac11 (bitnet)
network%frsac11.bitnet@cunyvm.cuny.edu (arpanet)
dumas@sumex-aim.stanford.edu (arpanet)

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU  1 Jun 88 17:12:56 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA06718@BLOOM-BEACON.MIT.EDU>; Wed, 1 Jun 88 16:59:06 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 1 Jun 88 19:09:26 GMT
From: leto!matthias@rice.edu  (Matthias Felleisen)
Organization: Rice University, Houston
Subject: Re: collect special form for streams
Message-Id: <748@thalia.rice.edu>
References: <294@gt-eedsp.UUCP>, <50472@ti-csl.CSNET>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

In article <50472@ti-csl.CSNET> gateley@mips.UUCP (John Gateley) writes:
>In article <294@gt-eedsp.UUCP> schw@gt-eedsp.UUCP (Dave Schwartz) writes:
>>How can the "collect" special form for streams (from Chap. 3 of
>>Structure and Interpretation of Computer Programs) be implemented for
>>TI PC-Scheme? I have Kent Dybvig's "extend-syntax," but this does not
>>appear to be powerful enough for this special form.
>
>Extend-syntax's pattern matching is not powerful enough to do this.
>You have to use the "with" feature to generate the v functions. (by calling
>a function which builds them, i.e. you do them by hand). I also used a
>help macro to make the flatmap parts of the expression (watch out for
>keywords). If this is not enough help, email me and I will send you my code.
>
>John Gateley
>gateley@tilde.csc.ti.com

John, what do you think of this one?  

(syntax
 (collect <result> ((<v1> <set1>) ...) <restriction>)
 (map (lambda (tuple)
	(help-res (<v1> ...) <result>))
      (filter (lambda (tuple)
		(help-res (<v1> ...) <restirction>))
	      (flat-help ((<v1> <set1>) ...) (list <v1> ...)))))

(extend-syntax (help-res)
  [(help-res (<v1> <v2> ...) <res>)
   (let ((<v1> (car tuple)) (tuple (cdr tuple)))
     (help-res (<v2> ...) <res>))]
  [(help-res () <res>) <res>])

(extend-syntax (flat-help)
  [(flat-help ((<v1> <set1>) (<v2> <set2>) (<v3> <set3>) ...) last)
   (flatmap (lambda (<v1>)
	      (flat-help ((<v2> <set2>) (<v3> <set3>) ...) last))
	    <set1>)]
  [(flat-help ((<v1> <set1>)) last)
   (map (lambda (<v1>) last) <set1>)])

-- Matthias 

P.S. Eugene Kohlbecker invented extend-syntax.

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU  1 Jun 88 01:42:52 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA14590@BLOOM-BEACON.MIT.EDU>; Tue, 31 May 88 20:11:02 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 31 May 88 21:01:46 GMT
From: tness7!killer!pollux!ti-csl!mips!gateley@bellcore.bellcore.com  (John Gateley)
Organization: TI Computer Science Center, Dallas
Subject: Re: collect special form for streams
Message-Id: <50472@ti-csl.CSNET>
References: <294@gt-eedsp.UUCP>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu

In article <294@gt-eedsp.UUCP> schw@gt-eedsp.UUCP (Dave Schwartz) writes:
>How can the "collect" special form for streams (from Chap. 3 of
>Structure and Interpretation of Computer Programs) be implemented for
>TI PC-Scheme? I have Kent Dybvig's "extend-syntax," but this does not
>appear to be powerful enough for this special form.

Extend-syntax's pattern matching is not powerful enough to do this.
You have to use the "with" feature to generate the v functions. (by calling
a function which builds them, i.e. you do them by hand). I also used a
help macro to make the flatmap parts of the expression (watch out for
keywords). If this is not enough help, email me and I will send you my code.

John Gateley
gateley@tilde.csc.ti.com

Received: from gateway.mitre.org (TCP 1200200157) by MC.LCS.MIT.EDU  1 Jun 88 00:05:51 EDT
Received: by gateway.mitre.org (5.54/SMI-2.2)
	id AA05908; Tue, 31 May 88 15:26:59 EDT
Return-Path: <howell%community-chest.mitre.org@gateway.mitre.org>
Received: by boardwalk.mitre.org (3.2/SMI-2.2)
	id AA01271; Tue, 31 May 88 15:26:35 EDT
From: howell%community-chest.mitre.org@gateway.mitre.org
Message-Id: <8805311926.AA01271@boardwalk.mitre.org>
To: scheme@mc.lcs.mit.edu
Cc: howell@mitre.ARPA
Subject: Miranda
Date: Tue, 31 May 88 15:26:33 -0400

An announcement of an implementation of Miranda was recently posted to
this mailing list; I apologize for sending this to the entire list, but I
deleted that mail message inadvertantly before I had a chance to respond.
If someone would re-post it to me, I'd appreciate it.

Thanks,
 
     Chuck Howell
     The MITRE Corporation, Mail Stop Z645
     7525 Colshire Drive, McLean, VA 22102
     NET:  howell@mitre.arpa or 
           howell%community-chest.mitre.org@gateway.mitre.org

Received: from IBM.COM (TCP 30001235007) by MC.LCS.MIT.EDU 31 May 88 22:46:15 EDT
Date: 31 May 88 09:01:50 EDT
From: Cyril Alberga <ALBERGA@ibm.com>
To:   SCHEME@MC.LCS.MIT.EDU
Message-Id: <053188.090151.alberga@ibm.com>
Subject: Macros in lexically scoped lisps

No, that is not the only way macros work in lexically scoped lisps.  In LISP/VM
they work pretty much as you would expect, execpt sometimes.
   Quick aside: LISP/VM uses a single value cell, a la SCHEME.  It support
   dynamic (FLUID) bindings, in the same binding contour as lexical bindings.
   It has an operator, STATE, which can be used to duplicate CALL/CC.  Macros
   are first-class objects, written as (MLAMBDA ...).  The scope rules for
   macros are identical to those of functions.
The trouble is, this makes compilation hard.  LISP/VM cheats.  The compiler
is presented with two environments.  One is used to resolve operators, the
other to apply macros.  The first allows the compiler to receive macro
definitions which differ from the run-time definitions.  For example, compiled
calls to functions with fixed numbers of arguments is faster than calls with
indefinite trailing arguments.  On the other hand, macros may not be applied
(unlike FRANZ-LISP).  Thus the run-time environment has a function, PLUS, which
takes indefinite numbers of arguments, while the compiler has a macro, PLUS,
which expands to nested calls to internal-PLUS, a two argument function.

The conceit is that compiler/interpreter equivalence only holds AFTER the
macro expansion phase of the compilation process.  It turns out that in
most cases this causes not trouble.  Since there are both EVAL and APPLY
operators, and since they accept environments, all lexical variables are
accessible to mixed compiled and interpreted code.  (I know this is a
violation of lexicality, but it seemed like the lesser of many evils.)

I should comment that in LISP/VM thinks are a bit more complex.  This is
because no operator is examined before evaluation.  Thus a function is
not a list with first element LAMBDA, but a list whose first element
evaluates to LAMBDA.  The problems arise when an operator evaluates
to (FOO ...), and then FOO evaluates to MLAMBDA.  The currently defined
semantics in LISP/VM seem to cause minimal astonishment, but they are
still a bit too baroque for my taste.  Trouble is, no-one has suggested better.

Yours,
     Cyril N. Alberga


Received: from MITVMA.MIT.EDU (TCP 2227000003) by MC.LCS.MIT.EDU 31 May 88 12:51:57 EDT
Received: from MITVMA.MIT.EDU by MITVMA.MIT.EDU (IBM VM SMTP R1.1) with BSMTP id 0796; Tue, 31 May 88 09:25:45 EDT
Received: from WUVMD.BITNET by MITVMA.MIT.EDU (Mailer X1.25) with BSMTP id
 0795; Tue, 31 May 88 08:13:06 EDT
Received: by WUVMD (Mailer X1.25) id 4630; Mon, 30 May 88 14:44:34 CST
Date:         Mon, 30 May 88 14:40:51 CST
From:         Ronald Lovett <C24880RL%WUVMD.BITNET@MITVMA.MIT.EDU>
Subject:      Request for information
To:           SCHEME@MC.LCS.MIT.EDU


Do you have a list of available SCHEME software?

I am interested in installing SCHEME on local lab computers.  The two
  closest to me are based on Motorola 6809 and Motorola 68020 processors
  and we have C language software on these machines.

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 31 May 88 11:27:30 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA02567@BLOOM-BEACON.MIT.EDU>; Tue, 31 May 88 11:14:49 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 31 May 88 04:07:26 GMT
From: gt-eedsp!schw@gatech.edu  (Dave Schwartz)
Organization: School of Electrical Engineering, Ga. Tech, Atlanta, GA  30332
Subject: collect special form for streams
Message-Id: <294@gt-eedsp.UUCP>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


Any help you can provide would be appreciated ...

How can the "collect" special form for streams (from Chap. 3 of
Structure and Interpretation of Computer Programs) be implemented for
TI PC-Scheme? I have Kent Dybvig's "extend-syntax," but this does not
appear to be powerful enough for this special form.

   __                     ()
  /  )              /     /\       /                 _/_
 /  / __. , __o  __/     /  )  _. /_  , , , __.  __  /  __.
/__/_(_/|_\/ <__(_/_    /__/__(__/ /_(_(_/_(_/|_/ (_<__/  |_
                                                         (|
-------------------------------------------------------------
uucp:                         schw@gt-eedsp.uucp
domainizing internet mailers: schw@gteedsp.gatech.edu
dumb internet mailers:        schw%gteedsp@gatech.gatech.edu

Received: from CHARON.MIT.EDU (TCP 2224000015) by MC.LCS.MIT.EDU 29 May 88 23:28:11 EDT
Received: by CHARON.MIT.EDU (5.45/4.7)
	id AA07377; Sun, 29 May 88 23:25:06 EDT
Date: Sun, 29 May 88 23:25:06 EDT
From: <amgreene@athena.MIT.EDU>
Message-Id: <8805300325.AA07377@CHARON.MIT.EDU>
To: scheme@mc.lcs.mit.edu
Subject: PLEASE remove me from this list

I'm sorry to send this to the whole list, but I sent to scheme-request
and I'm still on.  I won't be here this summer and *really* can't afford
to have lots of mail pile up.  Thanks again.

- Andrew Greene

Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 27 May 88 19:12:39 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA05440@BLOOM-BEACON.MIT.EDU>; Fri, 27 May 88 18:58:49 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 26 May 88 18:05:45 GMT
From: eagle!dat@bloom-beacon.mit.edu  (D.A.Turner)
Organization: Computing Lab, University of Kent at Canterbury, UK.
Subject: Miranda (functional programming system)
Message-Id: <5107@eagle.ukc.ac.uk>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


		Miranda - release one
		---------------------

Miranda is a very pure functional language designed by  Professor  David
Turner  of the University of Kent.  It has polymorphic strong typing and
a simple but powerful module system.  This is to inform anyone  who  may
be  interested  that  the  first  full release of the Miranda functional
programming system is now available  for  a  number  of  UNIX  machines,
including  VAX's  and  SUN's.   If you wish to receive a longer piece of
electronic mail telling you more about the Miranda  system  and  how  to
obtain it, this can be requested from

		USENET:   ...!mcvax!ukc!mira-request
		ARPANET:  mira-request@ukc%nss.cs.ucl.ac.uk
		JANET:    mira-request@ukc.ac.uk

Received: from a.cs.uiuc.edu (TCP 1200600045) by MC.LCS.MIT.EDU 27 May 88 17:17:57 EDT
Received: from reddy.cs.uiuc.edu by a.cs.uiuc.edu with SMTP (UIUC-5.52/9.7)
	id AA16183; Fri, 27 May 88 12:01:22 CDT
Received: by reddy.cs.uiuc.edu (3.2/9.7)
	id AA05772; Fri, 27 May 88 12:01:36 CDT
Date: Fri, 27 May 88 12:01:36 CDT
From: reddy%reddy.cs.uiuc.edu@a.cs.uiuc.edu (Uday S. Reddy)
Message-Id: <8805271701.AA05772@reddy.cs.uiuc.edu>
To: hes@VALLECITO.SCRC.Symbolics.COM
Cc: wand%corwin.ccs.northeastern.edu@RELAY.CS.NET,
        hes@VALLECITO.SCRC.Symbolics.COM, scheme@mc.lcs.mit.edu
In-Reply-To: Howard Shrobe's message of Mon, 23 May 88 18:15 EDT <19880523221557.1.HES@MERLIN.SCRC.Symbolics.COM>
Subject: Floyd-Hoare Verification Harmful??
Reply-To: reddy@a.cs.uiuc.edu

   Howard Shrobe:

   Indeed the problem is that when allows arbitrary pointer and array
   manipulations one can get aliasing problems.  It is very hard to write
   an axiom set in the Floyd-Hoare tradition that does not screw up for
   such languages.  There are two responses, one is to weaken the language
   in such a way as to prevent aliasing.  The other is to create a
   different technique stating the language axioms and verifying programs.
   To date, I haven't seen a proposal in either direction that seems
   workable.  Attempts to constrain pointer manipulation seem to constrain
   more than you'd like.

Well, that depends on what you mean by "workable".  The standard
technique used for handling aliasing (for example, in denotational
semantics) is a two-level store.  The first level called "environment"
binds variables to objects, and the second level called "store" binds
objects to values.  We then have an accurate semantic formulation, but
reasoning is harder than in Floyd-Hoare tradition.  A two-level store
formulation in predicate logic style is the recent "situational
calculus" semantics of Manna and Waldinger.  It remains to be seen how
nice reasoning looks like in this framework.

Another technique, attributed to Landin, is to use an "equivalence
relation" on variables.  Modifying any variable in an equivalence
class has the effect of modifying all the variables in the class.
Reasoning seems to be nicer in this framework.  But, one has to be
careful about the order of evaluation.  A version of the Church-Rosser
property gets lost when aliasing is introduced.

Uday Reddy


Received: from BLOOM-BEACON.MIT.EDU (TCP 2224000021) by MC.LCS.MIT.EDU 27 May 88 08:27:22 EDT
Received: by BLOOM-BEACON.MIT.EDU with sendmail-5.59/4.7 
	id <AA15079@BLOOM-BEACON.MIT.EDU>; Fri, 27 May 88 08:16:14 EDT
Received: from USENET by bloom-beacon.mit.edu with netnews
	for scheme@mc.lcs.mit.edu (scheme@mc.lcs.mit.edu)
	(contact usenet@bloom-beacon.mit.edu if you have questions)
Date: 26 May 88 16:01:00 GMT
From: sanders@osiris.cso.uiuc.edu
Subject: Re: HELP ME!!!
Message-Id: <39400001@osiris.cso.uiuc.edu>
References: <5813@cup.portal.com>
Sender: scheme-request@mc.lcs.mit.edu
To: scheme@mc.lcs.mit.edu


But he DID reply, in another notesfile (can't think of the name of it just now).
He said he was working 25 hours/week and going to school full time.