Here are brief instructions for the various demos.

* THE GRAPH EDITOR

  Type:
  % guile graph

  This is a knock-off of the graph-editor in "Tcl and the Tk Toolkit".
  This version is written in Scheme using the "Gwish library" (described
  further below).

  Mouse-button 1 drops dots.  Typing 1 or 2 while a dot is highlighted
  draws connections.  Mouse-button 2 can be used to drag a dot and
  its connections around.  Type "q" to end the demo.





* AN AUTOKAD SYSTEM

  Type: 
  % guile kad

  Groovy.

  Type 'q' to quit.  Mouse-button 3 toggles participation mode.
  I hope your machine draws circles well.





* GWISH

  Type: 
  % guile Gwish

  This is a wish-like program for Guile.  It allows you to interactively
  manipulate Tk widgets.  For example, stealing the first few commands
  from graph.scm:

	tk-guile> (canvas '.c) 
	;Evaluation took 0 mSec (0 in scm_gc) 557 cells work, 1271 bytes other 
	".c"
	tk-guile> (pack '.c :fill "both" :expand #t)
	;Evaluation took 0 mSec (0 in scm_gc) 215 cells work, 151 bytes other
	#f

  Then you can draw whatever you like.  Have a nice day!

	(.c 'create 'oval  50 5 250 205 :fill 'yellow)
	(.c 'create 'oval  110 60 130 110 :fill 'black)
	(.c 'create 'oval  170 60 190 110 :fill 'black)
	(.c 'create 'polygon
	     100 125 125 170 150 180 175 170 200 125
	     200 120 175 165 150 175 125 165 100 120
	     :fill 'black :smooth 1)


  You can learn more about Gwish in the texinfo manual "scm.info"
  that can be found in the snapshot directory "guile".

  To escape from Gwish, type "(quit)".



* THE CTAX DEMO

  The Ctax is a c-like syntax for Scheme.  It is not done yet, but it
  is usable for small programs.  I made a demo as a way to attract
  volunteers to work on various aspects of the Ctax, so if you are
  interested, please write to lord@gnu.ai.mit.edu.

  To run the ctax interpreter, you can use:

	% guile crepl

  If everything is functioning correctly, you'll see this prompt:

	ctax> 

  Now you can start entering statements and definitions in ctax.
  You may find this tricky, since ctax isn't yet documented.
  On the other hand, you may find it simple, because ctax looks
  so much like C.  Below are some examples.

  You should understand that, like the Scheme interpreter,
  Ctax reads expressions, evaluates them, and then prints
  the result.  For example:

	ctax> 5 + 7;
	12

  Sorry about the trailing semi-colon.  Its there because you
  are allowed to spread expressions over multiple lines.  For 
  example:

	ctax> 5 
	      + 
	      7;
	12

  In a future release, ctax will, when used interactively,
  treat two successive returns as if they were a semi-colon
  followed by a return.

  You can call familiar lisp functions from Ctax:

	ctax> list (1, 2, 3);
	(1 2 3)

  If a Scheme function has a "-" in its name, the 
  corresponding ctax function has an "_".  For
  example, Scheme has a function "string-append":

	ctax> string_append ("abc", "def");
	"abcdef"


  There is not yet any ctax syntax implemented for writing quoted
  constants or anonymous functions.

  One important Scheme function that doesn't require name mangling is
  the one you need to exit the demo.  It is "quit".  To get out of the
  demo, use:

	ctax> quit();
	
  So far, ctax implements most of the C expression syntax (assignment
  operators like += aren't there yet).  For flow of control, it
  implements:

	for (<init>; <test>; <inc>)
	  <body>

	while (<test>)
	  <body>

  	break; /* within "for" and "while" */

	if (<test>)
	  <body>
	else /* optional, of course */
	  <body>

	return <exp>;


  To declare a variable, either globally or locally, follow
  the example of:

	scm x;

   or

	scm x = 34;

  To define a new function, use syntax like:

  	ctax> 
	scm cross (a, b) 
	{ 
	   return car(a) * cdr(b) + cdr(a) * car(b); 
	}

	ctax> cross (cons (2, 3), cons (100, 1000));
	2300


  You may notice that that example uses lisp pairs.
  In the future, ctax wil have an object sytem
  so that you can use structures instead.

  Here is a slightly more involved example:

  	ctax> 
	scm fact(x)
	{
	  scm total;
	  for (total = 1; x; x = x - 1)
	    total = total * x;
          return total;
        }

  And, of course, you call functions s defined in the usual way:

	ctax> fact(500);
	1220136825991110068701238785423046926253574342803192842192413588385845373153881997605496447502203281863013616477148203584163378722078177200480785205159329285477907571939330603772960859086270429174547882424912726344305670173270769461062802310452644218878789465754777149863494367781037644274033827365397471386477878495438489595537537990423241061271326984327745715546309977202781014561081188373709531016356324432987029563896628911658974769572087926928871281780070265174507768410719624390394322536422605234945850129918571501248706961568141625359056693423813008856249246891564126775654481886506593847951775360894005745238940335798476363944905313062323749066445048824665075946735862074637925184200459369692981022263971952597190945217823331756934581508552332820762820023402626907898342451712006207714640979456116127629145951237229913340169552363850942885592018727433795173014586357570828355780158735432768888680120399882384702151467605445407663535984174430480128938313896881639487469658817504506926365338175055478128640000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

  The ctax syntax is neither finished nor unchanging.  In addition to
  fixing the shortcomings mentioned above, we'll almost certainly add
  an object system and a way to write optional type declarations for
  variables.  One possibility is to make the ctax a superset
  of Java.  For more information about this idea, poke around in the
  subdirectory "latte".

