HDTenEightyP/NetNews huggingface dataset:
From: klausf@OSGO.KS.HE.Schule.DE (Klaus Fueller)
Newsgroups: comp.lang.scheme
Subject: Re: New York Times article
Date: 16 Apr 92 12:58:46 GMT
Organization: Oberstufengymnasium (College) Kassel, Germany

In <shestINNomr@agate.berkeley.edu> bh@anarres.CS.Berkeley.EDU (Brian Harvey) writes:

[... A very intersting discussion about Lisp and C ...]

>Is anyone besides me an Iain interested in this discussion?  Or should we
>move it over to comp.edu or something?

I'm teaching CS at a college/school in Kassel, Germany in a project that
combines general education and vocational training. I'M VERY INTERESTED
IN THAT KIND OF DISCUSSION.  We had the language-sequence
Pascal->Fortran->Cobol, now we have Pascal->Prolog->(C++,Cobol).  We
experiment with Pascal->Scheme->(C++,Cobol) now (since about 8 Weeks the
first group uses Scheme after 1 Jear of Pascal).

The first mentioned language (Pascal in any case) is for ALL students,
the rest is for students who take CS as efficiency course.

I ask myself wether or not we should start with Scheme->C++->Cobol.  So
any discussion I can listen to is of some value for me.
-- 
Mit freundlichen Gruessen		Klaus M. Fueller, Kassel
With kind regards			KlausF@OSGO.KS.HE.Schule.DE
Avec mes sentiments les meilleurs	KLAUSF%OSGO@URANUS.ZER (from Z-Netz)
From: thinman@netcom.com (Lance Norskog)
Newsgroups: comp.lang.scheme
Subject: On the shelves at Computer Literacy
Date: 16 Apr 92 03:41:49 GMT
Distribution: ba
Organization: Netcom - Online Communication Services  (408 241-9760 guest)

1: MacScheme from LightShip Software. $40. Trade Edition.  Book+disk.

2: IEEE Scheme standard. $40, or, ~$1/page.

Lance Norskog
-- 
----------------Lance Norskog---------------
  ((lambda (lambda) `(,lambda ',lambda)) 
   '(lambda (lambda) `(,lambda ',lambda)))
Ah don't know, Jim, Ah thank it's some kahnd of vahrus.
Newsgroups: comp.lang.scheme
From: Pete Harlan <harlan@copper.ucs.indiana.edu>
Subject: Re: Neato Scheme programming problem
Organization: Indiana University
Date: Thu, 16 Apr 1992 17:35:51 -0500

bh@anarres.CS.Berkeley.EDU (Brian Harvey) writes:

|Write a function CXR-NAME that takes as its argument a function FN.
|This function FN must be some composition of CARs and CDRs.  The value
|returned by CXR-NAME should be the appropriate name for FN:

Here's a solution.  It works by creating a cons cell, the car of which
is a cell that leads only to itself and the cdr of which is a cell
that leads only to *it*self.  Running the function on this cell will
tell you whether it begins with a car or cdr.

Once you know whether it begins with a car (or cdr), you extend the
car (or cdr) of the cell so it points to a cell that is the cons of
the two circular cells.  This way you can know whether the second
operation is car or cdr, and so on.

My solution uses side-effects, but only to avoid doing a lot more
consing.  Since the input function is only allowed to do cars and
cdrs, that's safe.

(define cxr-name
  ;; Given a function f that does only car's and cdr's, return a string
  ;; that 'names' the function.
  (let ([*car* (cons '* '*)]
	[*cdr* (cons '* '*)])
    (set-car! *car* *car*)    ; Create the two self-referetial objects
    (set-cdr! *car* *car*)
    (set-car! *cdr* *cdr*)
    (set-cdr! *cdr* *cdr*)
    (lambda (f)
      (let ([obj (cons *car* *cdr*)])
	(letrec ([loop (lambda (tail as&ds)
			 (let ([result (f obj)])
			   
			   ;; If result is the final cell, we're done
			   (cond [(eq? result tail)
				  (apply string-append (cons "c" as&ds))]

				 ;; If result is in the car, extend the
				 ;; car of the tail and continue.
				 [(eq? result *car*)
				  (let ([new-tail (cons *car* *cdr*)])
				    (set-car! tail new-tail)
				    (loop new-tail (cons "a" as&ds)))]

				 ;; If result is in the cdr, extend the
				 ;; cdr of the tail and continue.
				 [(eq? result *cdr*)
				  (let ([new-tail (cons *car* *cdr*)])
				    (set-cdr! tail new-tail)
				    (loop new-tail (cons "d" as&ds)))])))])
	  (loop obj (list "r")))))))

Chez Scheme Version 4.0a
Copyright (c) 1991 Cadence Research Systems

> (cxr-name (lambda (x) x))
"cr"
> (cxr-name (lambda (x) (cddr (cadr (caaaar (cdaadr x))))))
"cddadaaaadaadr"
> 


Neat problem!

--Pete Harlan
  harlan@copper.ucs.indiana.edu
From: secrist@kxovax.enet.dec.com (Strong datatypes for weak minds.)
Newsgroups: comp.lang.scheme
Subject: SCM version 3c13 MS-DOS EXEs ?
Date: 7 Apr 92 21:04:59 GMT
Organization: Digital Equipment Corporation


Has anyone put MS-DOS executables for SCM version 3c13 on the net ?
altdorf.ai.mit.edu carries a couple of v2 binaries.  

Regards,
rcs
From: pk@cs.tut.fi (Kellom{ki Pertti)
Newsgroups: comp.lang.scheme
Subject: Re: Yet news about PC-Scheme
Date: 13 Apr 92 08:09:24 GMT
	<PK.92Apr9183206@talitiainen.cs.tut.fi> <1054@mitech.com>
Organization: Tampere Univ. of Technology, Finland.

In article <1054@mitech.com> gjc@mitech.com (George J. Carrette) writes:
   Do you like MicroEmacs as an editor? I found that it took only about
   an hour of hacking to make the "main" subroutine of MicroEmacs into
   a scheme callable subr (in SIOD, so it would be just as easy in SCM),
   which can be entered and re-entered with all buffer state exactly as
   you left it. 

That would be ideal. I have incidentally thought about doing the same
thing, if I can find some spare time. I'm glad to hear it was easy. Do
you think it would be feasible to direct SCM's stdout into a MicroEmacs
buffer? That would give a very GNU Emacs + Scheme interpreter like
environment.

The debugging side would still be a problem, though.
--
Pertti Kellom\"aki (TeX format)  #       These opinions are mine, 
  Tampere Univ. of TeXnology     #              ALL MINE !
      Software Systems Lab       #  (but go ahead and use them, if you like)
Newsgroups: comp.lang.scheme
From: dorai@cs.rice.edu (Dorai Sitaram)
Subject: Re: Help with problem
Organization: Rice University, Houston
Date: Tue, 7 Apr 1992 18:26:53 GMT

In article <9209812.29806@mulga.cs.mu.OZ.AU> simong@mundil.cs.mu.OZ.AU (Simon Alexander GREGORY) writes:
>Can anybody write me a procedure to construct this?
>
>Given this list '( 1 0 0 1 0 0 0 1 0 0 0 0 1 1)
>
>Result wanted is: ( 1 ( 0 0 ) 1 ( 0 0 0 ) 1 ( 0 0 0 0 ) 1 1)
>
>Note: the 1's should be able to be any type that will mean create
>a sublist.
>
>ie. vowels lets say.
>
>given ( a n m n b e f j k l a e) 
>
>result
>
>( a (n m n b) e (f j k l) a e)

Here's a solution whose (only?) merit is that it doesn't perform any
extra cons'ing.  Creates a lot of temporary (cps continuation)
procedures though.

(define nonhomog-bunch
  (lambda (pred? l)
    (process-rejects pred? l identity)))

(define process-rejects
  (lambda (pred? l f)
    (let loop ((l l) (f f))
      (if (null? l) (f '())
	(let ((a (car l)))
	  (if (pred? a) 
	      (process-accepts pred? l f)
	      (loop (cdr l)
		    (lambda (x) (f (cons a x))))))))))

(define process-accepts
  (lambda (pred? l f)
    (let ((finish
	    (lambda (l g)
	      (let ((b (g '())))
		(process-rejects pred? l
		  (lambda (x) (f (cons b x))))))))
      (let loop ((l l) (g identity))
	(if (null? l) (finish l g)
	  (let ((a (car l)))
	    (if (pred? a)
		(loop (cdr l)
		      (lambda (y) (g (cons a y))))
		(finish l g))))))))
    
(define identity (lambda (x) x))

(define vowel-symbol?
  (lambda (s)
    (let ((c (string-ref (symbol->string s) 0)))
      (memv c '(#\a #\e #\i #\o #\u)))))

;tests

> (nonhomog-bunch zero? '(1 0 0 1 0 0 0 1 0 0 0 0 1 1))
(1 (0 0) 1 (0 0 0) 1 (0 0 0 0) 1 1)
> (nonhomog-bunch (lambda (x) (not (vowel-symbol? x)))
    '(a n m n b e f j k l a e))
(a (n m n b) e (f j k l) a e)

--d
-- 

dorai@titan.rice.edu   !    It may be that the gulfs will wash us down;
dorai@owlnet.rice.edu  !      it may be we shall touch the Happy Isles.
From: sab@reef.cis.ufl.edu (Shawn Berg)
Newsgroups: comp.lang.scheme
Subject: Permutations function need
Date: 15 Apr 92 03:13:51 GMT
Organization: Univ. of Florida CIS Dept.


Could someone explain to me how to output, to the screen, all the permutations
of a list.

For example if the function is called w/ (1 2 3) the output should be:
(1 2 3)
(1 3 2)
(2 1 3)
(2 3 1)
(3 1 2)
(3 2 1)

I don't need to deal with nested lists (ie, ((1 2) 3)).

E-mail please: sab@reef.cis.ufl.edu

Thanks,
Shawn Berg

PS. If there is interest I'll e-mail information I get to whomever wants it.
From: pk@cs.tut.fi (Kellom{ki Pertti)
Newsgroups: comp.lang.scheme
Subject: Re: Yet news about PC-Scheme
Date: 9 Apr 92 16:32:06 GMT
Organization: Tampere Univ. of Technology, Finland.

In article <JAFFER.92Apr8133034@camelot.ai.mit.edu> jaffer@zurich.ai.mit.edu (Aubrey Jaffer) writes:
   In article <1992Apr7.203854.1347@uni2a.unige.ch> vuilleum@uni2a.unige.ch writes:
	 Anyway, there are still quite a lot of people who are interested in
      developping under a small yet powerfull Scheme interpreter, running on PC
      computers. Some users recently wanted Mouse support, other R^4, and so on.

   Those people have to wait no longer!  scm3c13 is R^4 and IEEE
   compliant an compiles under Microsoft C, Turbo C, Borland C, and Gnu C
   under MSDOS.

There is one point, however, that can not be ignored. I have used scm
a while now, and I generally like it. At home on a PC, I still use
PC-Scheme, mainly because

	1) It has an integrated editor. It is not great (no
	   replace-string, for example), but still nicer than having
	   to switch between the editor and Scheme interpreter all the
	   time

	2) It has a superior debugger compared to any other Scheme I
	   have seen on PC.

For educational use, the second point is crucial. A lot of our
students have PC's at home, and they use them for doing home
assignments etc. I can live with a poor debugger on a workstation
environment, where I can use mouse to pick modified versions of
procedures to the interpreter, use the undo capabilities of Emacs to
comment out code etc., but on a PC this is just not available.
Conclusion: there is still a need for a nice Scheme development
environment with a good editor, debugger etc. for the PC.
--
Pertti Kellom\"aki (TeX format)  #       These opinions are mine, 
  Tampere Univ. of TeXnology     #              ALL MINE !
      Software Systems Lab       #  (but go ahead and use them, if you like)
From: ark@alice.att.com (Andrew Koenig)
Newsgroups: comp.lang.scheme
Subject: Re: Scheme release scm4a1 (alpha) available.
Date: 16 Apr 92 03:35:46 GMT
Reply-To: ark@alice.UUCP ()
Organization: AT&T Bell Laboratories, Liberty Corner NJ

In article <JAFFER.92Apr15133006@camelot.ai.mit.edu> jaffer@zurich.ai.mit.edu (Aubrey Jaffer) writes:

> scm4a0 had some missing declarations.  scm4a1 should be better
> behaved.  There is a patch file scm4a1.pat.  The regular announcement
> follows:

Any chance of incorporating Guy Steele's accurate floating-point
input/output stuff?
-- 
				--Andrew Koenig
				  ark@europa.att.com
Newsgroups: comp.lang.scheme
From: "Shinnder Lee" <sdlee@iuvax.cs.indiana.edu>
Subject: Re: Neato Scheme programming problem
Organization: Computer Science, Indiana University
Date: Thu, 16 Apr 92 00:30:26 -0500

bh@anarres.CS.Berkeley.EDU (Brian Harvey) writes:

>I thought up this great problem to put on a quiz for my SICP class but
>the TAs convinced me it was too hard, so I'm sharing it with you instead...

>Write a function CXR-NAME that takes as its argument a function FN.
>This function FN must be some composition of CARs and CDRs.  The value
>returned by CXR-NAME should be the appropriate name for FN:

>> (cxr-name (lambda (x) (caddr (cddaar (cadadr (cddr (car (caaddr x))))))))
>CADDDDAAADADDDAAADDR

(define cxr-name
  (lambda (f)
    (fluid-let
      ((car (lambda (x) (cons "A" x)))
       (cdr (lambda (x) (cons "D" x)))
       (caar (lambda (x) (cons "AA" x)))
       (cadr (lambda (x) (cons "AD" x)))
       (cdar (lambda (x) (cons "DA" x)))
       (cddr (lambda (x) (cons "DD" x)))
       (caaar (lambda (x) (cons "AAA" x)))
       (caadr (lambda (x) (cons "AAD" x)))
       (cadar (lambda (x) (cons "ADA" x)))
       (caddr (lambda (x) (cons "ADD" x)))
       (cdaar (lambda (x) (cons "DAA" x)))
       (cdadr (lambda (x) (cons "DAD" x)))
       (cddar (lambda (x) (cons "DDA" x)))
       (cdddr (lambda (x) (cons "DDD" x)))
       (caaaar (lambda (x) (cons "AAAA" x)))
       (caaadr (lambda (x) (cons "AAAD" x)))
       (caadar (lambda (x) (cons "AADA" x)))
       (caaddr (lambda (x) (cons "AADD" x)))
       (cadaar (lambda (x) (cons "ADAA" x)))
       (cadadr (lambda (x) (cons "ADAD" x)))
       (caddar (lambda (x) (cons "ADDA" x)))
       (cadddr (lambda (x) (cons "ADDD" x)))
       (cdaaar (lambda (x) (cons "DAAA" x)))
       (cdaadr (lambda (x) (cons "DAAD" x)))
       (cdadar (lambda (x) (cons "DADA" x)))
       (cdaddr (lambda (x) (cons "DADD" x)))
       (cddaar (lambda (x) (cons "DDAA" x)))
       (cddadr (lambda (x) (cons "DDAD" x)))
       (cdddar (lambda (x) (cons "DDDA" x)))
       (cddddr (lambda (x) (cons "DDDD" x))))
      (display (apply string-append (cons "C" (f (list "R"))))))))

-shinnder
From: 70262.630@compuserve.COM (Iain Ferguson)
Newsgroups: comp.lang.scheme
Subject: New York Times article
Date: 15 Apr 92 01:31:16 GMT
Organization: The Internet

Subject: New York Times article

Owen L. Astrachan writes:

> Quotes like Natasha Chen's "After my sixth grade BASIC experience, I
> never wanted to take another computer course again" do a disservice in
> that they lump experiences with language rather than what the language
> was used for...

For three years I taught BASIC and Pascal at the high school level in the UK. 
Now, I may not have been the best teacher around, but I was motivated and 
worked hard.  

The problem was, the kids would be interested for several weeks, and then as a
rule they would turn off.  I tried changing the textbook.  I tried projects 
and group work.  Wrote my own stuff.  Even CAI.  You name it, I tried it.  But
the result was always bored kids and a frustrated teacher.  It must be me, I 
thought.

Later I was involved with computer science teaching at a regional level, and 
began to suspect that it wasn't my fault at all.  Nobody else was doing any 
better, it seemed.  

Currently, I'm involved with teaching Scheme to a high school class in 
Florida, and I'm only now beginning to understand what the problem was. In the
Scheme class it took us about six weeks to learn about lists, define, cond, 
lambda and recursion.  I won't pretend it was easy, but in my experience it 
was certainly no more difficult than teaching BASIC or Pascal syntax.  And 
then the kids started to write programs, and they've been writing them ever 
since.  

The most surprising thing for me has been the variety of the algorithms that 
the kids manage to dream up.  I thought I knew everything there was to know 
about counting the nodes in a binary tree...number in the left subtree plus 
the number in the right, plus one.  Simple.  Noooooooo.  Traverse the tree, 
putting the roots into a list, then find the length of the resulting list.  Or
traverse the tree building a list of 1's, one for each node, then sum the 
list.  

Today, the students were writing a Scheme program for estimating the expected 
number of tosses of a coin to obtain two consecutive heads, or THT, or...  My 
impression was that there were quite a few devious algorithms being 
spawned...more grading headaches when the work is turned in, I suppose.  They 
may not write the most efficient algorithms, but the point is that they're 
being creative and individual.  And that's why they're still motivated after 
27 weeks.  When teaching BASIC or Pascal at the high school level there's no 
time to encourage exploration of this type.   

Are we teaching computer science?  Some may argue not.  Are we creating future
computer scientists and programmers?  You had better believe it.

Iain Ferguson,
Nova High School.
From: jaffer@zurich.ai.mit.edu (Aubrey Jaffer)
Newsgroups: comp.lang.scheme
Subject: Re: SCM version 3c13 MS-DOS EXEs ?
Date: 8 Apr 92 18:39:06 GMT
Article-I.D.: camelot.JAFFER.92Apr8133906
Organization: M.I.T. Artificial Intelligence Lab.

In article <339@sousa.ltn.dec.com> secrist@kxovax.enet.dec.com (Strong datatypes for weak minds.) writes:

   Has anyone put MS-DOS executables for SCM version 3c13 on the net ?
   altdorf.ai.mit.edu carries a couple of v2 binaries.  

I do not put recent MSDOS executables out for FTP in the hope of
getting some token financial support for the large number of hours I
devote to developing SCM, SLIB, and JACAL.  I am not employed by MIT
and do this on my own time.  You can buy an MSDOS diskette with source
and executables from me.  It comes with a $10 update policy.  See
recent postings for details.
From: thant@horus.esd.sgi.com (Thant Tessman)
Newsgroups: comp.lang.scheme
Subject: MacScheme (Was: Scheme as a high school instructional language)
Date: 7 Apr 92 21:04:32 GMT
Organization: sgi


>In article <michaelg.702318106@Xenon.Stanford.EDU>,
>michaelg@Xenon.Stanford.EDU
>(Michael Greenwald) says:
>
>I believe there is already a version of scheme available for the Mac.
>I also believe that there is a very cheap (free?) educational
>discount.  I think it is a Real(tm) Programming Language/Environment.

[...]

It's called MacScheme, and I really like it.  (But I'm new to both
scheme and the Mac so I'm not a good judge.)  I actually only
intended to buy a book on scheme.  To my surprise the first book I 
picked up had this disk in the back.  Can you beat forty bucks for 
a real scheme interpreter?  (I bought it at Computer Literacy in 
Sunnyvale.)

On the cover of the book in small print is "trade edition".  Inside 
it talks about the "student edition".  As far as I can tell they
mean the same thing.  The student edition includes an interpreter,
(which they say 'compiles' it into 'byte' code for subsequent 
interpretation by a simulated lisp machine), an editor that keeps
track of all of the indenting and parentheses for you (there's one
interpreter/dialog (?) window and you can open up multiple text 
windows), a debugger, and a limited functionality graphics window 
that you can do stuff in (like points, lines and circles).

In the book there is talk of the "professional edition" of MacScheme
which has a native-code compiler and access to the Mac toolbox stuff.
I'm guessing this is a lot more expensive, but its nice to know that
it exists if I ever decide to do anything serious.

thant
From: 71020.1774@compuserve.COM (Terry Kaufman)
Newsgroups: comp.lang.scheme
Subject: New York Times article
Date: 8 Apr 92 01:17:11 GMT
Organization: The Internet

The Education Life supplement of last Sunday's New York Times had an
article, "Computer Science Is Going Down", by Peter Lewis on the
current state of computer science education in the USA at the high
school and undergraduate levels.   Much of the article is devoted to
Scheme and the current thinking at our leading universities.

I think the article should help spread the word about the advantages of Scheme
in introductory classes.  (However, the article ends on a weak note with 
unchallenged quotes from Nell Dale, computer science lecturer at the 
University of Texas, including "it would be a mistake to think of
Scheme as a replacement language for BASIC or Pascal.  Scheme is a
different kind of language than the students will use when they get
out in industry, a different way of looking at the world".  Also, 
there's a reference to the ACM High School Committee, which is
recommending a breadth-only computer science course---a real quick way
to turn high school students off to computer science---similar to High
School General Biology and Chemistry, for all college-bound
students.)  If you haven't seen the article, I'd recommend taking the
time to get a copy.  

... Terry
From: sdoran@matt.ksu.ksu.edu (Steven Marcotte)
Newsgroups: comp.lang.scheme
Subject: scm3c13 help
Date: 6 Apr 1992 14:47:31 -0500
Organization: Kansas State University
Distribution: world
NNTP-Posting-Host: matt.ksu.ksu.edu


First I'd like to thank all the people who replied to my post about
learning scheme and lambda calculus.  Second, the class I am taking
is using the book "Essentials of Programming Languages" by Freidman.
In the class we are using the record facilities that are defined in 
the book.  These make use of extend-syntax.  Is there a libraray
for scm3c13 that gives support for extend-syntax.  If so, it would
make my life alot easier.  Thanks, 
 
Steven Marcotte
sdoran@matt.ksu.ksu.edu
From: bh@anarres.CS.Berkeley.EDU (Brian Harvey)
Newsgroups: comp.lang.scheme
Subject: Re: Neato Scheme programming problem
Date: 16 Apr 92 14:35:17 GMT
Article-I.D.: agate.sk3b5INN4s1
Organization: University of California at Berkeley
NNTP-Posting-Host: anarres.cs.berkeley.edu

sdlee@iuvax.cs.indiana.edu (Shinnder Lee) writes:
>(define cxr-name
>  (lambda (f)
>    (fluid-let
>      ((car (lambda (x) (cons "A" x)))
>       (cdr (lambda (x) (cons "D" x)))
>       (caar (lambda (x) (cons "AA" x)))
>       [...]
>       (cddddr (lambda (x) (cons "DDDD" x))))
>      (display (apply string-append (cons "C" (f (list "R"))))))))

I admit, I hadn't thought of using fluid-let.  But it seems a little
risky to me; what if APPLY uses CAR?  I suppose you could say

(apply string-append
       (cons "C"
             (let ((base (list "R")))
               (fluid-let ... (f base)) )))


This is fun -- everyone's coming up with solutions different from mine.
Do we have an archive of neat programming problems online somewhere?
From: krishna@csgrad.cs.vt.edu (Krishna Ganugapati)
Newsgroups: comp.lang.scheme
Subject: Looking for SIOD (Scheme in One Defun)
Date: 12 Apr 92 18:34:40 GMT
Organization: VPI&SU Computer Science Department, Blacksburg, VA

Hi,

I'm working on a windowing interface for the display and analysis
of parallel program traces. Part of my work involves the 
transformation of the traces. Needless to say the transformed
traces have to visualized too. 

For the transformations, I need a small yet powerful interpreter
that could be embedded into my graphics system (which incidentally
has been implemented using OSF/Motif). I was thinking of using
a version of an easy to embed Scheme.

A colleague out here suggested that I use SIOD (Scheme in One Defun)
and the description he gave me looks ideal. Problem is that that the 
site specified - doesn't have the sources - bu-it.bu.edu  
(I've looked all over)


I'd appreciate any pointers/help on locating SIOD,  suggestions
on embedded Scheme interpreters.


Thanks very much


Krishna Ganugapati
(krishna@csgrad.cs.vt.edu)
From: gjc@mitech.com (George J. Carrette)
Newsgroups: comp.lang.scheme
Subject: Re: Yet news about PC-Scheme
Date: 10 Apr 92 10:15:55 GMT
Organization: Mitech Corporation, Concord MA

In article <PK.92Apr9183206@talitiainen.cs.tut.fi>, pk@cs.tut.fi (Kellom{ki Pertti) writes:
> 	1) It has an integrated editor. It is not great (no
> 	   replace-string, for example), but still nicer than having
> 	   to switch between the editor and Scheme interpreter all the
> 	   time

Do you like MicroEmacs as an editor? I found that it took only about
an hour of hacking to make the "main" subroutine of MicroEmacs into
a scheme callable subr (in SIOD, so it would be just as easy in SCM),
which can be entered and re-entered with all buffer state exactly as
you left it. 

Newsgroups: comp.lang.scheme.c