This is sizzle-ref.info, produced by makeinfo version 4.0 from
sizzle-ref.texi.

INFO-DIR-SECTION Sizzle Scheme Interpreter
START-INFO-DIR-ENTRY
* sizzle-ref: (sizzle-ref).     Sizzle reference manual.
END-INFO-DIR-ENTRY

   This file documents the Sizzle Scheme interpreter.

   Copyright (C) 1999, 2000 Martin Grabmueller

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.


File: sizzle-ref.info,  Node: Index,  Prev: Glossary,  Up: Top

Index
*****

* Menu:

* !=:                                    Numerical operations.
* %dlcall:                               Dynamic Loading.
* %dlclose:                              Dynamic Loading.
* %dlopen:                               Dynamic Loading.
* %dlsym:                                Dynamic Loading.
* %eval-time-taken%:                     Predefined Variables.
* %load-path:                            Predefined Variables.
* %max-evaluate-stack%:                  Predefined Variables.
* %print-backtrace%:                     Predefined Variables.
* %print-backtrace-limit%:               Predefined Variables.
* %print-func-bodies%:                   Predefined Variables.
* %print-memoized%:                      Predefined Variables.
* %print-read%:                          Predefined Variables.
* %print-result%:                        Predefined Variables.
* %read-delimited!:                      Input and output.
* %save-backtrace%:                      Predefined Variables.
* %sizzle-major-version%:                Predefined Variables.
* %sizzle-minor-version%:                Predefined Variables.
* %sizzle-patchlevel%:                   Predefined Variables.
* %sizzle-version%:                      Predefined Variables.
* %write-history-file%:                  Predefined Variables.
* *:                                     Numerical operations.
* +:                                     Numerical operations.
* -:                                     Numerical operations.
* ...:                                   List selectors.
* /:                                     Numerical operations.
* 1+:                                    Misc functions.
* 1-:                                    Misc functions.
* <:                                     Numerical operations.
* <=:                                    Numerical operations.
* =:                                     Numerical operations.
* >:                                     Numerical operations.
* >=:                                    Numerical operations.
* abs:                                   Numerical operations.
* accept:                                Network Procedures.
* access?:                               System interface functions.
* acos:                                  Numerical operations.
* add1:                                  Misc functions.
* alist-cons:                            Association lists.
* alist-copy:                            Association lists.
* alist-delete:                          Association lists.
* alist-delete!:                         Association lists.
* and:                                   Syntactic Forms.
* angle:                                 Numerical operations.
* any:                                   List searching.
* append:                                Miscellaneous list procedures.
* append!:                               Miscellaneous list procedures.
* append-map:                            Fold unfold and map.
* append-map!:                           Fold unfold and map.
* append-reverse:                        Miscellaneous list procedures.
* append-reverse!:                       Miscellaneous list procedures.
* apply:                                 Control flow operations.
* apply-macro:                           Macro functions.
* apropos:                               Self-Documentation.
* ash:                                   Numerical operations.
* asin:                                  Numerical operations.
* assoc:                                 Association lists.
* assq:                                  Association lists.
* assv:                                  Association lists.
* atan:                                  Numerical operations.
* backtrace:                             Debugging Support.
* basename:                              String Pathname Operations.
* begin:                                 Syntactic Forms.
* bind:                                  Network Procedures.
* boolean->integer:                      Boolean operations.
* boolean?:                              Boolean operations.
* box-ref:                               Box Operations.
* box-set!:                              Box Operations.
* box?:                                  Box Operations.
* break <1>:                             Syntactic Forms.
* break:                                 List searching.
* break!:                                List searching.
* caar:                                  List selectors.
* cadr:                                  List selectors.
* call-with-current-continuation:        Control flow operations.
* call-with-input-file:                  Input and output.
* call-with-input-string:                Input and output.
* call-with-output-file:                 Input and output.
* call-with-output-string:               Input and output.
* call-with-values:                      Control flow operations.
* call/cc:                               Control flow operations.
* car:                                   List selectors.
* car+cdr:                               List selectors.
* case:                                  Syntactic Forms.
* catch:                                 Control flow operations.
* cdddar:                                List selectors.
* cddddr:                                List selectors.
* cdr:                                   List selectors.
* ceiling:                               Numerical operations.
* char->integer:                         Character operations.
* char-alphabetic?:                      Character operations.
* char-ci<:                              Character operations.
* char-ci<=:                             Character operations.
* char-ci=:                              Character operations.
* char-ci>:                              Character operations.
* char-ci>=:                             Character operations.
* char-downcase:                         Character operations.
* char-lower-case?:                      Character operations.
* char-numeric?:                         Character operations.
* char-ready?:                           Input and output.
* char-upcase:                           Character operations.
* char-upper-case?:                      Character operations.
* char-whitespace?:                      Character operations.
* char<:                                 Character operations.
* char<=:                                Character operations.
* char=:                                 Character operations.
* char>:                                 Character operations.
* char>=:                                Character operations.
* char?:                                 Character operations.
* chdir:                                 System interface functions.
* chmod:                                 System interface functions.
* chown:                                 System interface functions.
* circular-list:                         List constructors.
* circular-list?:                        List predicates.
* cleanup-filename:                      String Pathname Operations.
* close:                                 System interface functions.
* close-input-port:                      Input and output.
* close-output-port:                     Input and output.
* close-port:                            Input and output.
* closedir:                              System interface functions.
* closure?:                              Control flow operations.
* command-line:                          System interface functions.
* complex?:                              Numerical operations.
* concatenate:                           Miscellaneous list procedures.
* concatenate!:                          Miscellaneous list procedures.
* cond:                                  Syntactic Forms.
* connect:                               Network Procedures.
* cons:                                  List constructors.
* cons*:                                 List constructors.
* continue:                              Syntactic Forms.
* copy-file:                             System interface functions.
* cos:                                   Numerical operations.
* count:                                 Miscellaneous list procedures.
* current-environment:                   Eval function.
* current-error-port:                    Input and output.
* current-input-port:                    Input and output.
* current-module:                        Module System.
* current-output-port:                   Input and output.
* current-time:                          System interface functions.
* define:                                Syntactic Forms.
* define-constant:                       Syntactic Forms.
* define-macro:                          Macro functions.
* define-module:                         Module System.
* defined?:                              Syntactic Forms.
* delay:                                 Syntactic Forms.
* delete:                                Deletion.
* delete!:                               Deletion.
* delete-duplicates:                     Deletion.
* delete-duplicates!:                    Deletion.
* denominator:                           Numerical operations.
* describe:                              Self-Documentation.
* directory-files:                       System interface functions.
* directory-stream?:                     System interface functions.
* dirname:                               String Pathname Operations.
* display:                               Input and output.
* dl-error:                              Dynamic Loading.
* do:                                    Syntactic Forms.
* documentation:                         Self-Documentation.
* dotted-list?:                          List predicates.
* drop:                                  List selectors.
* drop-right:                            List selectors.
* drop-right!:                           List selectors.
* drop-while:                            List searching.
* dynamic-wind:                          Control flow operations.
* eighth:                                List selectors.
* eof-object?:                           Input and output.
* eq?:                                   Equality tests.
* equal?:                                Equality tests.
* eqv?:                                  Equality tests.
* error:                                 Control flow operations.
* eval:                                  Eval function.
* even?:                                 Numerical operations.
* every:                                 List searching.
* exact->inexact:                        Numerical operations.
* exact?:                                Numerical operations.
* execl:                                 System interface functions.
* execle:                                System interface functions.
* execlp:                                System interface functions.
* exit:                                  Control flow operations.
* exp:                                   Numerical operations.
* expand-macro:                          Macro functions.
* export:                                Module System.
* expt:                                  Numerical operations.
* false-if-exception:                    Syntactic Forms.
* fcntl:                                 System interface functions.
* fifth:                                 List selectors.
* fileno:                                Network Procedures.
* filter:                                Filtering and partitioning.
* filter!:                               Filtering and partitioning.
* filter-map:                            Fold unfold and map.
* find:                                  List searching.
* find-tail:                             List searching.
* first:                                 List selectors.
* floor:                                 Numerical operations.
* fold:                                  Fold unfold and map.
* for-each:                              Fold unfold and map.
* force:                                 Control flow operations.
* force-output:                          Input and output.
* fork:                                  System interface functions.
* form?:                                 Control flow operations.
* fourth:                                List selectors.
* fsync:                                 System interface functions.
* ftell:                                 Input and output.
* garbage-collect:                       Runtime system.
* gc-message:                            Predefined Variables.
* gc-stats:                              Misc functions.
* gcd:                                   Numerical operations.
* gensym:                                Symbol operations.
* get-output-string:                     Input and output.
* getcwd:                                System interface functions.
* getdomainname:                         Network Procedures.
* getegid:                               System interface functions.
* getenv:                                System interface functions.
* geteuid:                               System interface functions.
* getgid:                                System interface functions.
* getgroups:                             System interface functions.
* gethostbyname:                         Network Procedures.
* gethostname:                           Network Procedures.
* getpeername:                           Network Procedures.
* getpgid:                               System interface functions.
* getpgrp:                               System interface functions.
* getpid:                                System interface functions.
* getppid:                               System interface functions.
* getpwnam:                              System interface functions.
* getpwuid:                              System interface functions.
* getsockname:                           Network Procedures.
* getuid:                                System interface functions.
* gmtime:                                System interface functions.
* hash:                                  Hash table operations.
* hash-create-handle!:                   Hash table operations.
* hash-fold:                             Hash table operations.
* hash-get-handle:                       Hash table operations.
* hash-ref:                              Hash table operations.
* hash-remove!:                          Hash table operations.
* hash-set!:                             Hash table operations.
* hashq:                                 Hash table operations.
* hashq-create-handle!:                  Hash table operations.
* hashq-get-handle:                      Hash table operations.
* hashq-ref:                             Hash table operations.
* hashq-remove!:                         Hash table operations.
* hashq-set!:                            Hash table operations.
* hashv:                                 Hash table operations.
* hashv-create-handle!:                  Hash table operations.
* hashv-get-handle:                      Hash table operations.
* hashv-ref:                             Hash table operations.
* hashv-remove!:                         Hash table operations.
* hashv-set!:                            Hash table operations.
* htonl:                                 Network Procedures.
* htons:                                 Network Procedures.
* if:                                    Syntactic Forms.
* imag-part:                             Numerical operations.
* inet-aton:                             Network Procedures.
* inet-ntoa:                             Network Procedures.
* inexact->exact:                        Numerical operations.
* inexact?:                              Numerical operations.
* input-port?:                           Input and output.
* integer->boolean:                      Boolean operations.
* integer->char:                         Character operations.
* integer?:                              Numerical operations.
* interaction-environment:               Eval function.
* invalidate-pointer!:                   Pointer Operations.
* iota:                                  List constructors.
* isatty?:                               Input and output.
* keyword-table:                         Debugging Support.
* kill:                                  System interface functions.
* lambda:                                Syntactic Forms.
* last:                                  List selectors.
* last-pair:                             List selectors.
* lcm:                                   Numerical operations.
* length:                                Miscellaneous list procedures.
* length+:                               Miscellaneous list procedures.
* let:                                   Syntactic Forms.
* let*:                                  Syntactic Forms.
* letrec:                                Syntactic Forms.
* link:                                  System interface functions.
* list:                                  List constructors.
* list->:                                Homogenous Vector Operations.
* list->string:                          String Constructors.
* list->vector:                          Vector conversion.
* list-copy:                             List constructors.
* list-index:                            List searching.
* list-ref:                              List selectors.
* list-tabulate:                         List constructors.
* list-tail:                             List selectors.
* list=:                                 List predicates.
* list?:                                 List predicates.
* listen:                                Network Procedures.
* load:                                  Control flow operations.
* load-library:                          Dynamic Loading.
* localtime:                             System interface functions.
* log:                                   Numerical operations.
* logand:                                Numerical operations.
* logior:                                Numerical operations.
* lognot:                                Numerical operations.
* logxor:                                Numerical operations.
* long?:                                 Numerical operations.
* lset-adjoin:                           Set operations on lists.
* lset-diff+intersection:                Set operations on lists.
* lset-diff+intersection!:               Set operations on lists.
* lset-difference:                       Set operations on lists.
* lset-difference!:                      Set operations on lists.
* lset-intersection:                     Set operations on lists.
* lset-intersection!:                    Set operations on lists.
* lset-union:                            Set operations on lists.
* lset-union!:                           Set operations on lists.
* lset-xor:                              Set operations on lists.
* lset-xor!:                             Set operations on lists.
* lset<=:                                Set operations on lists.
* lset=:                                 Set operations on lists.
* lsh:                                   Numerical operations.
* lstat:                                 System interface functions.
* magnitude:                             Numerical operations.
* make-:                                 Homogenous Vector Operations.
* make-box:                              Box Operations.
* make-hash:                             Hash table operations.
* make-list:                             List constructors.
* make-pointer:                          Pointer Operations.
* make-regexp:                           Regular expression functions.
* make-string:                           String Constructors.
* make-vector:                           Vector constructors.
* map:                                   Fold unfold and map.
* map!:                                  Fold unfold and map.
* map-in-order:                          Fold unfold and map.
* max:                                   Numerical operations.
* member:                                List searching.
* memq:                                  List searching.
* memv:                                  List searching.
* min:                                   Numerical operations.
* module-list:                           Module System.
* modulo:                                Numerical operations.
* negative?:                             Numerical operations.
* network-error:                         Network Procedures.
* newline:                               Input and output.
* nice:                                  System interface functions.
* ninth:                                 List selectors.
* not:                                   Boolean operations.
* not-pair?:                             List predicates.
* ntohl:                                 Network Procedures.
* ntohs:                                 Network Procedures.
* null-environment:                      Eval function.
* null-list?:                            List predicates.
* null?:                                 List predicates.
* number->string:                        Numerical operations.
* number?:                               Numerical operations.
* numerator:                             Numerical operations.
* object->string:                        Input and output.
* odd?:                                  Numerical operations.
* open-fdes:                             System interface functions.
* open-input-file:                       Input and output.
* open-input-string:                     Input and output.
* open-output-file:                      Input and output.
* open-output-string:                    Input and output.
* opendir:                               System interface functions.
* or:                                    Syntactic Forms.
* output-port?:                          Input and output.
* pair-fold:                             Fold unfold and map.
* pair-for-each:                         Fold unfold and map.
* pair?:                                 List predicates.
* partition:                             Filtering and partitioning.
* partition!:                            Filtering and partitioning.
* peek-char:                             Input and output.
* pointer?:                              Pointer Operations.
* port-closed?:                          Input and output.
* port-column:                           Input and output.
* port-filename:                         Input and output.
* port-line:                             Input and output.
* positive?:                             Numerical operations.
* pretty-print:                          Misc functions.
* primitive-exit:                        System interface functions.
* primitive-load:                        Control flow operations.
* primitive-load-path:                   Control flow operations.
* primitive-procedure?:                  Control flow operations.
* procedure?:                            Control flow operations.
* profile-stats:                         Misc functions.
* proper-list?:                          List predicates.
* putenv:                                System interface functions.
* pw:dir:                                System interface functions.
* pw:gecos:                              System interface functions.
* pw:gid:                                System interface functions.
* pw:name:                               System interface functions.
* pw:passwd:                             System interface functions.
* pw:shell:                              System interface functions.
* pw:uid:                                System interface functions.
* quasiquote:                            Syntactic Forms.
* quote:                                 Syntactic Forms.
* quotient:                              Numerical operations.
* random:                                Misc functions.
* rational?:                             Numerical operations.
* read:                                  Input and output.
* read-char:                             Input and output.
* read-line:                             Input and output.
* readdir:                               System interface functions.
* readlink:                              System interface functions.
* real-part:                             Numerical operations.
* real?:                                 Numerical operations.
* receive:                               Control flow operations.
* reduce:                                Fold unfold and map.
* reduce-right:                          Fold unfold and map.
* regexp-exec:                           Regular expression functions.
* regexp?:                               Regular expression functions.
* remainder:                             Numerical operations.
* remove:                                Filtering and partitioning.
* remove!:                               Filtering and partitioning.
* rename:                                System interface functions.
* reverse:                               Miscellaneous list procedures.
* reverse!:                              Miscellaneous list procedures.
* reverse-list->string:                  String Constructors.
* rewinddir:                             System interface functions.
* round:                                 Numerical operations.
* s8vector->string:                      Homogenous Vector Operations.
* safe-environment:                      Eval function.
* scheme-report-environment:             Eval function.
* second:                                List selectors.
* seek:                                  Input and output.
* select:                                Network Procedures.
* server-loop:                           Network Procedures.
* server-socket:                         Network Procedures.
* set!:                                  Syntactic Forms.
* set-car!:                              Primitive side-effects.
* set-cdr!:                              Primitive side-effects.
* set-current-error-port:                Input and output.
* set-current-input-port:                Input and output.
* set-current-output-port:               Input and output.
* set-documentation!:                    Self-Documentation.
* set-port-column!:                      Input and output.
* set-port-filename!:                    Input and output.
* set-port-line!:                        Input and output.
* setdomainname:                         Network Procedures.
* setegid:                               System interface functions.
* seteuid:                               System interface functions.
* setgid:                                System interface functions.
* sethostname:                           Network Procedures.
* setuid:                                System interface functions.
* seventh:                               List selectors.
* shutdown:                              Network Procedures.
* signal:                                Control flow operations.
* signum:                                Numerical operations.
* sin:                                   Numerical operations.
* sixth:                                 List selectors.
* sleep:                                 System interface functions.
* socket:                                Network Procedures.
* span:                                  List searching.
* span!:                                 List searching.
* split-at:                              List selectors.
* split-at!:                             List selectors.
* sqrt:                                  Numerical operations.
* srand:                                 Misc functions.
* stat:                                  System interface functions.
* stat:atime:                            System interface functions.
* stat:blksize:                          System interface functions.
* stat:blocks:                           System interface functions.
* stat:ctime:                            System interface functions.
* stat:dev:                              System interface functions.
* stat:gid:                              System interface functions.
* stat:ino:                              System interface functions.
* stat:mode:                             System interface functions.
* stat:mtime:                            System interface functions.
* stat:nlink:                            System interface functions.
* stat:perms:                            System interface functions.
* stat:rdev:                             System interface functions.
* stat:size:                             System interface functions.
* stat:type:                             System interface functions.
* stat:uid:                              System interface functions.
* strftime:                              System interface functions.
* string:                                String Constructors.
* string->list:                          String Constructors.
* string->number:                        Numerical operations.
* string->s8vector:                      Homogenous Vector Operations.
* string->symbol:                        Symbol operations.
* string->u8vector:                      Homogenous Vector Operations.
* string-any:                            String Predicates.
* string-append:                         String Constructors.
* string-chop:                           String Trimming.
* string-ci<=?:                          String Comparison.
* string-ci<?:                           String Comparison.
* string-ci=?:                           String Comparison.
* string-ci>=?:                          String Comparison.
* string-ci>?:                           String Comparison.
* string-contains:                       String Searching.
* string-contains-ci:                    String Searching.
* string-copy:                           String Constructors.
* string-count:                          String Searching.
* string-downcase:                       String Case Conversion.
* string-downcase!:                      String Case Conversion.
* string-drop:                           String Decomposition.
* string-drop-right:                     String Decomposition.
* string-every:                          String Predicates.
* string-fill!:                          String Accessors.
* string-hash:                           String Searching.
* string-hash-ci:                        String Searching.
* string-index:                          String Searching.
* string-index-right:                    String Searching.
* string-join:                           String Constructors.
* string-length:                         String Accessors.
* string-null?:                          String Predicates.
* string-pad:                            String Padding.
* string-pad-right:                      String Padding.
* string-prefix-ci?:                     String Comparison.
* string-prefix-length:                  String Comparison.
* string-prefix-length-ci:               String Comparison.
* string-prefix?:                        String Comparison.
* string-ref:                            String Accessors.
* string-reverse:                        String Constructors.
* string-reverse!:                       String Constructors.
* string-set!:                           String Accessors.
* string-skip:                           String Searching.
* string-skip-right:                     String Searching.
* string-split:                          String Decomposition.
* string-suffix-ci?:                     String Comparison.
* string-suffix-length:                  String Comparison.
* string-suffix-length-ci:               String Comparison.
* string-suffix?:                        String Comparison.
* string-tabulate:                       String Constructors.
* string-take:                           String Decomposition.
* string-take-right:                     String Decomposition.
* string-titlecase:                      String Case Conversion.
* string-titlecase!:                     String Case Conversion.
* string-trim:                           String Trimming.
* string-trim-both:                      String Trimming.
* string-trim-right:                     String Trimming.
* string-upcase:                         String Case Conversion.
* string-upcase!:                        String Case Conversion.
* string<=?:                             String Comparison.
* string<?:                              String Comparison.
* string=:                               String Comparison.
* string>=?:                             String Comparison.
* string>?:                              String Comparison.
* string?:                               String Predicates.
* strptime:                              System interface functions.
* sub1:                                  Misc functions.
* substring:                             String Accessors.
* symbol->string:                        Symbol operations.
* symbol-table:                          Debugging Support.
* symbol?:                               Symbol operations.
* symlink:                               System interface functions.
* sync:                                  System interface functions.
* sys:creat:                             System interface functions.
* sys:pipe:                              System interface functions.
* sys:read:                              System interface functions.
* sys:read!:                             System interface functions.
* sys:write:                             System interface functions.
* system:                                System interface functions.
* TAG:                                   Homogenous Vector Operations.
* take:                                  List selectors.
* take!:                                 List selectors.
* take-right:                            List selectors.
* take-while:                            List searching.
* take-while!:                           List searching.
* tan:                                   Numerical operations.
* tenth:                                 List selectors.
* third:                                 List selectors.
* throw:                                 Control flow operations.
* tilde-expand:                          String Pathname Operations.
* tm:hour:                               System interface functions.
* tm:isdst:                              System interface functions.
* tm:mday:                               System interface functions.
* tm:min:                                System interface functions.
* tm:month:                              System interface functions.
* tm:sec:                                System interface functions.
* tm:wday:                               System interface functions.
* tm:yday:                               System interface functions.
* tm:year:                               System interface functions.
* tm:zname:                              System interface functions.
* tm:zoff:                               System interface functions.
* tmpfile:                               System interface functions.
* tmpnam:                                System interface functions.
* toplevel:                              Control flow operations.
* trace:                                 Debugging Support.
* transcript-off:                        Control flow operations.
* transcript-on:                         Control flow operations.
* trim-whitespace:                       String Trimming.
* truncate:                              Numerical operations.
* u8vector->string:                      Homogenous Vector Operations.
* umask:                                 System interface functions.
* uname:                                 System interface functions.
* undefine:                              Syntactic Forms.
* unfold:                                Fold unfold and map.
* unfold-right:                          Fold unfold and map.
* unless:                                Syntactic Forms.
* unlink:                                System interface functions.
* unquote:                               Syntactic Forms.
* unquote-splicing:                      Syntactic Forms.
* unread-char:                           Input and output.
* unzip1:                                Miscellaneous list procedures.
* unzip2:                                Miscellaneous list procedures.
* unzip3:                                Miscellaneous list procedures.
* unzip4:                                Miscellaneous list procedures.
* unzip5:                                Miscellaneous list procedures.
* use-modules:                           Module System.
* utime:                                 System interface functions.
* values:                                Control flow operations.
* vector:                                Vector constructors.
* vector->list:                          Vector conversion.
* vector-copy:                           Vector constructors.
* vector-fill!:                          Vector modifying.
* vector-length:                         Vector selectors.
* vector-ref:                            Vector selectors.
* vector-set!:                           Vector modifying.
* vector-tabulate:                       Vector constructors.
* vector=:                               Vector predicates.
* vector?:                               Vector predicates.
* wait:                                  System interface functions.
* waitpid:                               System interface functions.
* when:                                  Syntactic Forms.
* while:                                 Syntactic Forms.
* with-error-to-file:                    Input and output.
* with-error-to-port:                    Input and output.
* with-error-to-string:                  Input and output.
* with-input-from-file:                  Input and output.
* with-input-from-port:                  Input and output.
* with-input-from-string:                Input and output.
* with-output-to-file:                   Input and output.
* with-output-to-port:                   Input and output.
* with-output-to-string:                 Input and output.
* write:                                 Input and output.
* write-char:                            Input and output.
* write-line:                            Input and output.
* xcons:                                 List constructors.
* zero?:                                 Numerical operations.
* zip:                                   Miscellaneous list procedures.


