home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 2: PC / frozenfish_august_1995.bin / bbs / d07xx / d0764.lha / Gambit_Terp / QuickTour < prev    next >
Text File  |  1992-11-21  |  17KB  |  549 lines
  1. ;; FILE        "Gambit:docs/QuickTour"
  2. ;; IMPLEMENTS    An overview of the Gambit release 1.8 for AmigaDOS 1.3/2.0
  3. ;; AUTHOR    Kenneth A Dickey
  4. ;; DATE        1992 October 2
  5. ;; LAST UPDATED    1992 October 3
  6.  
  7.  
  8. SYNOPSIS:
  9.   INTRODUCTION
  10.   INVOCATION & OPTIONS
  11.   THE READ-EVAL-PRINT LOOP (Example)
  12.   FUNCTION SYNOPSIS
  13.   STANDARDS REFERENCES
  14.  
  15.  
  16.  
  17. === INTRODUCTION ===
  18.  
  19. This is Gambit release 1.8 for the Amiga with AmigaDOS 1.3 or 2.0.
  20. This is a full implementation of Scheme with some extensions.  It
  21. conforms to IEEE P1178 and the Revised^4 Report on the Programming
  22. Language Scheme (see REFERENCES, below).  The interpreter requires 1.5
  23. MB and the compiler requires 3 MB of RAM to run (see INVOCATION &
  24. OPTIONS, below).  This document is a quick overview/reference of the 
  25. Gambit Scheme system, not a Scheme tutorial.
  26.  
  27.  
  28.  
  29. === INVOCATION & OPTIONS ===
  30.  
  31.  
  32. INVOCATION
  33.  
  34. To invoke the interpreter, put it in your C: directory, "assign SCM:
  35. <your scheme source directory>" and type the interpreter's name from
  36. the CLI (see INVOCATION OPTIONS, below).  I usually name the
  37. interpreter "gsi".  You may want to name it "scheme".
  38.  
  39. There are several variants of the Gambit Scheme Interpreter to use:
  40.  
  41.   "gsi.68020+FPU" requires a 680[234]0 with floating point processing.
  42.  
  43.   "gsi.68k.emu" requires only a 68000 and does floating point (and 020)
  44.     emulation. 
  45.  
  46.   "gsi.68k.small.emu" is like gsi.68k.emu, but loads the runtime from
  47.     disk to save space.  It loads in 1.25 MB rather than in gsi.68k.emu's
  48.     1.52 MB.  This version expects to load the runtime files from a
  49.     directory "GAMBIT:runtime", so if you copy files to a hard disk, you
  50.     should do the proper ASSIGN statement ("assign GAMBIT: <whatever>").
  51.     The other versions have the runtime linked as part of the executable. 
  52.  
  53. Gsi looks for a file "init.scm" first in your S: directory, then in
  54. the current directory.  If it finds such a file, it loads it and then
  55. brings up the read-eval-print loop (REPL) prompt.
  56.  
  57.  
  58. OPTIONS
  59.  
  60. You can invoke gsi with a simple command string to get a result:
  61.  
  62. > gsi "(/ 610728 1024.)"
  63. 596.4140625
  64. >
  65.  
  66. All option flags are preceeded by "--".  The most important flags are
  67. those which control how much heap space to allocate.
  68.  
  69. There are 2 heaps: a static heap and a dynamic heap.  
  70.  
  71. The static heap is where all compiled code is loaded.  Compiled code
  72. module names by convention end in ".O", source code modules in ".scm",
  73. so "foo.scm" compiles into "foo.O".  The runtime system requires ~340
  74. KB.  The compiler requires an additional 600 KB.  To set the static
  75. heap use the "-c" flag followed by the number of KB you want.  The
  76. static heap is *not* garbage collected.
  77.  
  78. The dynamic heap holds all your dynamic data structures (interpreted
  79. code and your data).  Make it as big as you can afford.  To set the
  80. dynamic heap, use the "-h" flag followed by the number of KB you want.
  81. Note that the dynamic heap is garbage collected and is divided into 2
  82. subheaps or "semi-spaces" (A Stop-and-Copy collector is currently
  83. used).  This means that if you allocate 500 KB to your dynamic heap,
  84. your live data will be up to 250 KB.  Note that the interpreter also
  85. allocates (malloc's) space for its own internal data structures.
  86.  
  87. Example: 
  88. > gsi -- -h2000 -c1000
  89. allocates 2 one-megabyte semispaces for the dynamic heap and reserves
  90. one megabyte for loading compiled code (e.g. the compiler).
  91.  
  92. See file "docs/gsi.man" for further details and options.
  93.  
  94.  
  95.  
  96. === THE READ-EVAL-PRINT LOOP (Example) ===
  97.  
  98. >gsi
  99.  
  100. Gambit (v1.8)
  101.  
  102. : (define (fact x)
  103.     (cond ((= x 0) 1)
  104.           ((= x 1) 1)
  105.           ((> x 1) (* (fact (- x 1)) x))
  106.           (else    (error "argument must be positive"))))
  107. fact
  108.  
  109. : (trace fact)
  110. fact
  111.  
  112. : (fact 10)
  113. Entry (fact 10)
  114. |Entry (fact 9)
  115. | Entry (fact 8)
  116. |  Entry (fact 7)
  117. |  |Entry (fact 6)
  118. |  | Entry (fact 5)
  119. |  |  Entry (fact 4)
  120. |  |  |Entry (fact 3)
  121. |  |  | Entry (fact 2)
  122. |  |  |  Entry (fact 1)
  123. |  |  |  ==> 1
  124. |  |  | ==> 2
  125. |  |  |==> 6
  126. |  |  ==> 24
  127. |  | ==> 120
  128. |  |==> 720
  129. |  ==> 5040
  130. | ==> 40320
  131. |==> 362880
  132. ==> 3628800
  133. 3628800
  134.  
  135. : (untrace fact)
  136. fact
  137.  
  138. : (pp fact)    ;; NOTE: 'x is alpha-converted to 'x.1 by the macro-expander
  139. (lambda (x.1)
  140.   (cond ((= x.1 0) 1)
  141.         ((= x.1 1) 1)
  142.         ((> x.1 1) (* (fact (- x.1 1)) x.1))
  143.         (else (error "argument must be positive"))))
  144. #f
  145.  
  146. : (define f fact)
  147. f
  148.  
  149. : (define fact "not the factorial function")
  150. fact
  151.  
  152. : (f 5)
  153. *** ERROR IN f -- Operator is not a PROCEDURE
  154. (fact (- x 1))
  155.  
  156. 1: ,?
  157. ,?        : Summary of commands
  158. ,+ and ,- : Move to next or previous frame of continuation
  159. ,<n>      : Move to particular frame (<n> <= 0)
  160. ,b        : Display frames of continuation (i.e. backtrace)
  161. ,p        : Display procedure attached to current frame
  162. ,e        : Display subproblem of current frame
  163. ,l        : Display list of local variables accessible in current frame
  164. ,t        : Transfer to top-level REP loop
  165. ,d        : Transfer to previous REP loop
  166. ,r        : Return from REP loop
  167. ,q        : Quit
  168.  
  169. 1: ,b
  170. 0    f                         (fact (- x 1))
  171. -1   (top level)               (f 5)
  172. -2   ##read-eval-print
  173. -3   ##dynamic-env-bind
  174. -4   ###_kernel.startup
  175.  
  176. 1: ,p
  177. #[procedure f] =
  178. (lambda (x.1)
  179.   (cond ((= x.1 0) 1)
  180.         ((= x.1 1) 1)
  181.         ((> x.1 1) (* (fact (- x.1 1)) x.1))
  182.         (else (error "argument must be positive"))))
  183.  
  184. 1: ,l
  185. x.1 = 5
  186.  
  187. 1: (- x.1 1)
  188. 4
  189.  
  190. 1: fact
  191. "not the factorial function"
  192.  
  193. 1: (set! fact f)
  194. #[undefined]
  195.  
  196. 1: ,r (fact (- x.1 1))
  197. 120
  198.  
  199. : (list (gensym) (gensym) (gensym))
  200. (g1 g2 g3)
  201.  
  202. : (put 'bob 'eyes 'blue)
  203. #f
  204.  
  205. : (put 'mary 'hair 'blond)
  206. #f
  207.  
  208. : (get 'bob 'eyes)
  209. blue
  210.  
  211. : (get 'mary 'eyes)
  212. #f
  213.  
  214. : (define (series term)
  215.     (let ((sum 0) (stop #f))
  216.       (FUTURE (let loop ((i 0))
  217.                 (if (not stop)
  218.                   (begin (set! sum (+ sum (term i))) (loop (+ i 1))))))
  219.       (lambda (msg)
  220.         (cond ((eq? msg 'value) sum)
  221.               ((eq? msg 'stop)  (set! stop #t))
  222.               (else             (error "unknown message" msg))))))
  223. series
  224.  
  225. : (define pi (series (lambda (i) (/ 4. ((if (odd? i) - +) (+ (* i 2) 1))))))
  226. pi
  227.  
  228. : (pi 'value)
  229. 3.141419882340216
  230.  
  231. : (pi 'value)
  232. 3.1415194471477133
  233.  
  234. : (pi 'value)
  235. 3.1416300745380195
  236.  
  237. : (pi 'value)
  238. 3.1415798589941843
  239.  
  240. : (pi 'stop)
  241. #[undefined]
  242.  
  243. : (pi 'value)
  244. 3.1415815090449892
  245.  
  246. : (pi 'value)
  247. 3.1415815090449892
  248.  
  249. : ,q
  250.  
  251.  
  252.  
  253.  
  254.  
  255. === FUNCTION SYNOPSIS ===
  256.  
  257.  
  258. Here is a quick reference of the signatures of provided functions.
  259. Aside from Extensions, there is no attempt at completeness.  It is
  260. assumed that the user has a copy of R^4RS or the IEEE/ANSI standard.
  261.  
  262. Notation:
  263.   <object>    any Scheme data object.
  264.   <object>*    zero or more objects
  265.   <object>+    one or more objects
  266.   [<object>]    optional object
  267.  
  268.  
  269. ; EXTENSIONS
  270.  
  271.   (EXIT) -- exit the interpreter.
  272.  
  273.   (##SYSTEM <string>) -- Executes CLI command string
  274.     e.g. (##system "dir #?.scm")
  275.  
  276.   (TRACE <proc>+ )   -- turns trace on  for <proc>(s) {SYNTAX}.
  277.   (UNTRACE <proc>* ) -- turns trace off for <proc>(s) {SYNTAX}.  With
  278.     no <proc> specified, turns off tracing for all trace'd procedures.
  279.  
  280.   (ERROR <message> <object>* ) -- invokes the debugger.  ",?" for help.
  281.  
  282.   (PP <object> [<output-port> [<width>]]) -- Pretty print object.  
  283.     Prints source for interpreted code.
  284.  
  285.   (PRETTY-PRINT <object> [<output-port> [<width>]] ) -- like PP, but does
  286.     *not* print source for code.
  287.  
  288.   (GENSYM [<symbol-or-string>] ) -- generates a symbol.
  289.     Examples:
  290.       (gensym)        -> g1
  291.       (gensym 'foo) -> foo2
  292.       (gensym)        -> g3
  293.  
  294.   (PUT <symbol> <key> <value>)     -- Known generally as "putprop"
  295.   (GET <symbol> <key>)    -> <value> -- Known generally as "getprop"
  296.     Examples:
  297.       (put 'groceries 'beans 37)
  298.       (put 'groceries 'milk 2)
  299.       (get 'groceries 'beans)     -> 37
  300.  
  301.   (LOAD <string>) -- rather than "foo.scm" <string> may be "foo",
  302.    which looks first for "foo.O", then "foo.scm"
  303.  
  304.   (EVAL <expression>) -- If you don't know what this does, you should
  305.     probably not use it.  You probably don't need to use it anyway...
  306.  
  307.   (SET-GC-REPORT <boolean>) -- If set to #t, reports when a storage
  308.     reclamation occurs.  If set to #f (the default), gc is not reported.
  309.  
  310.   (OPEN-INPUT-STRING <string>)  -> <output-string-port>
  311.   (OPEN-OUTPUT-STRING)        -> <input-string-port>
  312.   (GET-OUTPUT-STRING <input-string-port>) -> <string>
  313.  
  314.   (##WEAK-CONS <obj1> <obj2>)    -> a weak cons
  315.   (##WEAK-PAIR? <object>)    -> #t or #f
  316.   (##WEAK-CAR <weak-pair>)    -> <obj1> or #f
  317.   (##WEAK-CDR <weak-pair>)    -> <obj2>
  318.     Weak pairs are a special object that behavies like a cons cell,
  319.     except that the car pointer is weak.  This means that if no 
  320.     "strong" ppointer is referencing an object denoted by the car
  321.     slot, it will be collected after gc.  When collected, the car's
  322.     value becomes #f.  The cdr slot is `normal'.  Note that a
  323.     weak-pair is *not* a pair-- you must use the ##weak-* functions.
  324.     I.e. you cannot take the CAR of a weak-pair, you must use
  325.     ##weak-car.  Weak pointers are useful to keep track of things
  326.     that you don't want to stay around just because you are keeping
  327.     track of them (e.g. elements of a set with some property).
  328.  
  329.   (FUTURE <expression>) -> <future>
  330.     Futures are a multi-processing construct.  The value is potentially
  331.     calculated in parallel with other computations.  Futures may be
  332.     stored in data structures.  Their value is guarenteed where it is
  333.     first used ("touching" is implicit in this implementation).
  334.  
  335. Extensions for compiler users:
  336.  
  337.   (COMPILE <string> [ <option>* ] ) 
  338.     options:
  339.       ASM causes a commented assembly file to be generated
  340.       PVM creates a file of Portable Virtual Machine instructions
  341.       EXPANSION shows code after macro expansion
  342.       VERBOSE causes a report of compile time actions to be displayed
  343.       REPORT  reports on global variable usage
  344.       DEBUG compiles in debug information (takes up a lot of space!) so that
  345.             compiled code can be debugged like interpreted code.
  346.  
  347.   (MAKE-UNSCANNED-VECTOR <num-slots>) -- Creates a vector which is not
  348.     scanned by the collector.  Useful for stashing C pointers and non-Scheme
  349.     binary values.
  350.   (UNSCANNED-VECTOR? v)        -> #t or #f
  351.   (UNSCANNED-VECTOR-LENGTH uv)    -> <num-slots>
  352.   (UNSCANNED-VECTOR-SET! uv index val)
  353.   (UNSCANNED-VECTOR-REF  uv index) -- you should probably never use this!
  354.     [The implementation is in "runtime/gsi.scm"].
  355.  
  356.   (REGISTER-FOR-FINALIZATION <object> <thunk>) -- After the next
  357.     collection where <object> is no longer referenced, executes
  358.     <thunk>.  Note that <thunk> cannot refer to <object> or it will
  359.     never be collected.  This is useful for invoking destructors on C
  360.     malloc'ed storage when windows close, etc.  Note that it is
  361.     considered bad form to allocate storage within <thunk>.  [The
  362.     implementation is in "runtime/gsi.scm"].
  363.  
  364.   
  365. ; SYNTAX
  366.  
  367.   (LAMBDA <name> <exp>+ )
  368.   (LAMBDA (<name>* ) <exp>+ )
  369.   (AND <object>*)
  370.   (OR  <object>*)
  371.   (IF <test-exp> <if-true> [<if-false>] )
  372.   (COND (<test> <exp>* )... [(ELSE <exp>+)] )
  373.   (CASE <key-exp> ((<datum>+ ) <exp>* )... [(ELSE <exp>+)] )
  374.   (LET [<name>] ( (<vname> <value-exp>) ) <body-exp> )
  375.   (LET*   ( (<vname> <value-exp>) ) <body-exp> )
  376.   (LETREC ( (<vname> <value-exp>) ) <body-exp> )
  377.   (BEGIN <expression>+ )
  378.   (DO ( (<var> <init> <step>)... ) ( <test> <exp>* ) <exp>* )
  379.   ;; Note also R^4RS syntax, below
  380.  
  381. ; IEEE Scheme
  382.  
  383.   (NOT <object>)
  384.   (BOOLEAN? <object>)
  385.  
  386.   (EQV? <obj1> <obj2>)
  387.   (EQ? <obj1> <obj2>)
  388.   (EQUAL? <obj1> <obj2>)
  389.  
  390.   (PAIR? <object>)
  391.   (CONS <obj1> <obj2>)
  392.   (CAR <pair>)
  393.   (CDR <pair>)
  394.   (SET-CAR! <pair> <object>)
  395.   (SET-CDR! <pair> <object>)
  396.   (CAAR  <list>)   (CADR  <list>)   (CDAR  <list>)   (CDDR <list>)
  397.   (CAAAR <list>)   (CAADR <list>)   (CADAR <list>)   (CADDR <list>)
  398.   (CDAAR <list>)   (CDADR <list>)   (CDDAR <list>)   (CDDDR <list>)
  399.   (CAAAAR <list>)  (CAAADR <list>)  (CAADAR <list>)  (CAADDR <list>)
  400.   (CADAAR <list>)  (CADADR <list>)  (CADDAR <list>)  (CADDDR <list>)
  401.   (CDAAAR <list>)  (CDAADR <list>)  (CDADAR <list>)  (CDADDR <list>)
  402.   (CDDAAR <list>)  (CDDADR <list>)  (CDDDAR <list>)  (CDDDDR <list>)
  403.   (NULL? <object>)
  404.   (LIST? <object>)
  405.   (LIST <object>* )
  406.   (LENGTH <list>)
  407.   (APPEND <list>+ )
  408.   (REVERSE <list>)
  409.   (LIST-REF <list> <index>)
  410.   (MEMQ  <object> <list>)
  411.   (MEMV  <object> <list>)
  412.   (MEMBER <object> <list>)
  413.   (ASSQ  <object> <alist>)
  414.   (ASSV  <object> <alist>)
  415.   (ASSOC <object> <alist>)
  416.  
  417.   (SYMBOL? <object>)
  418.   (SYMBOL->STRING <symbol>)  (STRING->SYMBOL <string>)
  419.  
  420.   (NUMBER? <object>)
  421.   (COMPLEX? <object>)
  422.   (REAL? <object>)
  423.   (RATIONAL? <object>)
  424.   (INTEGER? <object>)
  425.   (EXACT? <number>)     (INEXACT? <number>)
  426.   (=  <number>+ )
  427.   (<  <number>+ )  (>  <number>+ )
  428.   (<= <number>+ )  (>= <number>+ )
  429.   (ZERO? <number>)
  430.   (POSITIVE? <number>)  (NEGATIVE? <number>)
  431.   (ODD? <number>)       (EVEN? <number>)
  432.   (MAX <number>+ )      (MIN <number>+ )
  433.   (+ <number>+ )
  434.   (* <number>+ )
  435.   (- <number>+ )
  436.   (/ <number>+ )
  437.   (ABS <number>)
  438.   (QUOTIENT <num1> <num2>)  (REMAINDER <num1> <num2>)
  439.   (MODULO <num1> <num2>)
  440.   (GCD <number>* )          (LCM <number>* )
  441.   (NUMERATOR <rational>)    (DENOMINATOR <rational>)
  442.   (FLOOR <number>)          (CEILING <number>)
  443.   (TRUNCATE <number>)       (ROUND <number>)
  444.   (RATIONALIZE <num1> <num2>)
  445.   (EXP <number>)            (LOG <number>)
  446.   (SIN <number>)   (COS <number>)   (TAN <number>)
  447.   (ASIN <number>)  (ACOS <number>)  (ATAN <number> [<number>])
  448.   (SQRT <number>)
  449.   (EXPT <num1> <num2>)
  450.   (MAKE-RECTANGULAR <num1> <num2>)  (MAKE-POLAR <num1> <num2>)
  451.   (REAL-PART <number>)       (IMAG-PART <number>)
  452.   (MAGNITUDE <number>)       (ANGLE <number>)
  453.   (EXACT->INEXACT <number>)  (INEXACT->EXACT <number>)
  454.   (NUMBER->STRING <number>)  (STRING->NUMBER <string>)
  455.  
  456.   (CHAR? <object>)
  457.   (CHAR=?  <char1> <char2>)  (CHAR-CI=?  <char1> <char2>)
  458.   (CHAR<?  <char1> <char2>)  (CHAR-CI<?  <char1> <char2>)
  459.   (CHAR>?  <char1> <char2>)  (CHAR-CI>?  <char1> <char2>)
  460.   (CHAR<=? <char1> <char2>)  (CHAR-CI<=? <char1> <char2>)
  461.   (CHAR>=? <char1> <char2>)  (CHAR-CI>=? <char1> <char2>)
  462.   (CHAR-ALPHABETIC? <character>)
  463.   (CHAR-NUMERIC?    <character>)
  464.   (CHAR-WHITESPACE? <character>)
  465.   (CHAR-UPPER-CASE? <character>)  (CHAR-LOWER-CASE? <character>)
  466.   (CHAR->INTEGER <character>)     (INTEGER->CHAR    <integer>)
  467.   (CHAR-UPCASE   <character>)     (CHAR-DOWNCASE    <character>)
  468.  
  469.   (STRING? <object>)
  470.   (MAKE-STRING <length> [<character>] )
  471.   (STRING <character>+ )
  472.   (STRING-LENGTH <string>)
  473.   (STRING-REF <string> <index>)
  474.   (STRING-SET! <string> <index> <character>)
  475.   (STRING=?  <string1> <string2>)  (STRING-CI=?  <string1> <string2>)
  476.   (STRING<?  <string1> <string2>)  (STRING-CI<?  <string1> <string2>)
  477.   (STRING>?  <string1> <string2>)  (STRING-CI>?  <string1> <string2>)
  478.   (STRING<=? <string1> <string2>)  (STRING-CI<=? <string1> <string2>)
  479.   (STRING>=? <string1> <string2>)  (STRING-CI>=? <string1> <string2>)
  480.   (SUBSTRING <string> <start-index> <end-index>)
  481.   (STRING-APPEND <string>+ )
  482.  
  483.   (VECTOR? <object>)
  484.   (MAKE-VECTOR <length> [<object>] )
  485.   (VECTOR <object>* )
  486.   (VECTOR-LENGTH <vector>)
  487.   (VECTOR-REF  <vector> <index>)
  488.   (VECTOR-SET! <vector> <index> <object>)
  489.  
  490.   (PROCEDURE? <object>)
  491.   (APPLY <procedure> <arg>* <arg-list>)
  492.   (MAP   <procedure> <list>+ )
  493.   (FOR-EACH <procedure> <list>+ )
  494.   (CALL-WITH-CURRENT-CONTINUATION <one-argument-procedure>)
  495.  
  496.   (CALL-WITH-INPUT-FILE  <string> <procedure>)
  497.   (CALL-WITH-OUTPUT-FILE <string> <procedure>)
  498.   (INPUT-PORT? <object>)  (OUTPUT-PORT? <object>)
  499.   (CURRENT-INPUT-PORT)    (CURRENT-OUTPUT-PORT)
  500.   (OPEN-INPUT-FILE  <string>)       (OPEN-OUTPUT-FILE <string>)
  501.   (CLOSE-INPUT-PORT  <input-port>)  (CLOSE-OUTPUT-PORT <output-port>)
  502.   (EOF-OBJECT? <object>)
  503.   (READ [<input-port>] )
  504.   (READ-CHAR [<input-port>] )
  505.   (PEEK-CHAR [<input-port>] )
  506.   (WRITE   <object> [<output-port>] )
  507.   (DISPLAY <object> [<output-port>] )
  508.   (NEWLINE [<output-port>] )
  509.   (WRITE-CHAR <character> [<output-port>] )
  510.  
  511.  
  512. ; R4RS Scheme
  513.  
  514.   (LIST-TAIL <list>)
  515.   (STRING->LIST <string>)
  516.   (LIST->STRING <list-of-characters>)
  517.   (STRING-COPY  <string>)
  518.   (STRING-FILL! <string> <character>)
  519.   (VECTOR->LIST <vector>)
  520.   (LIST->VECTOR <list>)
  521.   (VECTOR-FILL! <vector> <object>)
  522.   (DELAY <expression>)
  523.   (FORCE <promise>)
  524.   (WITH-INPUT-FROM-FILE <string> <thunk>)
  525.   (WITH-OUTPUT-TO-FILE  <string> <thunk>)
  526.   (CHAR-READY? [<input-port>] )
  527.   (LOAD <string>)
  528.   (TRANSCRIPT-ON <string>)
  529.   (TRANSCRIPT-OFF)
  530.   (DEFINE-SYNTAX <name> <transformer-spec>)  -- High-Level macros (only)
  531.   (LET-SYNTAX    ( <syntax-spec>* ) <exp>+ ) -- see R^4RS, below
  532.   (LETREC-SYNTAX ( <syntax-spec>* ) <exp>+ )
  533.  
  534.  
  535.  
  536. === STANDARDS REFERENCES ===
  537.  
  538.  
  539. IEEE Standard 1178-1990. "IEEE Standard for the Scheme Programming
  540. Language", IEEE, New York, 1991, ISBN 1-55937-125-0 [1-800-678-IEEE:
  541. order # SH14209].  -- now also an ANSI standard.
  542.  
  543. W. Clinger and J. Rees, eds., "Revised^4 Report on the Algorithmic
  544. Language Scheme" (R^4RS), ACM LISP Pointers IV, 3 (July-September 1991).
  545.  
  546.  
  547.  
  548. ;;            --- E O F ---            ;;
  549.