| Index Entry | | Section |
|---|
|
| " | | |
|---|
| ": | | Strings |
|
| # | | |
|---|
| #: | | Syntax of numerical constants |
| #!optional: | | Additional Notations |
| #!optional: | | Lambda Expressions |
| #!rest: | | Additional Notations |
| #!rest: | | Lambda Expressions |
| #(: | | Vectors |
| #b: | | Syntax of numerical constants |
| #d: | | Syntax of numerical constants |
| #e: | | Syntax of numerical constants |
| #f: | | True and False |
| #f: | | Conditionals |
| #f: | | Booleans |
| #i: | | Syntax of numerical constants |
| #o: | | Syntax of numerical constants |
| #t: | | True and False |
| #t: | | Conditionals |
| #t: | | Booleans |
| #x: | | Syntax of numerical constants |
| #\: | | Characters |
| #\alarm: | | Characters |
| #\backspace: | | Characters |
| #\delete: | | Characters |
| #\escape: | | Characters |
| #\newline: | | Characters |
| #\null: | | Characters |
| #\return: | | Characters |
| #\space: | | Characters |
| #\space: | | Strings |
| #\tab: | | Characters |
|
| ' | | |
|---|
| ': | | Quoting |
| ': | | Lists |
|
| ( | | |
|---|
| (: | | Lists |
| (): | | Lists |
|
| ) | | |
|---|
| ): | | Lists |
|
| * | | |
|---|
| *: | | Procedure Call Syntax |
| *: | | Numerical operations |
| *: | | Regular S-Expressions |
| *: | | *Matcher |
| *: | | *Parser |
| *: | | R7RS |
| **: | | Regular S-Expressions |
| **: | | Regular S-Expressions |
| **?: | | Regular S-Expressions |
| *?: | | Regular S-Expressions |
| *default-pathname-defaults*: | | Operations on Pathnames |
| *matcher: | | *Matcher |
| *parser: | | *Parser |
| *parser-canonicalize-symbols?*: | | Input Procedures |
| *parser-radix*: | | Input Procedures |
| *random-state*: | | Random Number Generation |
| *unparse-with-maximum-readability?*: | | Output Procedures |
| *unparser-list-breadth-limit*: | | Output Procedures |
| *unparser-list-depth-limit*: | | Output Procedures |
| *unparser-radix*: | | Output Procedures |
| *unparser-string-length-limit*: | | Output Procedures |
|
| + | | |
|---|
| +: | | Procedure Call Syntax |
| +: | | Exactness |
| +: | | Numerical operations |
| +: | | Regular S-Expressions |
| +: | | *Matcher |
| +: | | *Parser |
| +: | | R7RS |
| +?: | | Regular S-Expressions |
| +inf.0: | | Flonum Operations |
| +nan.0: | | Flonum Operations |
| +snan.1: | | Flonum Operations |
|
| , | | |
|---|
| ,: | | Quoting |
| ,: | | Lists |
| ,@: | | Quoting |
| ,@: | | Lists |
|
| - | | |
|---|
| -: | | Numerical operations |
| -: | | R7RS |
| -1+: | | Numerical operations |
| ->char-set: | | SRFI 14 |
| ->namestring: | | Filenames and Pathnames |
| ->pathname: | | Filenames and Pathnames |
| ->pathname: | | Working Directory |
| ->truename: | | File Manipulation |
| -inf.0: | | Flonum Operations |
| -nan.0: | | Flonum Operations |
| -snan.1: | | Flonum Operations |
|
| . | | |
|---|
| .: | | Lists |
| ...: | | Pattern Language |
| ...: | | R7RS |
|
| / | | |
|---|
| /: | | Implementation restrictions |
| /: | | Numerical operations |
| /: | | R7RS |
|
| 1 | | |
|---|
| 1+: | | Numerical operations |
| 1d-table/alist: | | 1D Tables |
| 1d-table/get: | | 1D Tables |
| 1d-table/lookup: | | 1D Tables |
| 1d-table/put!: | | 1D Tables |
| 1d-table/remove!: | | 1D Tables |
| 1d-table?: | | 1D Tables |
|
| 2 | | |
|---|
| 2d-get: | | The Association Table |
| 2d-get-alist-x: | | The Association Table |
| 2d-get-alist-y: | | The Association Table |
| 2d-put!: | | The Association Table |
| 2d-remove!: | | The Association Table |
|
| 8 | | |
|---|
| 8-bit-char-set?: | | Character Sets |
|
| < | | |
|---|
| <: | | Numerical operations |
| <: | | R7RS |
| <=: | | Numerical operations |
| <=: | | R7RS |
| <=?: | | SRFI 128 |
| <?: | | SRFI 128 |
| <xml-!attlist>: | | XML Structure |
| <xml-!element>: | | XML Structure |
| <xml-!entity>: | | XML Structure |
| <xml-!notation>: | | XML Structure |
| <xml-declaration>: | | XML Structure |
| <xml-document>: | | XML Structure |
| <xml-dtd>: | | XML Structure |
| <xml-element>: | | XML Structure |
| <xml-external-id>: | | XML Structure |
| <xml-parameter-!entity>: | | XML Structure |
| <xml-processing-instructions>: | | XML Structure |
| <xml-unparsed-!entity>: | | XML Structure |
|
| = | | |
|---|
| =: | | Equivalence Predicates |
| =: | | Equivalence Predicates |
| =: | | Numerical operations |
| =: | | Numerical operations |
| =: | | Strings |
| =: | | R7RS |
| =>: | | Conditionals |
| =>: | | R7RS |
| =?: | | SRFI 128 |
|
| > | | |
|---|
| >: | | Numerical operations |
| >: | | R7RS |
| >=: | | Numerical operations |
| >=: | | R7RS |
| >=?: | | SRFI 128 |
| >?: | | SRFI 128 |
|
| ? | | |
|---|
| ?: | | Regular S-Expressions |
| ?: | | *Matcher |
| ?: | | *Parser |
| ??: | | Regular S-Expressions |
|
| \ | | |
|---|
| \": | | Strings |
| \a: | | Strings |
| \b: | | Strings |
| \n: | | Strings |
| \r: | | Strings |
| \t: | | Strings |
| \x: | | Strings |
| \\: | | Strings |
| \|: | | Strings |
|
| _ | | |
|---|
| _: | | R7RS |
|
| ` | | |
|---|
| `: | | Quoting |
| `: | | Lists |
|
| A | | |
|---|
| abort: | | Restarts |
| abort: | | Invoking Standard Restart Code |
| abs: | | Numerical operations |
| abs: | | R7RS |
| access: | | Assignments |
| access-condition: | | Generating Operations on Conditions |
| access-condition: | | Simple Condition Instance Operations |
| acos: | | Numerical operations |
| acos: | | R7RS |
| acos/pi: | | Numerical operations |
| aexsec: | | Numerical operations |
| aexsec/pi: | | Numerical operations |
| alist->amap: | | Amap constructors |
| alist->hash-table: | | Construction of Hash Tables |
| alist->hash-table: | | Construction of Hash Tables |
| alist->hash-table: | | SRFI 69 |
| alist->hash-table: | | SRFI 125 |
| alist->rb-tree: | | Red-Black Trees |
| alist->wt-tree: | | Construction of Weight-Balanced Trees |
| alist-cons: | | SRFI 1 |
| alist-copy: | | Association Lists |
| alist-copy: | | SRFI 1 |
| alist-delete: | | SRFI 1 |
| alist-delete!: | | SRFI 1 |
| alist?: | | Association Lists |
| allocate-host-address: | | Miscellaneous OS Facilities |
| alt: | | Regular S-Expressions |
| alt: | | *Matcher |
| alt: | | *Parser |
| amap->alist: | | Amap copying and conversion |
| amap-args: | | Amap accessors |
| amap-clean!: | | Amap mutators |
| amap-clear!: | | Amap mutators |
| amap-comparator: | | Amap accessors |
| amap-contains?: | | Amap predicates |
| amap-copy: | | Amap copying and conversion |
| amap-count: | | Amap contents |
| amap-delete!: | | Amap mutators |
| amap-difference!: | | Amaps as sets |
| amap-empty-copy: | | Amap copying and conversion |
| amap-empty?: | | Amap predicates |
| amap-entries: | | Amap contents |
| amap-find: | | Amap contents |
| amap-fold: | | Amap mapping and folding |
| amap-for-each: | | Amap mapping and folding |
| amap-implementation-name: | | Amap accessors |
| amap-implementation-names: | | Amap constructors |
| amap-implementation-supported-args: | | Amap constructors |
| amap-implementation-supports-args?: | | Amap constructors |
| amap-implementation-supports-comparator?: | | Amap constructors |
| amap-intern!: | | Amap mutators |
| amap-intersection!: | | Amaps as sets |
| amap-keys: | | Amap contents |
| amap-map: | | Amap mapping and folding |
| amap-map!: | | Amap mapping and folding |
| amap-map->list: | | Amap mapping and folding |
| amap-mutable?: | | Amap predicates |
| amap-pop!: | | Amap mutators |
| amap-prune!: | | Amap mapping and folding |
| amap-ref: | | Amap accessors |
| amap-ref/default: | | Amap accessors |
| amap-set!: | | Amap mutators |
| amap-size: | | Amap contents |
| amap-unfold: | | Amap constructors |
| amap-union!: | | Amaps as sets |
| amap-update!: | | Amap mutators |
| amap-update!/default: | | Amap mutators |
| amap-values: | | Amap contents |
| amap-xor!: | | Amaps as sets |
| amap=?: | | Amap predicates |
| amap?: | | Amap predicates |
| and: | | Conditionals |
| and: | | Booleans |
| and: | | R7RS |
| and-let*: | | and-let* (SRFI 2) |
| and-let*: | | SRFI 2 |
| angle: | | Numerical operations |
| angle: | | Numerical operations |
| angle: | | R7RS |
| any: | | Mapping of Lists |
| any: | | SRFI 1 |
| any-char: | | Regular S-Expressions |
| append: | | Cutting and Pasting Lists |
| append: | | R7RS |
| append: | | SRFI 1 |
| append!: | | Cutting and Pasting Lists |
| append!: | | SRFI 1 |
| append-map: | | Mapping of Lists |
| append-map: | | SRFI 1 |
| append-map!: | | Mapping of Lists |
| append-map!: | | SRFI 1 |
| append-map*: | | Mapping of Lists |
| append-map*!: | | Mapping of Lists |
| append-reverse: | | SRFI 1 |
| append-reverse!: | | SRFI 1 |
| apply: | | Procedure Operations |
| apply: | | R7RS |
| apply-hook-extra: | | Application Hooks |
| apply-hook-procedure: | | Application Hooks |
| apply-hook?: | | Application Hooks |
| arithmetic-shift: | | Bit operations |
| asin: | | Numerical operations |
| asin: | | R7RS |
| asin/pi: | | Numerical operations |
| assoc: | | Association Lists |
| assoc: | | R7RS |
| assoc: | | SRFI 1 |
| association-procedure: | | Association Lists |
| assq: | | Association Lists |
| assq: | | R7RS |
| assq: | | SRFI 1 |
| assv: | | Association Lists |
| assv: | | R7RS |
| assv: | | SRFI 1 |
| atan: | | Numerical operations |
| atan: | | Numerical operations |
| atan: | | Flonum Operations |
| atan: | | R7RS |
| atan/pi: | | Numerical operations |
| atan2/pi: | | Numerical operations |
| aversin: | | Numerical operations |
| aversin/pi: | | Numerical operations |
|
| B | | |
|---|
| beep: | | Output Procedures |
| begin: | | Sequencing |
| begin: | | R7RS |
| binary-port?: | | Ports |
| binary-port?: | | R7RS |
| bind-cell-contents!: | | Parameters |
| bind-condition-handler: | | Error System |
| bind-condition-handler: | | Condition Signalling |
| bind-condition-handler: | | Condition Handling |
| bind-condition-handler: | | Condition Handling |
| bind-default-condition-handler: | | Condition Signalling |
| bind-default-condition-handler: | | Condition Handling |
| bind-default-condition-handler: | | Condition Handling |
| bit: | | Bit operations |
| bit-antimask: | | Bit operations |
| bit-clear?: | | Bit operations |
| bit-count: | | Bit operations |
| bit-mask: | | Bit operations |
| bit-set?: | | Bit operations |
| bit-string->signed-integer: | | Integer Conversions of Bit Strings |
| bit-string->unsigned-integer: | | Integer Conversions of Bit Strings |
| bit-string-allocate: | | Construction of Bit Strings |
| bit-string-and: | | Bitwise Operations on Bit Strings |
| bit-string-and!: | | Bitwise Operations on Bit Strings |
| bit-string-andc: | | Bitwise Operations on Bit Strings |
| bit-string-andc!: | | Bitwise Operations on Bit Strings |
| bit-string-append: | | Cutting and Pasting Bit Strings |
| bit-string-clear!: | | Selecting Bit String Components |
| bit-string-copy: | | Construction of Bit Strings |
| bit-string-fill!: | | Modification of Bit Strings |
| bit-string-length: | | Selecting Bit String Components |
| bit-string-move!: | | Modification of Bit Strings |
| bit-string-movec!: | | Bitwise Operations on Bit Strings |
| bit-string-not: | | Bitwise Operations on Bit Strings |
| bit-string-or: | | Bitwise Operations on Bit Strings |
| bit-string-or!: | | Bitwise Operations on Bit Strings |
| bit-string-ref: | | Selecting Bit String Components |
| bit-string-set!: | | Selecting Bit String Components |
| bit-string-xor: | | Bitwise Operations on Bit Strings |
| bit-string-xor!: | | Bitwise Operations on Bit Strings |
| bit-string-zero?: | | Bitwise Operations on Bit Strings |
| bit-string=?: | | Bitwise Operations on Bit Strings |
| bit-string?: | | Selecting Bit String Components |
| bit-substring: | | Cutting and Pasting Bit Strings |
| bit-substring-find-next-set-bit: | | Selecting Bit String Components |
| bit-substring-move-right!: | | Modification of Bit Strings |
| bitless-char?: | | Character implementation |
| bits: | | Bit operations |
| bitwise-and: | | Bit operations |
| bitwise-andc1: | | Bit operations |
| bitwise-andc2: | | Bit operations |
| bitwise-eqv: | | Bit operations |
| bitwise-ior: | | Bit operations |
| bitwise-nand: | | Bit operations |
| bitwise-nor: | | Bit operations |
| bitwise-not: | | Bit operations |
| bitwise-orc1: | | Bit operations |
| bitwise-orc2: | | Bit operations |
| bitwise-xor: | | Bit operations |
| boolean-comparator: | | SRFI 162 |
| boolean-hash: | | SRFI 128 |
| boolean/and: | | Booleans |
| boolean/or: | | Booleans |
| boolean=?: | | R7RS |
| boolean?: | | Booleans |
| boolean?: | | R7RS |
| both: | | Strings |
| bound-restart: | | Finding and Invoking General Restart Code |
| bound-restarts: | | Finding and Invoking General Restart Code |
| bracketed-print-method: | | Custom Output |
| break: | | SRFI 1 |
| break!: | | SRFI 1 |
| break-on-signals: | | Condition Signalling |
| break-on-signals: | | Condition Handling |
| break-on-signals: | | Condition Handling |
| buffered-input-chars on textual input port: | | Textual Input Port Operations |
| buffered-output-chars on textual output port: | | Textual Output Port Operations |
| bytevector: | | R7RS |
| bytevector->generator: | | SRFI 158 |
| bytevector-accumulator: | | SRFI 158 |
| bytevector-accumulator!: | | SRFI 158 |
| bytevector-append: | | R7RS |
| bytevector-copy: | | R7RS |
| bytevector-copy!: | | R7RS |
| bytevector-length: | | R7RS |
| bytevector-u8-ref: | | R7RS |
| bytevector-u8-set!: | | R7RS |
| bytevector?: | | R7RS |
|
| C | | |
|---|
| caaaar: | | Pairs |
| caaaar: | | R7RS |
| caaaar: | | SRFI 1 |
| caaadr: | | Pairs |
| caaadr: | | R7RS |
| caaadr: | | SRFI 1 |
| caaar: | | Pairs |
| caaar: | | R7RS |
| caaar: | | SRFI 1 |
| caadar: | | Pairs |
| caadar: | | R7RS |
| caadar: | | SRFI 1 |
| caaddr: | | Pairs |
| caaddr: | | R7RS |
| caaddr: | | SRFI 1 |
| caadr: | | Pairs |
| caadr: | | R7RS |
| caadr: | | SRFI 1 |
| caar: | | Pairs |
| caar: | | R7RS |
| caar: | | SRFI 1 |
| cadaar: | | Pairs |
| cadaar: | | R7RS |
| cadaar: | | SRFI 1 |
| cadadr: | | Pairs |
| cadadr: | | R7RS |
| cadadr: | | SRFI 1 |
| cadar: | | Pairs |
| cadar: | | R7RS |
| cadar: | | SRFI 1 |
| caddar: | | Pairs |
| caddar: | | R7RS |
| caddar: | | SRFI 1 |
| cadddr: | | Pairs |
| cadddr: | | R7RS |
| cadddr: | | SRFI 1 |
| caddr: | | Pairs |
| caddr: | | R7RS |
| caddr: | | SRFI 1 |
| cadr: | | Pairs |
| cadr: | | R7RS |
| cadr: | | SRFI 1 |
| call-with-binary-input-file: | | File Ports |
| call-with-binary-input-file: | | File Ports |
| call-with-binary-output-file: | | File Ports |
| call-with-binary-output-file: | | File Ports |
| call-with-current-continuation: | | Continuations |
| call-with-current-continuation: | | R7RS |
| call-with-input-file: | | File Ports |
| call-with-input-file: | | R7RS |
| call-with-output-bytevector: | | Bytevector Ports |
| call-with-output-file: | | File Ports |
| call-with-output-file: | | R7RS |
| call-with-output-string: | | String Ports |
| call-with-port: | | Ports |
| call-with-port: | | File Ports |
| call-with-port: | | File Ports |
| call-with-port: | | R7RS |
| call-with-temporary-file-pathname: | | File Manipulation |
| call-with-truncated-output-port: | | Ports |
| call-with-truncated-output-port: | | String Ports |
| call-with-truncated-output-string: | | String Ports |
| call-with-truncated-output-string: | | String Ports |
| call-with-truncated-output-string: | | String Ports |
| call-with-values: | | Continuations |
| call-with-values: | | R7RS |
| call/cc: | | R7RS |
| canonical-host-name: | | Miscellaneous OS Facilities |
| capture-syntactic-environment: | | SC Transformer Definition |
| car: | | Storage Model |
| car: | | Pairs |
| car: | | Streams |
| car: | | R7RS |
| car: | | SRFI 1 |
| car+cdr: | | Pairs |
| car+cdr: | | SRFI 1 |
| case: | | Conditionals |
| case: | | Sequencing |
| case: | | R7RS |
| case-lambda: | | R7RS |
| cd: | | Working Directory |
| cdaaar: | | Pairs |
| cdaaar: | | R7RS |
| cdaaar: | | SRFI 1 |
| cdaadr: | | Pairs |
| cdaadr: | | R7RS |
| cdaadr: | | SRFI 1 |
| cdaar: | | Pairs |
| cdaar: | | R7RS |
| cdaar: | | SRFI 1 |
| cdadar: | | Pairs |
| cdadar: | | R7RS |
| cdadar: | | SRFI 1 |
| cdaddr: | | Pairs |
| cdaddr: | | R7RS |
| cdaddr: | | SRFI 1 |
| cdadr: | | Pairs |
| cdadr: | | R7RS |
| cdadr: | | SRFI 1 |
| cdar: | | Pairs |
| cdar: | | R7RS |
| cdar: | | SRFI 1 |
| cddaar: | | Pairs |
| cddaar: | | R7RS |
| cddaar: | | SRFI 1 |
| cddadr: | | Pairs |
| cddadr: | | R7RS |
| cddadr: | | SRFI 1 |
| cddar: | | Pairs |
| cddar: | | R7RS |
| cddar: | | SRFI 1 |
| cdddar: | | Pairs |
| cdddar: | | R7RS |
| cdddar: | | SRFI 1 |
| cddddr: | | Pairs |
| cddddr: | | R7RS |
| cddddr: | | SRFI 1 |
| cdddr: | | Pairs |
| cdddr: | | R7RS |
| cdddr: | | SRFI 1 |
| cddr: | | Pairs |
| cddr: | | R7RS |
| cddr: | | SRFI 1 |
| cdr: | | Entry Format |
| cdr: | | Pairs |
| cdr: | | Streams |
| cdr: | | R7RS |
| cdr: | | SRFI 1 |
| ceiling: | | Numerical operations |
| ceiling: | | R7RS |
| ceiling->exact: | | Numerical operations |
| ceiling-quotient: | | Numerical operations |
| ceiling-remainder: | | Numerical operations |
| ceiling/: | | Numerical operations |
| cell-contents: | | Parameters |
| cell?: | | Parameters |
| char: | | *Matcher |
| char->bitless-char: | | Character implementation |
| char->digit: | | Characters |
| char->integer: | | Characters |
| char->integer: | | R7RS |
| char->name: | | Characters |
| char-alphabetic?: | | Characters |
| char-alphabetic?: | | R7RS |
| char-alphanumeric?: | | Characters |
| char-bits: | | Character implementation |
| char-bits-limit: | | Character implementation |
| char-ci: | | Regular S-Expressions |
| char-ci: | | *Matcher |
| char-ci-comparator: | | SRFI 162 |
| char-ci-hash: | | SRFI 128 |
| char-ci-predicate: | | Character implementation |
| char-ci<=?: | | Characters |
| char-ci<=?: | | R7RS |
| char-ci<?: | | Characters |
| char-ci<?: | | R7RS |
| char-ci=?: | | Characters |
| char-ci=?: | | R7RS |
| char-ci>=?: | | Characters |
| char-ci>=?: | | R7RS |
| char-ci>?: | | Characters |
| char-ci>?: | | R7RS |
| char-code: | | Character implementation |
| char-code-limit: | | Character implementation |
| char-comparator: | | SRFI 162 |
| char-downcase: | | Characters |
| char-downcase: | | R7RS |
| char-foldcase: | | Characters |
| char-foldcase: | | R7RS |
| char-general-category: | | Unicode |
| char-graphic?: | | Prompting |
| char-hash: | | SRFI 128 |
| char-in: | | Regular S-Expressions |
| char-in-set?: | | Character Sets |
| char-lower-case?: | | Characters |
| char-lower-case?: | | R7RS |
| char-not-in: | | Regular S-Expressions |
| char-numeric?: | | Characters |
| char-numeric?: | | R7RS |
| char-predicate: | | Character implementation |
| char-ready?: | | Input Procedures |
| char-ready?: | | R7RS |
| char-ready? on textual input port: | | Textual Input Port Operations |
| char-set: | | Character Sets |
| char-set: | | *Matcher |
| char-set: | | SRFI 14 |
| char-set*: | | Character Sets |
| char-set->code-points: | | Character Sets |
| char-set->list: | | SRFI 14 |
| char-set->sre: | | SRFI 115 |
| char-set->string: | | SRFI 14 |
| char-set-adjoin: | | SRFI 14 |
| char-set-adjoin!: | | SRFI 14 |
| char-set-any: | | SRFI 14 |
| char-set-complement: | | SRFI 14 |
| char-set-complement!: | | SRFI 14 |
| char-set-contains?: | | SRFI 14 |
| char-set-copy: | | SRFI 14 |
| char-set-count: | | SRFI 14 |
| char-set-cursor: | | SRFI 14 |
| char-set-cursor-next: | | SRFI 14 |
| char-set-delete: | | SRFI 14 |
| char-set-delete!: | | SRFI 14 |
| char-set-diff+intersection: | | SRFI 14 |
| char-set-diff+intersection!: | | SRFI 14 |
| char-set-difference: | | Character Sets |
| char-set-difference: | | SRFI 14 |
| char-set-difference!: | | SRFI 14 |
| char-set-every: | | SRFI 14 |
| char-set-filter: | | SRFI 14 |
| char-set-filter!: | | SRFI 14 |
| char-set-fold: | | SRFI 14 |
| char-set-for-each: | | SRFI 14 |
| char-set-hash: | | SRFI 14 |
| char-set-intersection: | | Character Sets |
| char-set-intersection: | | SRFI 14 |
| char-set-intersection!: | | SRFI 14 |
| char-set-intersection*: | | Character Sets |
| char-set-invert: | | Character Sets |
| char-set-map: | | SRFI 14 |
| char-set-predicate: | | Character Sets |
| char-set-ref: | | SRFI 14 |
| char-set-size: | | SRFI 14 |
| char-set-unfold: | | SRFI 14 |
| char-set-unfold!: | | SRFI 14 |
| char-set-union: | | Character Sets |
| char-set-union: | | SRFI 14 |
| char-set-union!: | | SRFI 14 |
| char-set-union*: | | Character Sets |
| char-set-xor: | | SRFI 14 |
| char-set-xor!: | | SRFI 14 |
| char-set:alphabetic: | | Character Sets |
| char-set:alphanumeric: | | Character Sets |
| char-set:ascii: | | SRFI 14 |
| char-set:blank: | | SRFI 14 |
| char-set:digit: | | SRFI 14 |
| char-set:empty: | | SRFI 14 |
| char-set:full: | | SRFI 14 |
| char-set:graphic: | | SRFI 14 |
| char-set:hex-digit: | | SRFI 14 |
| char-set:iso-control: | | SRFI 14 |
| char-set:letter: | | SRFI 14 |
| char-set:letter+digit: | | SRFI 14 |
| char-set:lower-case: | | Character Sets |
| char-set:lower-case: | | SRFI 14 |
| char-set:numeric: | | Character Sets |
| char-set:printing: | | SRFI 14 |
| char-set:punctuation: | | SRFI 14 |
| char-set:symbol: | | SRFI 14 |
| char-set:title-case: | | SRFI 14 |
| char-set:upper-case: | | Character Sets |
| char-set:upper-case: | | SRFI 14 |
| char-set:whitespace: | | Character Sets |
| char-set:whitespace: | | Strings |
| char-set:whitespace: | | SRFI 14 |
| char-set<=: | | SRFI 14 |
| char-set=: | | SRFI 14 |
| char-set=?: | | Character Sets |
| char-set?: | | Character Sets |
| char-set?: | | SRFI 14 |
| char-title-case?: | | SRFI 129 |
| char-titlecase: | | SRFI 129 |
| char-upcase: | | Characters |
| char-upcase: | | R7RS |
| char-upper-case?: | | Characters |
| char-upper-case?: | | R7RS |
| char-whitespace?: | | Characters |
| char-whitespace?: | | Strings |
| char-whitespace?: | | R7RS |
| char<=?: | | Characters |
| char<=?: | | R7RS |
| char<?: | | Characters |
| char<?: | | R7RS |
| char=?: | | Equivalence Predicates |
| char=?: | | Equivalence Predicates |
| char=?: | | Characters |
| char=?: | | R7RS |
| char>=?: | | Characters |
| char>=?: | | R7RS |
| char>?: | | Characters |
| char>?: | | R7RS |
| char?: | | Characters |
| char?: | | R7RS |
| chars-remaining on textual input port: | | Textual Input Port Operations |
| circular-generator: | | SRFI 158 |
| circular-list: | | Miscellaneous List Operations |
| circular-list: | | SRFI 1 |
| circular-list?: | | Selecting List Components |
| circular-list?: | | SRFI 1 |
| clear: | | Output Procedures |
| clear-bit: | | Bit operations |
| close-all-open-files: | | File Ports |
| close-input-port: | | Ports |
| close-input-port: | | R7RS |
| close-output-port: | | Ports |
| close-output-port: | | R7RS |
| close-port: | | Ports |
| close-port: | | R7RS |
| close-syntax: | | SC Transformer Definition |
| close-tcp-server-socket: | | TCP Sockets |
| code-point-general-category: | | Unicode |
| code-point-in-set?: | | Character Sets |
| command-line: | | R7RS |
| comparator-check-type: | | SRFI 128 |
| comparator-equality-predicate: | | SRFI 128 |
| comparator-hash: | | SRFI 128 |
| comparator-hash-function: | | SRFI 128 |
| comparator-hashable?: | | SRFI 128 |
| comparator-if<=>: | | SRFI 128 |
| comparator-max: | | SRFI 162 |
| comparator-max-in-list: | | SRFI 162 |
| comparator-min: | | SRFI 162 |
| comparator-min-in-list: | | SRFI 162 |
| comparator-ordered?: | | SRFI 128 |
| comparator-ordering-predicate: | | SRFI 128 |
| comparator-register-default!: | | SRFI 128 |
| comparator-test-type: | | SRFI 128 |
| comparator-type-test-predicate: | | SRFI 128 |
| comparator?: | | SRFI 128 |
| compile-regsexp: | | Regsexp Procedures |
| compiled-procedure?: | | Procedure Operations |
| complex?: | | Numerical operations |
| complex?: | | R7RS |
| compound: | | Numerical operations |
| compound-procedure?: | | Procedure Operations |
| compoundm1: | | Numerical operations |
| compute-char-set: | | Character Sets |
| conc-name: | | Structure Definitions |
| concatenate: | | SRFI 1 |
| concatenate!: | | SRFI 1 |
| cond: | | Entry Format |
| cond: | | Conditionals |
| cond: | | Sequencing |
| cond: | | Booleans |
| cond: | | R7RS |
| cond-expand: | | cond-expand (SRFI 0) |
| cond-expand: | | R7RS |
| condition-accessor: | | Generating Operations on Conditions |
| condition-accessor: | | Generating Operations on Conditions |
| condition-accessor: | | Simple Condition Instance Operations |
| condition-constructor: | | Generating Operations on Conditions |
| condition-constructor: | | Generating Operations on Conditions |
| condition-predicate: | | Generating Operations on Conditions |
| condition-predicate: | | Generating Operations on Conditions |
| condition-signaller: | | Generating Operations on Conditions |
| condition-signaller: | | Generating Operations on Conditions |
| condition-type/error?: | | Condition Types |
| condition-type/field-names: | | Condition Types |
| condition-type/generalizations: | | Condition Types |
| condition-type:arithmetic-error: | | Taxonomy |
| condition-type:bad-range-argument: | | Numerical operations |
| condition-type:bad-range-argument: | | Integer Conversions of Bit Strings |
| condition-type:bad-range-argument: | | Integer Conversions of Bit Strings |
| condition-type:bad-range-argument: | | Object Hashing |
| condition-type:bad-range-argument: | | Taxonomy |
| condition-type:breakpoint: | | Error System |
| condition-type:breakpoint: | | Taxonomy |
| condition-type:control-error: | | Taxonomy |
| condition-type:datum-out-of-range: | | Taxonomy |
| condition-type:derived-file-error: | | Taxonomy |
| condition-type:derived-port-error: | | Taxonomy |
| condition-type:divide-by-zero: | | Taxonomy |
| condition-type:error: | | Condition Handling |
| condition-type:error: | | Condition State |
| condition-type:error: | | Condition Types |
| condition-type:error: | | Taxonomy |
| condition-type:file-error: | | Taxonomy |
| condition-type:file-operation-error: | | Miscellaneous Pathnames |
| condition-type:file-operation-error: | | File Manipulation |
| condition-type:file-operation-error: | | File Manipulation |
| condition-type:file-operation-error: | | Taxonomy |
| condition-type:floating-point-overflow: | | Taxonomy |
| condition-type:floating-point-underflow: | | Taxonomy |
| condition-type:illegal-datum: | | Taxonomy |
| condition-type:inapplicable-object: | | Taxonomy |
| condition-type:macro-binding: | | Environment Operations |
| condition-type:no-such-restart: | | Invoking Standard Restart Code |
| condition-type:no-such-restart: | | Invoking Standard Restart Code |
| condition-type:no-such-restart: | | Taxonomy |
| condition-type:not-loading: | | Taxonomy |
| condition-type:port-error: | | Taxonomy |
| condition-type:primitive-procedure-error: | | Taxonomy |
| condition-type:serious-condition: | | Error System |
| condition-type:serious-condition: | | Taxonomy |
| condition-type:simple-condition: | | Error System |
| condition-type:simple-condition: | | Taxonomy |
| condition-type:simple-error: | | Condition Signalling |
| condition-type:simple-error: | | Taxonomy |
| condition-type:simple-warning: | | Condition Signalling |
| condition-type:simple-warning: | | Taxonomy |
| condition-type:subprocess-abnormal-termination: | | Subprocess Conditions |
| condition-type:subprocess-signalled: | | Subprocess Conditions |
| condition-type:subprocess-stopped: | | Subprocess Conditions |
| condition-type:system-call-error: | | Taxonomy |
| condition-type:unassigned-variable: | | Variable Bindings |
| condition-type:unassigned-variable: | | Environment Operations |
| condition-type:unassigned-variable: | | Taxonomy |
| condition-type:unbound-variable: | | Environment Concepts |
| condition-type:unbound-variable: | | Dynamic Binding |
| condition-type:unbound-variable: | | Taxonomy |
| condition-type:variable-error: | | Taxonomy |
| condition-type:warning: | | Error System |
| condition-type:warning: | | Taxonomy |
| condition-type:wrong-number-of-arguments: | | Lambda Expressions |
| condition-type:wrong-number-of-arguments: | | Lambda Expressions |
| condition-type:wrong-number-of-arguments: | | Arity |
| condition-type:wrong-number-of-arguments: | | Taxonomy |
| condition-type:wrong-type-argument: | | Entry Format |
| condition-type:wrong-type-argument: | | Taxonomy |
| condition-type:wrong-type-datum: | | Taxonomy |
| condition-type?: | | Condition Types |
| condition/continuation: | | Condition State |
| condition/error?: | | Condition State |
| condition/report-string: | | Simple Condition Instance Operations |
| condition/restarts: | | Generating Operations on Conditions |
| condition/restarts: | | Condition State |
| condition/restarts: | | Simple Condition Instance Operations |
| condition/type: | | Condition State |
| condition?: | | Condition State |
| conjugate: | | Numerical operations |
| cons: | | Pairs |
| cons: | | R7RS |
| cons: | | SRFI 1 |
| cons*: | | Construction of Lists |
| cons*: | | SRFI 1 |
| cons-stream: | | Streams |
| console-i/o-port: | | Ports |
| constructor: | | Structure Definitions |
| continuation?: | | Continuations |
| continue: | | Restarts |
| continue: | | Invoking Standard Restart Code |
| copier: | | Structure Definitions |
| copy-area on x-graphics-device: | | Custom Operations on X Graphics Devices |
| copy-file: | | File Manipulation |
| copysign: | | Numerical operations |
| cos: | | Numerical operations |
| cos: | | R7RS |
| cos-pi*: | | Numerical operations |
| count: | | SRFI 1 |
| count-accumulator: | | SRFI 158 |
| count-pairs: | | Selecting List Components |
| cpu-architecture: | | SRFI 112 |
| create-image on graphics-device: | | Images |
| current-error-port: | | Ports |
| current-error-port: | | R7RS |
| current-file-time: | | File Manipulation |
| current-input-port: | | Ports |
| current-input-port: | | File Ports |
| current-input-port: | | R7RS |
| current-jiffy: | | R7RS |
| current-output-port: | | Ports |
| current-output-port: | | File Ports |
| current-output-port: | | R7RS |
| current-parser-macros: | | Parser-language Macros |
| current-second: | | R7RS |
|
| D | | |
|---|
| day-of-week/long-string: | | External Representation of Time |
| day-of-week/short-string: | | External Representation of Time |
| debug: | | Prompting |
| decoded-time->file-time: | | Time-Format Conversion |
| decoded-time->string: | | Time-Format Conversion |
| decoded-time->universal-time: | | Time-Format Conversion |
| decoded-time/date-string: | | External Representation of Time |
| decoded-time/day: | | Decoded Time |
| decoded-time/day-of-week: | | Decoded Time |
| decoded-time/daylight-savings-time?: | | Decoded Time |
| decoded-time/hour: | | Decoded Time |
| decoded-time/minute: | | Decoded Time |
| decoded-time/month: | | Decoded Time |
| decoded-time/second: | | Decoded Time |
| decoded-time/time-string: | | External Representation of Time |
| decoded-time/year: | | Decoded Time |
| decoded-time/zone: | | Decoded Time |
| default-comparator: | | SRFI 162 |
| default-hash: | | SRFI 128 |
| default-object?: | | Lambda Expressions |
| default-random-source: | | Random Number Generation |
| default-random-source: | | SRFI 27 |
| define: | | Environment Concepts |
| define: | | Definitions |
| define: | | Definitions |
| define: | | Internal Definitions |
| define: | | Sequencing |
| define: | | Environment Variables |
| define: | | R7RS |
| define: | | SRFI 219 |
| define-*matcher-expander: | | Parser-language Macros |
| define-*matcher-macro: | | Parser-language Macros |
| define-*parser-expander: | | Parser-language Macros |
| define-*parser-macro: | | Parser-language Macros |
| define-print-method: | | Custom Output |
| define-record-type: | | define-record-type (SRFI 9) |
| define-record-type: | | R7RS |
| define-record-type: | | SRFI 9 |
| define-record-type: | | SRFI 131 |
| define-structure: | | Structure Definitions |
| define-structure: | | Records |
| define-syntax: | | Syntactic Binding Constructs |
| define-syntax: | | R7RS |
| define-values: | | R7RS |
| del-assoc: | | Association Lists |
| del-assoc!: | | Association Lists |
| del-assq: | | Association Lists |
| del-assq!: | | Association Lists |
| del-assv: | | Association Lists |
| del-assv!: | | Association Lists |
| delay: | | Lexical Binding |
| delay: | | Promises |
| delay: | | R7RS |
| delay-force: | | R7RS |
| delete: | | Filtering Lists |
| delete: | | SRFI 1 |
| delete!: | | Filtering Lists |
| delete!: | | Filtering Lists |
| delete!: | | SRFI 1 |
| delete-association-procedure: | | Association Lists |
| delete-directory: | | File Manipulation |
| delete-duplicates: | | SRFI 1 |
| delete-duplicates!: | | SRFI 1 |
| delete-file: | | File Manipulation |
| delete-file: | | R7RS |
| delete-file-no-errors: | | File Manipulation |
| delete-member-procedure: | | Filtering Lists |
| delq: | | Filtering Lists |
| delq!: | | Filtering Lists |
| delv: | | Filtering Lists |
| delv: | | Filtering Lists |
| delv!: | | Filtering Lists |
| denominator: | | Numerical operations |
| denominator: | | R7RS |
| digit->char: | | Characters |
| digit-value: | | Characters |
| digit-value: | | R7RS |
| directory-namestring: | | Operations on Pathnames |
| directory-pathname: | | Operations on Pathnames |
| directory-pathname-as-file: | | Operations on Pathnames |
| directory-pathname?: | | Operations on Pathnames |
| directory-read: | | Directory Reader |
| discard-chars on textual input port: | | Textual Input Port Operations |
| discard-matched: | | *Matcher |
| discard-matched: | | *Parser |
| discard-parser-buffer-head!: | | Parser Buffers |
| discretionary-flush-output: | | Output Procedures |
| discretionary-flush-output on textual output port: | | Textual Output Port Operations |
| display: | | Output Procedures |
| display: | | Error Messages |
| display: | | R7RS |
| do: | | Environment Concepts |
| do: | | Sequencing |
| do: | | Iteration |
| do: | | R7RS |
| dotted-list?: | | Selecting List Components |
| dotted-list?: | | SRFI 1 |
| draw-arc: | | Custom Operations on X Graphics Devices |
| draw-arc on x-graphics-device: | | Custom Operations on X Graphics Devices |
| draw-circle: | | Custom Operations on X Graphics Devices |
| draw-circle on x-graphics-device: | | Custom Operations on X Graphics Devices |
| draw-image on graphics-device: | | Images |
| draw-subimage on graphics-device: | | Images |
| drop: | | Selecting List Components |
| drop: | | Cutting and Pasting Lists |
| drop: | | SRFI 1 |
| drop-right: | | SRFI 1 |
| drop-right!: | | SRFI 1 |
| drop-while: | | SRFI 1 |
| dynamic-wind: | | Continuations |
| dynamic-wind: | | R7RS |
|
| E | | |
|---|
| eighth: | | Selecting List Components |
| eighth: | | SRFI 1 |
| else: | | Entry Format |
| else: | | Conditionals |
| else: | | Conditionals |
| else: | | R7RS |
| emergency-exit: | | R7RS |
| encapsulate: | | *Parser |
| end-of-char-set?: | | SRFI 14 |
| end-of-input: | | *Matcher |
| enough-namestring: | | Operations on Pathnames |
| enough-pathname: | | Operations on Pathnames |
| entity-extra: | | Application Hooks |
| entity-procedure: | | Application Hooks |
| entity?: | | Application Hooks |
| enumerate-graphics-types: | | Opening and Closing of Graphics Devices |
| environment: | | Subprocess Options |
| environment: | | R7RS |
| environment-assign!: | | Environment Operations |
| environment-assignable?: | | Environment Operations |
| environment-assigned?: | | Environment Operations |
| environment-bindings: | | Environment Operations |
| environment-bound-names: | | Environment Operations |
| environment-bound?: | | Environment Operations |
| environment-definable?: | | Environment Operations |
| environment-define: | | Environment Operations |
| environment-define-macro: | | Environment Operations |
| environment-has-parent?: | | Environment Operations |
| environment-lookup: | | Environment Operations |
| environment-lookup-macro: | | Environment Operations |
| environment-macro-names: | | Environment Operations |
| environment-parent: | | Environment Operations |
| environment-reference-type: | | Environment Operations |
| environment?: | | Environment Operations |
| eof-object: | | Input Procedures |
| eof-object: | | R7RS |
| eof-object?: | | Input Procedures |
| eof-object?: | | R7RS |
| eof? on textual input port: | | Textual Input Port Operations |
| ephemeron-broken?: | | Ephemerons |
| ephemeron-broken?: | | SRFI 124 |
| ephemeron-datum: | | Ephemerons |
| ephemeron-datum: | | SRFI 124 |
| ephemeron-key: | | Ephemerons |
| ephemeron-key: | | SRFI 124 |
| ephemeron?: | | Ephemerons |
| ephemeron?: | | SRFI 124 |
| epoch: | | Universal Time |
| eq-comparator: | | SRFI 162 |
| eq-hash: | | Construction of Hash Tables |
| eq-hash: | | Address Hashing |
| eq-hash-mod: | | Address Hashing |
| eq?: | | Equivalence Predicates |
| eq?: | | Equivalence Predicates |
| eq?: | | Symbols |
| eq?: | | Symbols |
| eq?: | | Association Lists |
| eq?: | | Association Lists |
| eq?: | | Association Lists |
| eq?: | | The Association Table |
| eq?: | | Construction of Hash Tables |
| eq?: | | Construction of Hash Tables |
| eq?: | | Construction of Hash Tables |
| eq?: | | Construction of Hash Tables |
| eq?: | | Construction of Hash Tables |
| eq?: | | Object Hashing |
| eq?: | | The Named Restart Abstraction |
| eq?: | | R7RS |
| equal-comparator: | | SRFI 162 |
| equal-hash: | | Construction of Hash Tables |
| equal-hash: | | Address Hashing |
| equal-hash-mod: | | Address Hashing |
| equal?: | | Quoting |
| equal?: | | Equivalence Predicates |
| equal?: | | Equivalence Predicates |
| equal?: | | Association Lists |
| equal?: | | Association Lists |
| equal?: | | Association Lists |
| equal?: | | Construction of Hash Tables |
| equal?: | | Construction of Hash Tables |
| equal?: | | R7RS |
| eqv-comparator: | | SRFI 162 |
| eqv-hash: | | Address Hashing |
| eqv-hash-mod: | | Address Hashing |
| eqv?: | | Storage Model |
| eqv?: | | Conditionals |
| eqv?: | | Equivalence Predicates |
| eqv?: | | Equivalence Predicates |
| eqv?: | | Pairs |
| eqv?: | | Association Lists |
| eqv?: | | Association Lists |
| eqv?: | | Association Lists |
| eqv?: | | Construction of Hash Tables |
| eqv?: | | Construction of Hash Tables |
| eqv?: | | Construction of Hash Tables |
| eqv?: | | Construction of Hash Tables |
| eqv?: | | R7RS |
| er-macro-transformer: | | Explicit Renaming |
| error: | | Errors |
| error: | | Error System |
| error: | | Condition Signalling |
| error: | | Condition Signalling |
| error: | | Condition Handling |
| error: | | Condition Handling |
| error: | | R7RS |
| error: | | SRFI 23 |
| error-irritant/noise: | | Error Messages |
| error-object-irritants: | | R7RS |
| error-object-message: | | R7RS |
| error-object?: | | R7RS |
| error:bad-range-argument: | | Taxonomy |
| error:datum-out-of-range: | | Taxonomy |
| error:derived-file: | | Taxonomy |
| error:derived-port: | | Taxonomy |
| error:divide-by-zero: | | Taxonomy |
| error:file-operation: | | Taxonomy |
| error:no-such-restart: | | Taxonomy |
| error:wrong-number-of-arguments: | | Taxonomy |
| error:wrong-type-argument: | | Taxonomy |
| error:wrong-type-datum: | | Taxonomy |
| euclidean-quotient: | | Numerical operations |
| euclidean-remainder: | | Numerical operations |
| euclidean/: | | Numerical operations |
| eval: | | Environment Operations |
| eval: | | R7RS |
| even?: | | Numerical operations |
| even?: | | R7RS |
| every: | | Mapping of Lists |
| every: | | SRFI 1 |
| exact: | | Exactness |
| exact: | | Numerical operations |
| exact: | | R7RS |
| exact->inexact: | | Numerical operations |
| exact-integer-sqrt: | | R7RS |
| exact-integer?: | | Numerical operations |
| exact-integer?: | | R7RS |
| exact-nonnegative-integer?: | | Numerical operations |
| exact-rational?: | | Numerical operations |
| exact?: | | Numerical operations |
| exact?: | | R7RS |
| except-last-pair: | | Cutting and Pasting Lists |
| except-last-pair!: | | Cutting and Pasting Lists |
| exit: | | R7RS |
| exp: | | Numerical operations |
| exp: | | R7RS |
| exp10: | | Numerical operations |
| exp10m1: | | Numerical operations |
| exp2: | | Numerical operations |
| exp2m1: | | Numerical operations |
| expm1: | | Numerical operations |
| export-random-state: | | Random Number Generation |
| expt: | | Numerical operations |
| expt: | | R7RS |
| exsec: | | Numerical operations |
| exsec-pi*: | | Numerical operations |
| extend-top-level-environment: | | Top-level Environments |
| extract-bit: | | Bit operations |
|
| F | | |
|---|
| false: | | Booleans |
| false?: | | Booleans |
| features: | | R7RS |
| fifth: | | Selecting List Components |
| fifth: | | SRFI 1 |
| file-access: | | File Manipulation |
| file-access-time: | | File Manipulation |
| file-access-time-direct: | | File Manipulation |
| file-access-time-indirect: | | File Manipulation |
| file-attributes: | | File Manipulation |
| file-attributes-direct: | | File Manipulation |
| file-attributes-indirect: | | File Manipulation |
| file-attributes/access-time: | | File Manipulation |
| file-attributes/change-time: | | File Manipulation |
| file-attributes/gid: | | File Manipulation |
| file-attributes/inode-number: | | File Manipulation |
| file-attributes/length: | | File Manipulation |
| file-attributes/mode-string: | | File Manipulation |
| file-attributes/modes: | | File Manipulation |
| file-attributes/modification-time: | | File Manipulation |
| file-attributes/n-links: | | File Manipulation |
| file-attributes/type: | | File Manipulation |
| file-attributes/uid: | | File Manipulation |
| file-directory?: | | File Manipulation |
| file-eq?: | | File Manipulation |
| file-error?: | | File Ports |
| file-error?: | | File Ports |
| file-error?: | | File Ports |
| file-error?: | | R7RS |
| file-executable?: | | File Manipulation |
| file-exists-direct?: | | File Manipulation |
| file-exists-indirect?: | | File Manipulation |
| file-exists?: | | File Manipulation |
| file-exists?: | | R7RS |
| file-length: | | File Manipulation |
| file-modes: | | File Manipulation |
| file-modification-time: | | File Manipulation |
| file-modification-time-direct: | | File Manipulation |
| file-modification-time-indirect: | | File Manipulation |
| file-namestring: | | Operations on Pathnames |
| file-pathname: | | Operations on Pathnames |
| file-readable?: | | File Manipulation |
| file-regular?: | | File Manipulation |
| file-symbolic-link?: | | File Manipulation |
| file-time->global-decoded-time: | | Time-Format Conversion |
| file-time->global-time-string: | | Time-Format Conversion |
| file-time->local-decoded-time: | | Time-Format Conversion |
| file-time->local-time-string: | | Time-Format Conversion |
| file-time->universal-time: | | Time-Format Conversion |
| file-touch: | | File Manipulation |
| file-type-direct: | | File Manipulation |
| file-type-indirect: | | File Manipulation |
| file-writeable?: | | File Manipulation |
| fill-circle: | | Custom Operations on X Graphics Devices |
| fill-circle on x-graphics-device: | | Custom Operations on X Graphics Devices |
| fill-with: | | Strings |
| filter: | | Filtering Lists |
| filter: | | SRFI 1 |
| filter!: | | Filtering Lists |
| filter!: | | SRFI 1 |
| filter-map: | | SRFI 1 |
| find: | | Searching Lists |
| find: | | SRFI 1 |
| find-restart: | | Restarts |
| find-restart: | | Finding and Invoking General Restart Code |
| find-restart: | | Finding and Invoking General Restart Code |
| find-tail: | | Searching Lists |
| find-tail: | | SRFI 1 |
| finite?: | | R7RS |
| first: | | Selecting List Components |
| first: | | SRFI 1 |
| first-set-bit: | | Bit operations |
| fix:*: | | Fixnum Operations |
| fix:+: | | Fixnum Operations |
| fix:-: | | Fixnum Operations |
| fix:-1+: | | Fixnum Operations |
| fix:1+: | | Fixnum Operations |
| fix:<: | | Fixnum Operations |
| fix:<=: | | Fixnum Operations |
| fix:=: | | Fixnum Operations |
| fix:>: | | Fixnum Operations |
| fix:>=: | | Fixnum Operations |
| fix:and: | | Fixnum Operations |
| fix:andc: | | Fixnum Operations |
| fix:divide: | | Fixnum Operations |
| fix:fixnum?: | | Fixnum Operations |
| fix:gcd: | | Fixnum Operations |
| fix:lsh: | | Fixnum Operations |
| fix:negative?: | | Fixnum Operations |
| fix:not: | | Fixnum Operations |
| fix:or: | | Fixnum Operations |
| fix:positive?: | | Fixnum Operations |
| fix:quotient: | | Fixnum Operations |
| fix:remainder: | | Fixnum Operations |
| fix:xor: | | Fixnum Operations |
| fix:zero?: | | Fixnum Operations |
| fixnum?: | | SRFI 143 |
| flo:*: | | Flonum Operations |
| flo:*+: | | Flonum Operations |
| flo:*-: | | Flonum Operations |
| flo:+: | | Flonum Operations |
| flo:-: | | Flonum Operations |
| flo:/: | | Flonum Operations |
| flo:<: | | Flonum Operations |
| flo:<=: | | Flonum Operations |
| flo:<>: | | Flonum Operations |
| flo:=: | | Flonum Operations |
| flo:>: | | Flonum Operations |
| flo:>=: | | Flonum Operations |
| flo:abs: | | Flonum Operations |
| flo:acos: | | Flonum Operations |
| flo:acos/pi: | | Flonum Operations |
| flo:acosh: | | Flonum Operations |
| flo:aexsec: | | Flonum Operations |
| flo:aexsec/pi: | | Flonum Operations |
| flo:asin: | | Flonum Operations |
| flo:asin/pi: | | Flonum Operations |
| flo:asinh: | | Flonum Operations |
| flo:atan: | | Flonum Operations |
| flo:atan/pi: | | Flonum Operations |
| flo:atan2: | | Flonum Operations |
| flo:atan2/pi: | | Flonum Operations |
| flo:atanh: | | Flonum Operations |
| flo:aversin: | | Flonum Operations |
| flo:aversin/pi: | | Flonum Operations |
| flo:cbrt: | | Flonum Operations |
| flo:ceiling: | | Flonum Operations |
| flo:ceiling->exact: | | Flonum Operations |
| flo:classify: | | Flonum Operations |
| flo:clear-exceptions!: | | Floating-Point Exceptions |
| flo:compound: | | Flonum Operations |
| flo:compoundm1: | | Flonum Operations |
| flo:copysign: | | Flonum Operations |
| flo:cos: | | Flonum Operations |
| flo:cos-pi*: | | Flonum Operations |
| flo:cosh: | | Flonum Operations |
| flo:default-environment: | | Floating-Point Environment |
| flo:default-rounding-mode: | | Floating-Point Rounding Mode |
| flo:default-trapped-exceptions: | | Floating-Point Exceptions |
| flo:defer-exception-traps!: | | Floating-Point Exceptions |
| flo:deferring-exception-traps: | | Floating-Point Exceptions |
| flo:environment: | | Floating-Point Environment |
| flo:erf: | | Flonum Operations |
| flo:erfc: | | Flonum Operations |
| flo:error-bound: | | Flonum Operations |
| flo:exception:divide-by-zero: | | Floating-Point Exceptions |
| flo:exception:inexact-result: | | Floating-Point Exceptions |
| flo:exception:invalid-operation: | | Floating-Point Exceptions |
| flo:exception:overflow: | | Floating-Point Exceptions |
| flo:exception:subnormal-operand: | | Floating-Point Exceptions |
| flo:exception:underflow: | | Floating-Point Exceptions |
| flo:exceptions->names: | | Floating-Point Exceptions |
| flo:exp: | | Flonum Operations |
| flo:exp10: | | Flonum Operations |
| flo:exp10m1: | | Flonum Operations |
| flo:exp2: | | Flonum Operations |
| flo:exp2m1: | | Flonum Operations |
| flo:expm1: | | Flonum Operations |
| flo:expt: | | Flonum Operations |
| flo:exsec: | | Flonum Operations |
| flo:exsec-pi*: | | Flonum Operations |
| flo:fast-fma?: | | Flonum Operations |
| flo:finite?: | | Flonum Operations |
| flo:flonum?: | | Flonum Operations |
| flo:floor: | | Flonum Operations |
| flo:floor->exact: | | Flonum Operations |
| flo:fma: | | Flonum Operations |
| flo:gamma: | | Flonum Operations |
| flo:greatest-normal-exponent-base-10: | | Flonum Operations |
| flo:greatest-normal-exponent-base-2: | | Flonum Operations |
| flo:greatest-normal-exponent-base-e: | | Flonum Operations |
| flo:have-trap-enable/disable?: | | Floating-Point Exceptions |
| flo:hypot: | | Flonum Operations |
| flo:ignoring-exception-traps: | | Floating-Point Exceptions |
| flo:infinite?: | | Flonum Operations |
| flo:j0: | | Flonum Operations |
| flo:j1: | | Flonum Operations |
| flo:jn: | | Flonum Operations |
| flo:largest-positive-normal: | | Flonum Operations |
| flo:ldexp: | | Flonum Operations |
| flo:least-normal-exponent-base-10: | | Flonum Operations |
| flo:least-normal-exponent-base-2: | | Flonum Operations |
| flo:least-normal-exponent-base-e: | | Flonum Operations |
| flo:least-subnormal-exponent-base-10: | | Flonum Operations |
| flo:least-subnormal-exponent-base-2: | | Flonum Operations |
| flo:least-subnormal-exponent-base-e: | | Flonum Operations |
| flo:lgamma: | | Flonum Operations |
| flo:log: | | Flonum Operations |
| flo:log-error-bound: | | Flonum Operations |
| flo:log-ulp-of-one: | | Flonum Operations |
| flo:log10: | | Flonum Operations |
| flo:log10p1: | | Flonum Operations |
| flo:log1p: | | Flonum Operations |
| flo:log2: | | Flonum Operations |
| flo:log2p1: | | Flonum Operations |
| flo:logb: | | Flonum Operations |
| flo:logp1: | | Flonum Operations |
| flo:make-nan: | | Flonum Operations |
| flo:max: | | Flonum Operations |
| flo:max-mag: | | Flonum Operations |
| flo:max-mag-num: | | Flonum Operations |
| flo:max-num: | | Flonum Operations |
| flo:min: | | Flonum Operations |
| flo:min-mag: | | Flonum Operations |
| flo:min-mag-num: | | Flonum Operations |
| flo:min-num: | | Flonum Operations |
| flo:names->exceptions: | | Floating-Point Exceptions |
| flo:nan-payload: | | Flonum Operations |
| flo:nan-quiet?: | | Flonum Operations |
| flo:nan?: | | Flonum Operations |
| flo:negate: | | Flonum Operations |
| flo:negative?: | | Flonum Operations |
| flo:nextafter: | | Flonum Operations |
| flo:normal-exponent-max: | | Flonum Operations |
| flo:normal-exponent-min: | | Flonum Operations |
| flo:normal?: | | Flonum Operations |
| flo:positive?: | | Flonum Operations |
| flo:precision: | | Flonum Operations |
| flo:preserving-environment: | | Floating-Point Environment |
| flo:radix: | | Flonum Operations |
| flo:radix.: | | Flonum Operations |
| flo:raise-exceptions!: | | Floating-Point Exceptions |
| flo:random-unit: | | Random Number Generation |
| flo:random-unit-closed: | | Random Number Generation |
| flo:random-unit-open: | | Random Number Generation |
| flo:restore-exception-flags!: | | Floating-Point Exceptions |
| flo:round: | | Flonum Operations |
| flo:round->exact: | | Flonum Operations |
| flo:rounding-mode: | | Floating-Point Rounding Mode |
| flo:rounding-modes: | | Floating-Point Rounding Mode |
| flo:rsqrt: | | Flonum Operations |
| flo:safe-zero?: | | Flonum Operations |
| flo:safe<: | | Flonum Operations |
| flo:safe<=: | | Flonum Operations |
| flo:safe<>: | | Flonum Operations |
| flo:safe=: | | Flonum Operations |
| flo:safe>: | | Flonum Operations |
| flo:safe>=: | | Flonum Operations |
| flo:save-exception-flags: | | Floating-Point Exceptions |
| flo:scalbn: | | Flonum Operations |
| flo:set-environment!: | | Floating-Point Environment |
| flo:set-rounding-mode!: | | Floating-Point Rounding Mode |
| flo:set-trapped-exceptions!: | | Floating-Point Exceptions |
| flo:sign-negative?: | | Flonum Operations |
| flo:signed-lgamma: | | Flonum Operations |
| flo:sin: | | Flonum Operations |
| flo:sin-pi*: | | Flonum Operations |
| flo:sinh: | | Flonum Operations |
| flo:smallest-positive-normal: | | Flonum Operations |
| flo:smallest-positive-subnormal: | | Flonum Operations |
| flo:sqrt: | | Flonum Operations |
| flo:sqrt1pm1: | | Flonum Operations |
| flo:subnormal-exponent-min: | | Flonum Operations |
| flo:subnormal?: | | Flonum Operations |
| flo:supported-exceptions: | | Floating-Point Exceptions |
| flo:tan: | | Flonum Operations |
| flo:tan-pi*: | | Flonum Operations |
| flo:tanh: | | Flonum Operations |
| flo:test-exception-flags: | | Floating-Point Exceptions |
| flo:test-exceptions: | | Floating-Point Exceptions |
| flo:total-mag<: | | Flonum Operations |
| flo:total-order: | | Flonum Operations |
| flo:total-order-mag: | | Flonum Operations |
| flo:total<: | | Flonum Operations |
| flo:trap-exceptions!: | | Floating-Point Exceptions |
| flo:trappable-exceptions: | | Floating-Point Exceptions |
| flo:trapped-exceptions: | | Floating-Point Exceptions |
| flo:truncate: | | Flonum Operations |
| flo:truncate->exact: | | Flonum Operations |
| flo:ulp: | | Flonum Operations |
| flo:ulp-of-one: | | Flonum Operations |
| flo:unordered?: | | Flonum Operations |
| flo:untrap-exceptions!: | | Floating-Point Exceptions |
| flo:update-environment!: | | Floating-Point Environment |
| flo:versin: | | Flonum Operations |
| flo:versin-pi*: | | Flonum Operations |
| flo:with-default-environment: | | Floating-Point Environment |
| flo:with-exceptions-trapped: | | Floating-Point Exceptions |
| flo:with-exceptions-untrapped: | | Floating-Point Exceptions |
| flo:with-rounding-mode: | | Floating-Point Rounding Mode |
| flo:with-trapped-exceptions: | | Floating-Point Exceptions |
| flo:y0: | | Flonum Operations |
| flo:y1: | | Flonum Operations |
| flo:yn: | | Flonum Operations |
| flo:zero?: | | Flonum Operations |
| flonum-parser-fast?: | | Numerical input and output |
| flonum-unparser-cutoff: | | Numerical input and output |
| floor: | | Numerical operations |
| floor: | | R7RS |
| floor->exact: | | Numerical operations |
| floor-quotient: | | Numerical operations |
| floor-quotient: | | R7RS |
| floor-remainder: | | Numerical operations |
| floor-remainder: | | R7RS |
| floor/: | | Numerical operations |
| floor/: | | R7RS |
| fluid-let: | | Dynamic Binding |
| flush-output: | | Output Procedures |
| flush-output on textual output port: | | Textual Output Port Operations |
| flush-output-port: | | Output Procedures |
| flush-output-port: | | Output Procedures |
| flush-output-port: | | R7RS |
| fold: | | Folding of Lists |
| fold: | | SRFI 1 |
| fold-left: | | Folding of Lists |
| fold-right: | | Folding of Lists |
| fold-right: | | SRFI 1 |
| font-structure on x-graphics-device: | | Custom Operations on X Graphics Devices |
| for-each: | | Mapping of Lists |
| for-each: | | R7RS |
| for-each: | | SRFI 1 |
| force: | | Promises |
| force: | | Streams |
| force: | | R7RS |
| format: | | Format |
| format-error-message: | | Error Messages |
| fourth: | | Selecting List Components |
| fourth: | | SRFI 1 |
| fresh-line: | | Output Procedures |
| fresh-line on textual output port: | | Textual Output Port Operations |
| fx*: | | SRFI 143 |
| fx*/carry: | | SRFI 143 |
| fx+: | | SRFI 143 |
| fx+/carry: | | SRFI 143 |
| fx-: | | SRFI 143 |
| fx-/carry: | | SRFI 143 |
| fx-greatest: | | SRFI 143 |
| fx-least: | | SRFI 143 |
| fx-width: | | SRFI 143 |
| fx<=?: | | SRFI 143 |
| fx<?: | | SRFI 143 |
| fx=?: | | SRFI 143 |
| fx>=?: | | SRFI 143 |
| fx>?: | | SRFI 143 |
| fxabs: | | SRFI 143 |
| fxand: | | SRFI 143 |
| fxarithmetic-shift: | | SRFI 143 |
| fxarithmetic-shift-left: | | SRFI 143 |
| fxarithmetic-shift-right: | | SRFI 143 |
| fxbit-count: | | SRFI 143 |
| fxbit-field: | | SRFI 143 |
| fxbit-field-reverse: | | SRFI 143 |
| fxbit-field-rotate: | | SRFI 143 |
| fxbit-set?: | | SRFI 143 |
| fxcopy-bit: | | SRFI 143 |
| fxeven?: | | SRFI 143 |
| fxfirst-set-bit: | | SRFI 143 |
| fxif: | | SRFI 143 |
| fxior: | | SRFI 143 |
| fxlength: | | SRFI 143 |
| fxmax: | | SRFI 143 |
| fxmin: | | SRFI 143 |
| fxneg: | | SRFI 143 |
| fxnegative?: | | SRFI 143 |
| fxnot: | | SRFI 143 |
| fxodd?: | | SRFI 143 |
| fxpositive?: | | SRFI 143 |
| fxquotient: | | SRFI 143 |
| fxremainder: | | SRFI 143 |
| fxsqrt: | | SRFI 143 |
| fxsquare: | | SRFI 143 |
| fxxor: | | SRFI 143 |
| fxzero?: | | SRFI 143 |
|
| G | | |
|---|
| gappend: | | SRFI 158 |
| gc-reclaimed-object: | | Weak Pairs |
| gc-reclaimed-object?: | | Weak Pairs |
| gcd: | | Numerical operations |
| gcd: | | R7RS |
| gcombine: | | SRFI 158 |
| gcons*: | | SRFI 158 |
| gdelete: | | SRFI 158 |
| gdelete-neighbor-dups: | | SRFI 158 |
| gdrop: | | SRFI 158 |
| gdrop-while: | | SRFI 158 |
| ge: | | Initial and Current Environments |
| ge: | | REPL Environment |
| general-car-cdr: | | Pairs |
| generate-uninterned-symbol: | | Symbols |
| generator: | | SRFI 158 |
| generator->list: | | SRFI 158 |
| generator->reverse-list: | | SRFI 158 |
| generator->string: | | SRFI 158 |
| generator->vector: | | SRFI 158 |
| generator->vector!: | | SRFI 158 |
| generator-any: | | SRFI 158 |
| generator-count: | | SRFI 158 |
| generator-every: | | SRFI 158 |
| generator-find: | | SRFI 158 |
| generator-fold: | | SRFI 158 |
| generator-for-each: | | SRFI 158 |
| generator-map->list: | | SRFI 158 |
| generator-unfold: | | SRFI 158 |
| get-default on x-graphics-device: | | Custom Operations on X Graphics Devices |
| get-environment-variable: | | R7RS |
| get-environment-variables: | | R7RS |
| get-host-by-address: | | Miscellaneous OS Facilities |
| get-host-by-name: | | Miscellaneous OS Facilities |
| get-host-name: | | Miscellaneous OS Facilities |
| get-output-bytevector: | | Bytevector Ports |
| get-output-bytevector: | | Bytevector Ports |
| get-output-bytevector: | | R7RS |
| get-output-string: | | String Ports |
| get-output-string: | | String Ports |
| get-output-string: | | R7RS |
| get-parser-buffer-pointer: | | Parser Buffers |
| get-parser-buffer-tail: | | Parser Buffers |
| get-universal-time: | | Universal Time |
| gfilter: | | SRFI 158 |
| gflatten: | | SRFI 158 |
| ggroup: | | SRFI 158 |
| gindex: | | SRFI 158 |
| global-decoded-time: | | Decoded Time |
| global-parser-macros: | | Parser-language Macros |
| gmap: | | SRFI 158 |
| gmerge: | | SRFI 158 |
| grapheme-cluster-length: | | Strings |
| grapheme-cluster-slice: | | Strings |
| graphics-bind-drawing-mode: | | Characteristics of Graphics Output |
| graphics-bind-line-style: | | Characteristics of Graphics Output |
| graphics-clear: | | Drawing Graphics |
| graphics-clear: | | Custom Operations on X Graphics Devices |
| graphics-clear: | | Custom Operations on X Graphics Devices |
| graphics-close: | | Opening and Closing of Graphics Devices |
| graphics-coordinate-limits: | | Coordinates for Graphics |
| graphics-device-coordinate-limits: | | Coordinates for Graphics |
| graphics-disable-buffering: | | Buffering of Graphics Output |
| graphics-drag-cursor: | | Drawing Graphics |
| graphics-draw-line: | | Drawing Graphics |
| graphics-draw-point: | | Drawing Graphics |
| graphics-draw-text: | | Drawing Graphics |
| graphics-enable-buffering: | | Buffering of Graphics Output |
| graphics-erase-point: | | Drawing Graphics |
| graphics-flush: | | Buffering of Graphics Output |
| graphics-move-cursor: | | Drawing Graphics |
| graphics-operation: | | Custom Graphics Operations |
| graphics-reset-clip-rectangle: | | Clipping of Graphics Output |
| graphics-set-clip-rectangle: | | Clipping of Graphics Output |
| graphics-set-coordinate-limits: | | Coordinates for Graphics |
| graphics-set-drawing-mode: | | Characteristics of Graphics Output |
| graphics-set-line-style: | | Characteristics of Graphics Output |
| graphics-type-available?: | | Opening and Closing of Graphics Devices |
| gremove: | | SRFI 158 |
| group: | | Regular S-Expressions |
| group-ref: | | Regular S-Expressions |
| gselect: | | SRFI 158 |
| gstate-filter: | | SRFI 158 |
| gtake: | | SRFI 158 |
| gtake-while: | | SRFI 158 |
| guarantee-procedure-of-arity: | | Arity |
| guard: | | R7RS |
|
| H | | |
|---|
| hamming-distance: | | Bit operations |
| hard-link-file: | | File Manipulation |
| hash: | | Address Hashing |
| hash: | | Object Hashing |
| hash: | | SRFI 69 |
| hash: | | SRFI 125 |
| hash-bound: | | SRFI 128 |
| hash-by-eqv: | | Address Hashing |
| hash-by-identity: | | Address Hashing |
| hash-by-identity: | | SRFI 69 |
| hash-by-identity: | | SRFI 125 |
| hash-object: | | Object Hashing |
| hash-salt: | | SRFI 128 |
| hash-table: | | SRFI 125 |
| hash-table->alist: | | Basic Hash Table Operations |
| hash-table->alist: | | SRFI 69 |
| hash-table->alist: | | SRFI 125 |
| hash-table-clean!: | | Basic Hash Table Operations |
| hash-table-clear!: | | Basic Hash Table Operations |
| hash-table-clear!: | | SRFI 125 |
| hash-table-constructor: | | Construction of Hash Tables |
| hash-table-constructor: | | Construction of Hash Tables |
| hash-table-contains?: | | SRFI 125 |
| hash-table-copy: | | SRFI 69 |
| hash-table-copy: | | SRFI 125 |
| hash-table-count: | | SRFI 125 |
| hash-table-delete!: | | Basic Hash Table Operations |
| hash-table-delete!: | | SRFI 69 |
| hash-table-delete!: | | SRFI 125 |
| hash-table-difference!: | | SRFI 125 |
| hash-table-empty-copy: | | SRFI 125 |
| hash-table-empty?: | | SRFI 125 |
| hash-table-entries: | | SRFI 125 |
| hash-table-entry-type:datum-ephemeral: | | Construction of Hash Tables |
| hash-table-entry-type:datum-weak: | | Construction of Hash Tables |
| hash-table-entry-type:key&datum-ephemeral: | | Construction of Hash Tables |
| hash-table-entry-type:key&datum-weak: | | Construction of Hash Tables |
| hash-table-entry-type:key-ephemeral: | | Construction of Hash Tables |
| hash-table-entry-type:key-weak: | | Construction of Hash Tables |
| hash-table-entry-type:key/datum-weak: | | Construction of Hash Tables |
| hash-table-entry-type:strong: | | Construction of Hash Tables |
| hash-table-equivalence-function: | | SRFI 69 |
| hash-table-equivalence-function: | | SRFI 125 |
| hash-table-exists?: | | SRFI 69 |
| hash-table-exists?: | | SRFI 125 |
| hash-table-find: | | SRFI 125 |
| hash-table-fold: | | SRFI 69 |
| hash-table-fold: | | SRFI 125 |
| hash-table-for-each: | | SRFI 125 |
| hash-table-grow-size: | | Resizing of Hash Tables |
| hash-table-hash-function: | | SRFI 69 |
| hash-table-hash-function: | | SRFI 125 |
| hash-table-intern!: | | Basic Hash Table Operations |
| hash-table-intern!: | | SRFI 125 |
| hash-table-intersection!: | | SRFI 125 |
| hash-table-keys: | | Basic Hash Table Operations |
| hash-table-keys: | | SRFI 69 |
| hash-table-keys: | | SRFI 125 |
| hash-table-map: | | SRFI 125 |
| hash-table-map!: | | SRFI 125 |
| hash-table-map->list: | | SRFI 125 |
| hash-table-merge!: | | SRFI 69 |
| hash-table-merge!: | | SRFI 125 |
| hash-table-mutable?: | | SRFI 125 |
| hash-table-pop!: | | SRFI 125 |
| hash-table-prune!: | | SRFI 125 |
| hash-table-ref: | | Basic Hash Table Operations |
| hash-table-ref: | | SRFI 69 |
| hash-table-ref: | | SRFI 125 |
| hash-table-ref/default: | | Basic Hash Table Operations |
| hash-table-ref/default: | | SRFI 69 |
| hash-table-ref/default: | | SRFI 125 |
| hash-table-rehash-size: | | Resizing of Hash Tables |
| hash-table-rehash-threshold: | | Resizing of Hash Tables |
| hash-table-set!: | | Basic Hash Table Operations |
| hash-table-set!: | | SRFI 69 |
| hash-table-set!: | | SRFI 125 |
| hash-table-shrink-size: | | Resizing of Hash Tables |
| hash-table-size: | | Basic Hash Table Operations |
| hash-table-size: | | SRFI 69 |
| hash-table-size: | | SRFI 125 |
| hash-table-unfold: | | SRFI 125 |
| hash-table-union!: | | SRFI 125 |
| hash-table-update!: | | Basic Hash Table Operations |
| hash-table-update!: | | SRFI 69 |
| hash-table-update!: | | SRFI 125 |
| hash-table-update!/default: | | Basic Hash Table Operations |
| hash-table-update!/default: | | SRFI 69 |
| hash-table-update!/default: | | SRFI 125 |
| hash-table-values: | | Basic Hash Table Operations |
| hash-table-values: | | SRFI 69 |
| hash-table-values: | | SRFI 125 |
| hash-table-walk: | | Basic Hash Table Operations |
| hash-table-walk: | | SRFI 69 |
| hash-table-walk: | | SRFI 125 |
| hash-table-xor!: | | SRFI 125 |
| hash-table/clean!: | | Basic Hash Table Operations |
| hash-table/clear!: | | Basic Hash Table Operations |
| hash-table/constructor: | | Construction of Hash Tables |
| hash-table/count: | | Basic Hash Table Operations |
| hash-table/datum-list: | | Basic Hash Table Operations |
| hash-table/for-each: | | Basic Hash Table Operations |
| hash-table/get: | | Basic Hash Table Operations |
| hash-table/intern!: | | Basic Hash Table Operations |
| hash-table/key-list: | | Basic Hash Table Operations |
| hash-table/lookup: | | Basic Hash Table Operations |
| hash-table/make: | | Object Hashing |
| hash-table/modify!: | | Basic Hash Table Operations |
| hash-table/put!: | | Basic Hash Table Operations |
| hash-table/rehash-size: | | Resizing of Hash Tables |
| hash-table/rehash-threshold: | | Resizing of Hash Tables |
| hash-table/remove!: | | Basic Hash Table Operations |
| hash-table/size: | | Resizing of Hash Tables |
| hash-table=?: | | SRFI 125 |
| hash-table?: | | Basic Hash Table Operations |
| hash-table?: | | SRFI 69 |
| hash-table?: | | SRFI 125 |
| host-address-any: | | Miscellaneous OS Facilities |
| host-address-loopback: | | Miscellaneous OS Facilities |
| host-namestring: | | Operations on Pathnames |
| host=?: | | Miscellaneous Pathnames |
| host?: | | Miscellaneous Pathnames |
|
| I | | |
|---|
| i/o-port-type?: | | Textual Port Types |
| i/o-port?: | | Ports |
| identifier=?: | | SC Identifiers |
| identifier?: | | SC Identifiers |
| if: | | Conditionals |
| if: | | Booleans |
| if: | | R7RS |
| ignore-error: | | Condition Handling |
| ignore-errors: | | Condition Handling |
| imag-part: | | Numerical operations |
| imag-part: | | R7RS |
| image/destroy: | | Images |
| image/fill-from-byte-vector: | | Images |
| image/height: | | Images |
| image/width: | | Images |
| image?: | | Images |
| implementation-name: | | SRFI 112 |
| implementation-version: | | SRFI 112 |
| implemented-primitive-procedure?: | | Primitive Procedures |
| import-random-state: | | Random Number Generation |
| include: | | R7RS |
| include-ci: | | R7RS |
| inexact: | | Numerical operations |
| inexact: | | R7RS |
| inexact->exact: | | Numerical operations |
| inexact?: | | Numerical operations |
| inexact?: | | R7RS |
| infinite?: | | R7RS |
| init-file-pathname: | | Miscellaneous Pathnames |
| initial-offset: | | Structure Definitions |
| input: | | Subprocess Options |
| input-buffer-size: | | Subprocess Options |
| input-buffer-size on textual input port: | | Textual Input Port Operations |
| input-line-translation: | | Subprocess Options |
| input-port->parser-buffer: | | Parser Buffers |
| input-port-blocking-mode: | | Blocking Mode |
| input-port-open?: | | Ports |
| input-port-open?: | | R7RS |
| input-port-terminal-mode: | | Terminal Mode |
| input-port-type?: | | Textual Port Types |
| input-port/char-ready?: | | Textual Input Port Operations |
| input-port/discard-chars: | | Textual Input Port Operations |
| input-port/peek-char: | | Textual Input Port Operations |
| input-port/read-char: | | Textual Input Port Operations |
| input-port/read-string: | | Textual Input Port Operations |
| input-port/read-substring: | | Textual Input Port Operations |
| input-port?: | | Ports |
| input-port?: | | R7RS |
| integer->char: | | Characters |
| integer->char: | | R7RS |
| integer-ceiling: | | Numerical operations |
| integer-divide: | | Numerical operations |
| integer-divide: | | Fixnum Operations |
| integer-divide-quotient: | | Numerical operations |
| integer-divide-quotient: | | Fixnum Operations |
| integer-divide-remainder: | | Numerical operations |
| integer-divide-remainder: | | Fixnum Operations |
| integer-floor: | | Numerical operations |
| integer-length: | | Bit operations |
| integer-round: | | Numerical operations |
| integer-truncate: | | Numerical operations |
| integer?: | | Numerical operations |
| integer?: | | R7RS |
| interaction-environment: | | R7RS |
| interaction-i/o-port: | | Ports |
| interaction-i/o-port: | | Prompting |
| intern: | | Symbols |
| intern-soft: | | Symbols |
| internal-time/seconds->ticks: | | Machine Time |
| internal-time/ticks->seconds: | | Machine Time |
| interpreter-environment?: | | Top-level Environments |
| invoke-restart: | | Restarts |
| invoke-restart: | | Establishing Restart Code |
| invoke-restart: | | Finding and Invoking General Restart Code |
| invoke-restart: | | Finding and Invoking General Restart Code |
| invoke-restart: | | The Named Restart Abstraction |
| invoke-restart-interactively: | | Restarts |
| invoke-restart-interactively: | | Finding and Invoking General Restart Code |
| invoke-restart-interactively: | | Finding and Invoking General Restart Code |
| invoke-restart-interactively: | | Finding and Invoking General Restart Code |
| invoke-restart-interactively: | | The Named Restart Abstraction |
| invoke-restart-interactively: | | The Named Restart Abstraction |
| iota: | | Construction of Lists |
| iota: | | SRFI 1 |
| istring?: | | SRFI 140 |
|
| J | | |
|---|
| jiffies-per-second: | | R7RS |
|
| K | | |
|---|
| keyword-constructor: | | Structure Definitions |
|
| L | | |
|---|
| lambda: | | Entry Format |
| lambda: | | Static Scoping |
| lambda: | | Additional Notations |
| lambda: | | Procedure Call Syntax |
| lambda: | | Lambda Expressions |
| lambda: | | Lexical Binding |
| lambda: | | Definitions |
| lambda: | | Internal Definitions |
| lambda: | | Sequencing |
| lambda: | | Procedures |
| lambda: | | R7RS |
| last: | | Cutting and Pasting Lists |
| last: | | SRFI 1 |
| last-pair: | | Cutting and Pasting Lists |
| last-pair: | | SRFI 1 |
| lcm: | | Numerical operations |
| lcm: | | R7RS |
| leading: | | Strings |
| leading: | | Strings |
| length: | | Implementation restrictions |
| length: | | Selecting List Components |
| length: | | R7RS |
| length: | | SRFI 1 |
| length+: | | Selecting List Components |
| length+: | | SRFI 1 |
| let: | | Environment Concepts |
| let: | | Lexical Binding |
| let: | | Dynamic Binding |
| let: | | Definitions |
| let: | | Internal Definitions |
| let: | | Sequencing |
| let: | | Iteration |
| let: | | R7RS |
| let*: | | Environment Concepts |
| let*: | | Lexical Binding |
| let*: | | Definitions |
| let*: | | Internal Definitions |
| let*: | | Sequencing |
| let*: | | R7RS |
| let*-syntax: | | Syntactic Binding Constructs |
| let*-values: | | Lexical Binding |
| let*-values: | | Definitions |
| let*-values: | | Internal Definitions |
| let*-values: | | Sequencing |
| let*-values: | | R7RS |
| let-syntax: | | Syntactic Binding Constructs |
| let-syntax: | | R7RS |
| let-values: | | Lexical Binding |
| let-values: | | Definitions |
| let-values: | | Internal Definitions |
| let-values: | | Sequencing |
| let-values: | | R7RS |
| letrec: | | Environment Concepts |
| letrec: | | Lexical Binding |
| letrec: | | Definitions |
| letrec: | | Internal Definitions |
| letrec: | | Internal Definitions |
| letrec: | | Sequencing |
| letrec: | | R7RS |
| letrec*: | | Lexical Binding |
| letrec*: | | Definitions |
| letrec*: | | Internal Definitions |
| letrec*: | | Sequencing |
| letrec*: | | R7RS |
| letrec-syntax: | | Syntactic Binding Constructs |
| letrec-syntax: | | R7RS |
| line-end: | | Regular S-Expressions |
| line-start: | | Regular S-Expressions |
| link-variables: | | Top-level Environments |
| list: | | Entry Format |
| list: | | Construction of Lists |
| list: | | Construction of Lists |
| list: | | Miscellaneous List Operations |
| list: | | Construction of Vectors |
| list: | | String Ports |
| list: | | R7RS |
| list: | | SRFI 1 |
| list->char-set: | | SRFI 14 |
| list->char-set!: | | SRFI 14 |
| list->generator: | | SRFI 158 |
| list->stream: | | Streams |
| list->string: | | Strings |
| list->string: | | R7RS |
| list->string: | | SRFI 140 |
| list->vector: | | Construction of Lists |
| list->vector: | | Construction of Vectors |
| list->vector: | | R7RS |
| list-accumulator: | | SRFI 158 |
| list-comparator: | | SRFI 162 |
| list-copy: | | Construction of Lists |
| list-copy: | | Association Lists |
| list-copy: | | R7RS |
| list-copy: | | SRFI 1 |
| list-deletor: | | Filtering Lists |
| list-deletor: | | Filtering Lists |
| list-deletor: | | Association Lists |
| list-deletor!: | | Filtering Lists |
| list-deletor!: | | Filtering Lists |
| list-deletor!: | | Association Lists |
| list-head: | | Cutting and Pasting Lists |
| list-index: | | SRFI 1 |
| list-ref: | | Selecting List Components |
| list-ref: | | R7RS |
| list-ref: | | SRFI 1 |
| list-set!: | | R7RS |
| list-tabulate: | | Construction of Lists |
| list-tabulate: | | SRFI 1 |
| list-tail: | | Cutting and Pasting Lists |
| list-tail: | | R7RS |
| list=: | | SRFI 1 |
| list?: | | Selecting List Components |
| list?: | | Association Lists |
| list?: | | 1D Tables |
| list?: | | R7RS |
| load: | | R7RS |
| load-option: | | Format |
| load-option: | | Parser Language |
| load-option: | | XML Support |
| local-decoded-time: | | Decoded Time |
| local-host: | | Miscellaneous Pathnames |
| log: | | Numerical operations |
| log: | | R7RS |
| log-logistic: | | Numerical operations |
| log10: | | Numerical operations |
| log10p1: | | Numerical operations |
| log1mexp: | | Numerical operations |
| log1p: | | Numerical operations |
| log1pexp: | | Numerical operations |
| log2: | | Numerical operations |
| log2p1: | | Numerical operations |
| logistic: | | Numerical operations |
| logistic-1/2: | | Numerical operations |
| logit: | | Numerical operations |
| logit-exp: | | Numerical operations |
| logit1/2+: | | Numerical operations |
| logp1: | | Numerical operations |
| logsumexp: | | Numerical operations |
| lset-adjoin: | | SRFI 1 |
| lset-diff+intersection: | | SRFI 1 |
| lset-diff+intersection!: | | SRFI 1 |
| lset-difference: | | SRFI 1 |
| lset-difference!: | | SRFI 1 |
| lset-intersection: | | SRFI 1 |
| lset-intersection!: | | SRFI 1 |
| lset-union: | | SRFI 1 |
| lset-union!: | | SRFI 1 |
| lset-xor: | | SRFI 1 |
| lset-xor!: | | SRFI 1 |
| lset<=: | | SRFI 1 |
| lset=: | | SRFI 1 |
|
| M | | |
|---|
| machine-name: | | SRFI 112 |
| magnitude: | | Numerical operations |
| magnitude: | | R7RS |
| make-1d-table: | | 1D Tables |
| make-accumulator: | | SRFI 158 |
| make-amap: | | Amap constructors |
| make-apply-hook: | | Application Hooks |
| make-bit-string: | | Construction of Bit Strings |
| make-bytevector: | | R7RS |
| make-cell: | | Parameters |
| make-char: | | Character implementation |
| make-circular-list: | | Miscellaneous List Operations |
| make-comparator: | | SRFI 128 |
| make-condition: | | Condition Signalling |
| make-condition: | | Condition Signalling |
| make-condition: | | Simple Condition Instance Operations |
| make-condition-type: | | Condition Types |
| make-coroutine-generator: | | SRFI 158 |
| make-datum-weak-eq-hash-table: | | Construction of Hash Tables |
| make-datum-weak-eqv-hash-table: | | Construction of Hash Tables |
| make-decoded-time: | | Decoded Time |
| make-default-comparator: | | SRFI 128 |
| make-directory: | | File Manipulation |
| make-entity: | | Application Hooks |
| make-ephemeron: | | Ephemerons |
| make-ephemeron: | | SRFI 124 |
| make-eq-comparator: | | SRFI 128 |
| make-eq-hash-table: | | Construction of Hash Tables |
| make-equal-comparator: | | SRFI 128 |
| make-equal-hash-table: | | Construction of Hash Tables |
| make-eqv-comparator: | | SRFI 128 |
| make-eqv-hash-table: | | Construction of Hash Tables |
| make-for-each-generator: | | SRFI 158 |
| make-graphics-device: | | Opening and Closing of Graphics Devices |
| make-hash-table: | | Construction of Hash Tables |
| make-hash-table: | | Construction of Hash Tables |
| make-hash-table: | | SRFI 69 |
| make-hash-table: | | SRFI 125 |
| make-hash-table*: | | Construction of Hash Tables |
| make-hash-table-type: | | Construction of Hash Tables |
| make-hash-table-type*: | | Construction of Hash Tables |
| make-initialized-list: | | Construction of Lists |
| make-initialized-vector: | | Construction of Vectors |
| make-iota-generator: | | SRFI 158 |
| make-key-ephemeral-eq-hash-table: | | Construction of Hash Tables |
| make-key-ephemeral-eqv-hash-table: | | Construction of Hash Tables |
| make-key-weak-eq-hash-table: | | Construction of Hash Tables |
| make-key-weak-eqv-hash-table: | | Construction of Hash Tables |
| make-list: | | Construction of Lists |
| make-list: | | R7RS |
| make-list: | | SRFI 1 |
| make-list-comparator: | | SRFI 128 |
| make-object-hash-table: | | Construction of Hash Tables |
| make-object-hasher: | | Object Hashing |
| make-pair-comparator: | | SRFI 128 |
| make-parameter: | | Parameters |
| make-parameter: | | R7RS |
| make-parameter: | | SRFI 39 |
| make-parser-macros: | | Parser-language Macros |
| make-pathname: | | Components of Pathnames |
| make-polar: | | Numerical operations |
| make-polar: | | R7RS |
| make-port: | | Constructors and Accessors for Textual Ports |
| make-port-type: | | Textual Port Types |
| make-primitive-procedure: | | Primitive Procedures |
| make-procedure-arity: | | Arity |
| make-promise: | | R7RS |
| make-random-source: | | Random Number Generation |
| make-random-source: | | SRFI 27 |
| make-random-state: | | Random Number Generation |
| make-range-generator: | | SRFI 158 |
| make-rb-tree: | | Red-Black Trees |
| make-record-type: | | Records |
| make-rectangular: | | Numerical operations |
| make-rectangular: | | Numerical operations |
| make-rectangular: | | R7RS |
| make-root-top-level-environment: | | Top-level Environments |
| make-settable-parameter: | | Parameters |
| make-string: | | Strings |
| make-string: | | R7RS |
| make-string-hash-table: | | Construction of Hash Tables |
| make-strong-eq-hash-table: | | Construction of Hash Tables |
| make-strong-eqv-hash-table: | | Construction of Hash Tables |
| make-symbol-hash-table: | | Construction of Hash Tables |
| make-syntactic-closure: | | SC Transformer Definition |
| make-synthetic-identifier: | | SC Identifiers |
| make-textual-port: | | Constructors and Accessors for Textual Ports |
| make-textual-port-type: | | Textual Port Types |
| make-top-level-environment: | | Top-level Environments |
| make-unfold-generator: | | SRFI 158 |
| make-unsettable-parameter: | | Parameters |
| make-vector: | | Construction of Vectors |
| make-vector: | | R7RS |
| make-vector-comparator: | | SRFI 128 |
| make-weak-eq-hash-table: | | Construction of Hash Tables |
| make-weak-eqv-hash-table: | | Construction of Hash Tables |
| make-wt-tree: | | Construction of Weight-Balanced Trees |
| make-wt-tree-type: | | Construction of Weight-Balanced Trees |
| make-xml-!attlist: | | XML Structure |
| make-xml-!element: | | XML Structure |
| make-xml-!entity: | | XML Structure |
| make-xml-!notation: | | XML Structure |
| make-xml-declaration: | | XML Structure |
| make-xml-document: | | XML Structure |
| make-xml-dtd: | | XML Structure |
| make-xml-element: | | XML Structure |
| make-xml-external-id: | | XML Structure |
| make-xml-name: | | XML Names |
| make-xml-nmtoken: | | XML Names |
| make-xml-parameter-!entity: | | XML Structure |
| make-xml-processing-instructions: | | XML Structure |
| make-xml-qname: | | XML Names |
| make-xml-unparsed-!entity: | | XML Structure |
| map: | | Mapping of Lists |
| map: | | *Parser |
| map: | | R7RS |
| map: | | SRFI 1 |
| map!: | | SRFI 1 |
| map*: | | Mapping of Lists |
| map-in-order: | | SRFI 1 |
| map-window on x-graphics-device: | | Custom Operations on X Graphics Devices |
| match: | | *Parser |
| match-parser-buffer-char: | | Parser Buffers |
| match-parser-buffer-char-ci: | | Parser Buffers |
| match-parser-buffer-char-ci-no-advance: | | Parser Buffers |
| match-parser-buffer-char-in-set: | | Parser Buffers |
| match-parser-buffer-char-in-set-no-advance: | | Parser Buffers |
| match-parser-buffer-char-no-advance: | | Parser Buffers |
| match-parser-buffer-not-char: | | Parser Buffers |
| match-parser-buffer-not-char-ci: | | Parser Buffers |
| match-parser-buffer-not-char-ci-no-advance: | | Parser Buffers |
| match-parser-buffer-not-char-no-advance: | | Parser Buffers |
| match-parser-buffer-string: | | Parser Buffers |
| match-parser-buffer-string-ci: | | Parser Buffers |
| match-parser-buffer-string-ci-no-advance: | | Parser Buffers |
| match-parser-buffer-string-no-advance: | | Parser Buffers |
| match-parser-buffer-substring: | | Parser Buffers |
| match-parser-buffer-substring-ci: | | Parser Buffers |
| match-parser-buffer-substring-ci-no-advance: | | Parser Buffers |
| match-parser-buffer-substring-no-advance: | | Parser Buffers |
| max: | | Numerical operations |
| max: | | R7RS |
| measure-interval: | | Machine Time |
| member: | | Searching Lists |
| member: | | R7RS |
| member: | | SRFI 1 |
| member-procedure: | | Searching Lists |
| memq: | | Searching Lists |
| memq: | | R7RS |
| memq: | | SRFI 1 |
| memv: | | Searching Lists |
| memv: | | R7RS |
| memv: | | SRFI 1 |
| merge-pathnames: | | File Ports |
| merge-pathnames: | | Operations on Pathnames |
| merge-sort: | | Miscellaneous List Operations |
| merge-sort!: | | Modifying Vectors |
| microcode-id/operating-system: | | Miscellaneous OS Facilities |
| microcode-id/operating-system-name: | | Miscellaneous OS Facilities |
| microcode-id/operating-system-variant: | | Miscellaneous OS Facilities |
| min: | | Numerical operations |
| min: | | R7RS |
| modexp: | | Numerical operations |
| modulo: | | Numerical operations |
| modulo: | | R7RS |
| month/long-string: | | External Representation of Time |
| month/max-days: | | Decoded Time |
| month/short-string: | | External Representation of Time |
| move-window on x-graphics-device: | | Custom Operations on X Graphics Devices |
| muffle-warning: | | Condition Signalling |
| muffle-warning: | | Condition Handling |
| muffle-warning: | | Restarts |
| muffle-warning: | | Invoking Standard Restart Code |
|
| N | | |
|---|
| name->char: | | Characters |
| named: | | Structure Definitions |
| named-lambda: | | Lambda Expressions |
| named-lambda: | | Definitions |
| named-lambda: | | Sequencing |
| NaN (not a number): | | Flonum Operations |
| nan?: | | R7RS |
| nearest-repl/environment: | | REPL Environment |
| negative?: | | Numerical operations |
| negative?: | | R7RS |
| newline: | | Output Procedures |
| newline: | | R7RS |
| nil: | | Booleans |
| ninth: | | Selecting List Components |
| ninth: | | SRFI 1 |
| noise: | | *Parser |
| not: | | Booleans |
| not: | | R7RS |
| not-char: | | *Matcher |
| not-char-ci: | | *Matcher |
| not-pair?: | | SRFI 1 |
| notification-output-port: | | Ports |
| notification-output-port: | | Condition Handling |
| nt-file-mode/archive: | | File Manipulation |
| nt-file-mode/compressed: | | File Manipulation |
| nt-file-mode/directory: | | File Manipulation |
| nt-file-mode/hidden: | | File Manipulation |
| nt-file-mode/normal: | | File Manipulation |
| nt-file-mode/read-only: | | File Manipulation |
| nt-file-mode/system: | | File Manipulation |
| nt-file-mode/temporary: | | File Manipulation |
| null-list?: | | Selecting List Components |
| null-list?: | | SRFI 1 |
| null-xml-name-prefix: | | XML Names |
| null-xml-name-prefix?: | | XML Names |
| null-xml-namespace-uri: | | XML Names |
| null-xml-namespace-uri?: | | XML Names |
| null?: | | Selecting List Components |
| null?: | | Selecting List Components |
| null?: | | Streams |
| null?: | | R7RS |
| null?: | | SRFI 1 |
| number->string: | | Numerical input and output |
| number->string: | | R7RS |
| number-hash: | | SRFI 128 |
| number-wt-type: | | Construction of Weight-Balanced Trees |
| number?: | | Numerical operations |
| number?: | | R7RS |
| numerator: | | Numerical operations |
| numerator: | | R7RS |
|
| O | | |
|---|
| object-hash: | | Object Hashing |
| object-hashed?: | | Object Hashing |
| object-unhash: | | Object Hashing |
| odd?: | | Numerical operations |
| odd?: | | R7RS |
| open-binary-i/o-file: | | File Ports |
| open-binary-input-file: | | File Ports |
| open-binary-input-file: | | File Ports |
| open-binary-input-file: | | R7RS |
| open-binary-output-file: | | File Ports |
| open-binary-output-file: | | File Ports |
| open-binary-output-file: | | R7RS |
| open-i/o-file: | | File Ports |
| open-input-bytevector: | | Bytevector Ports |
| open-input-bytevector: | | R7RS |
| open-input-file: | | File Ports |
| open-input-file: | | File Ports |
| open-input-file: | | R7RS |
| open-input-string: | | String Ports |
| open-input-string: | | R7RS |
| open-output-bytevector: | | Bytevector Ports |
| open-output-bytevector: | | Bytevector Ports |
| open-output-bytevector: | | R7RS |
| open-output-file: | | File Ports |
| open-output-file: | | File Ports |
| open-output-file: | | R7RS |
| open-output-string: | | String Ports |
| open-output-string: | | String Ports |
| open-output-string: | | String Ports |
| open-output-string: | | R7RS |
| open-tcp-server-socket: | | TCP Sockets |
| open-tcp-stream-socket: | | TCP Sockets |
| or: | | Conditionals |
| or: | | Booleans |
| or: | | R7RS |
| os-name: | | SRFI 112 |
| os-version: | | SRFI 112 |
| os/hostname: | | Miscellaneous OS Facilities |
| output: | | Subprocess Options |
| output-buffer-size: | | Subprocess Options |
| output-buffer-size on textual output port: | | Textual Output Port Operations |
| output-line-translation: | | Subprocess Options |
| output-port-blocking-mode: | | Blocking Mode |
| output-port-open?: | | Ports |
| output-port-open?: | | R7RS |
| output-port-terminal-mode: | | Terminal Mode |
| output-port-type?: | | Textual Port Types |
| output-port/discretionary-flush-output: | | Textual Output Port Operations |
| output-port/flush-output: | | Textual Output Port Operations |
| output-port/fresh-line: | | Textual Output Port Operations |
| output-port/write-char: | | Textual Output Port Operations |
| output-port/write-string: | | Textual Output Port Operations |
| output-port/write-substring: | | Textual Output Port Operations |
| output-port/x-size: | | Textual Output Port Operations |
| output-port/y-size: | | Textual Output Port Operations |
| output-port?: | | Ports |
| output-port?: | | R7RS |
|
| P | | |
|---|
| pair-comparator: | | SRFI 162 |
| pair-fold: | | SRFI 1 |
| pair-fold-right: | | SRFI 1 |
| pair-for-each: | | SRFI 1 |
| pair?: | | Pairs |
| pair?: | | Selecting List Components |
| pair?: | | Weak Pairs |
| pair?: | | R7RS |
| pair?: | | SRFI 1 |
| param:default-pathname-defaults: | | Operations on Pathnames |
| param:flonum-printer-cutoff: | | Numerical input and output |
| param:print-with-maximum-readability?: | | Output Procedures |
| param:printer-list-breadth-limit: | | Output Procedures |
| param:printer-list-depth-limit: | | Output Procedures |
| param:printer-radix: | | Output Procedures |
| param:printer-string-length-limit: | | Output Procedures |
| param:reader-fold-case?: | | Input Procedures |
| param:reader-radix: | | Input Procedures |
| parameterize: | | Dynamic Binding |
| parameterize: | | Definitions |
| parameterize: | | Internal Definitions |
| parameterize: | | Sequencing |
| parameterize: | | Ports |
| parameterize: | | File Ports |
| parameterize: | | File Ports |
| parameterize: | | Output Procedures |
| parameterize: | | R7RS |
| parameterize: | | SRFI 39 |
| parameterize*: | | Parameters |
| parse-namestring: | | Filenames and Pathnames |
| parser-buffer-pointer-index: | | Parser Buffers |
| parser-buffer-pointer-line: | | Parser Buffers |
| parser-buffer-pointer?: | | Parser Buffers |
| parser-buffer-position-string: | | Parser Buffers |
| parser-buffer-ref: | | Parser Buffers |
| parser-buffer?: | | Parser Buffers |
| parser-macros?: | | Parser-language Macros |
| partition: | | Filtering Lists |
| partition: | | SRFI 1 |
| partition!: | | Filtering Lists |
| partition!: | | SRFI 1 |
| pathname-absolute?: | | Operations on Pathnames |
| pathname-as-directory: | | Operations on Pathnames |
| pathname-as-directory: | | Working Directory |
| pathname-default: | | Operations on Pathnames |
| pathname-default-device: | | Components of Pathnames |
| pathname-default-directory: | | Components of Pathnames |
| pathname-default-name: | | Components of Pathnames |
| pathname-default-type: | | Components of Pathnames |
| pathname-default-version: | | Components of Pathnames |
| pathname-device: | | Components of Pathnames |
| pathname-directory: | | Components of Pathnames |
| pathname-host: | | Components of Pathnames |
| pathname-name: | | Components of Pathnames |
| pathname-new-device: | | Components of Pathnames |
| pathname-new-directory: | | Components of Pathnames |
| pathname-new-name: | | Components of Pathnames |
| pathname-new-type: | | Components of Pathnames |
| pathname-new-version: | | Components of Pathnames |
| pathname-simplify: | | Filenames and Pathnames |
| pathname-type: | | Components of Pathnames |
| pathname-version: | | Components of Pathnames |
| pathname-wild?: | | Operations on Pathnames |
| pathname=?: | | Operations on Pathnames |
| pathname?: | | Operations on Pathnames |
| peek-char: | | Input Procedures |
| peek-char: | | R7RS |
| peek-char on textual input port: | | Textual Input Port Operations |
| peek-parser-buffer-char: | | Parser Buffers |
| peek-u8: | | Input Procedures |
| peek-u8: | | R7RS |
| port-type/operation: | | Textual Port Types |
| port-type/operation-names: | | Textual Port Types |
| port-type/operations: | | Textual Port Types |
| port-type?: | | Textual Port Types |
| port/input-blocking-mode: | | Blocking Mode |
| port/input-terminal-mode: | | Terminal Mode |
| port/operation: | | Constructors and Accessors for Textual Ports |
| port/operation-names: | | Constructors and Accessors for Textual Ports |
| port/output-blocking-mode: | | Blocking Mode |
| port/output-terminal-mode: | | Terminal Mode |
| port/set-input-blocking-mode: | | Blocking Mode |
| port/set-input-terminal-mode: | | Terminal Mode |
| port/set-output-blocking-mode: | | Blocking Mode |
| port/set-output-terminal-mode: | | Terminal Mode |
| port/state: | | Constructors and Accessors for Textual Ports |
| port/type: | | Constructors and Accessors for Textual Ports |
| port/with-input-blocking-mode: | | Blocking Mode |
| port/with-input-terminal-mode: | | Terminal Mode |
| port/with-output-blocking-mode: | | Blocking Mode |
| port/with-output-terminal-mode: | | Terminal Mode |
| port?: | | Ports |
| port?: | | R7RS |
| positive?: | | Numerical operations |
| positive?: | | R7RS |
| pp: | | Output Procedures |
| predicate: | | Structure Definitions |
| primitive-procedure-name: | | Primitive Procedures |
| primitive-procedure?: | | Procedure Operations |
| print-procedure: | | Structure Definitions |
| procedure: | | Booleans |
| procedure-arity: | | Arity |
| procedure-arity-max: | | Arity |
| procedure-arity-min: | | Arity |
| procedure-arity-valid?: | | Arity |
| procedure-arity?: | | Arity |
| procedure-environment: | | Procedure Operations |
| procedure-of-arity?: | | Arity |
| procedure?: | | Procedure Operations |
| procedure?: | | R7RS |
| process-time-clock: | | Machine Time |
| product-accumulator: | | SRFI 158 |
| promise-forced?: | | Promises |
| promise-value: | | Promises |
| promise?: | | Promises |
| promise?: | | R7RS |
| prompt-for-command-char: | | Prompting |
| prompt-for-command-expression: | | Prompting |
| prompt-for-confirmation: | | Prompting |
| prompt-for-evaluated-expression: | | Prompting |
| prompt-for-expression: | | Prompting |
| proper-list?: | | Selecting List Components |
| proper-list?: | | SRFI 1 |
| pwd: | | Working Directory |
|
| Q | | |
|---|
| quasiquote: | | Quoting |
| quasiquote: | | Lists |
| quasiquote: | | R7RS |
| quick-sort: | | Miscellaneous List Operations |
| quick-sort!: | | Modifying Vectors |
| quote: | | Quoting |
| quote: | | Lists |
| quote: | | R7RS |
| quotient: | | Numerical operations |
| quotient: | | R7RS |
|
| R | | |
|---|
| raise: | | R7RS |
| raise-continuable: | | R7RS |
| random: | | Random Number Generation |
| random-bytevector: | | Random Number Generation |
| random-bytevector!: | | Random Number Generation |
| random-integer: | | Random Number Generation |
| random-integer: | | SRFI 27 |
| random-real: | | Random Number Generation |
| random-real: | | SRFI 27 |
| random-source-make-integers: | | Random Number Generation |
| random-source-make-integers: | | SRFI 27 |
| random-source-make-reals: | | Random Number Generation |
| random-source-make-reals: | | SRFI 27 |
| random-source-make-reals: | | SRFI 27 |
| random-source-pseudo-randomize!: | | Random Number Generation |
| random-source-pseudo-randomize!: | | SRFI 27 |
| random-source-randomize!: | | Random Number Generation |
| random-source-randomize!: | | SRFI 27 |
| random-source-state-ref: | | Random Number Generation |
| random-source-state-ref: | | SRFI 27 |
| random-source-state-set!: | | Random Number Generation |
| random-source-state-set!: | | SRFI 27 |
| random-source?: | | Random Number Generation |
| random-source?: | | SRFI 27 |
| random-state?: | | Random Number Generation |
| rational?: | | Numerical operations |
| rational?: | | R7RS |
| rationalize: | | Numerical operations |
| rationalize: | | R7RS |
| rationalize->exact: | | Numerical operations |
| rb-tree->alist: | | Red-Black Trees |
| rb-tree/copy: | | Red-Black Trees |
| rb-tree/datum-list: | | Red-Black Trees |
| rb-tree/delete!: | | Red-Black Trees |
| rb-tree/delete-max!: | | Red-Black Trees |
| rb-tree/delete-max-datum!: | | Red-Black Trees |
| rb-tree/delete-max-pair!: | | Red-Black Trees |
| rb-tree/delete-min!: | | Red-Black Trees |
| rb-tree/delete-min-datum!: | | Red-Black Trees |
| rb-tree/delete-min-pair!: | | Red-Black Trees |
| rb-tree/empty?: | | Red-Black Trees |
| rb-tree/equal?: | | Red-Black Trees |
| rb-tree/height: | | Red-Black Trees |
| rb-tree/insert!: | | Red-Black Trees |
| rb-tree/intern!: | | Red-Black Trees |
| rb-tree/key-list: | | Red-Black Trees |
| rb-tree/lookup: | | Red-Black Trees |
| rb-tree/max: | | Red-Black Trees |
| rb-tree/max-datum: | | Red-Black Trees |
| rb-tree/max-pair: | | Red-Black Trees |
| rb-tree/min: | | Red-Black Trees |
| rb-tree/min-datum: | | Red-Black Trees |
| rb-tree/min-pair: | | Red-Black Trees |
| rb-tree/ref: | | Red-Black Trees |
| rb-tree/size: | | Red-Black Trees |
| rb-tree/update!: | | Red-Black Trees |
| rb-tree?: | | Red-Black Trees |
| read: | | Overview |
| read: | | External Representations |
| read: | | Lists |
| read: | | Symbols |
| read: | | Symbols |
| read: | | Symbols |
| read: | | Ports |
| read: | | Input Procedures |
| read: | | R7RS |
| read-bytevector: | | Input Procedures |
| read-bytevector: | | R7RS |
| read-bytevector!: | | Input Procedures |
| read-bytevector!: | | R7RS |
| read-char: | | Ports |
| read-char: | | Input Procedures |
| read-char: | | Input Procedures |
| read-char: | | Input Procedures |
| read-char: | | R7RS |
| read-char on textual input port: | | Textual Input Port Operations |
| read-char-no-hang: | | Input Procedures |
| read-delimited-string: | | Input Procedures |
| read-error?: | | R7RS |
| read-line: | | Input Procedures |
| read-line: | | R7RS |
| read-only: | | Structure Definitions |
| read-parser-buffer-char: | | Parser Buffers |
| read-string: | | Input Procedures |
| read-string: | | R7RS |
| read-string on textual input port: | | Textual Input Port Operations |
| read-string!: | | Input Procedures |
| read-substring on textual input port: | | Textual Input Port Operations |
| read-substring!: | | Input Procedures |
| read-u8: | | Ports |
| read-u8: | | Input Procedures |
| read-u8: | | R7RS |
| read-xml: | | XML Input |
| read-xml-file: | | XML Input |
| real-comparator: | | SRFI 162 |
| real-part: | | Numerical operations |
| real-part: | | R7RS |
| real-time-clock: | | Machine Time |
| real?: | | Numerical operations |
| real?: | | R7RS |
| receive: | | receive (SRFI 8) |
| receive: | | SRFI 8 |
| record-accessor: | | Records |
| record-constructor: | | Records |
| record-keyword-constructor: | | Records |
| record-modifier: | | Records |
| record-predicate: | | Records |
| record-type-descriptor: | | Records |
| record-type-field-names: | | Records |
| record-type-name: | | Records |
| record-type?: | | Records |
| record?: | | Records |
| redisplay-hook: | | Subprocess Options |
| reduce: | | Folding of Lists |
| reduce: | | SRFI 1 |
| reduce-left: | | Folding of Lists |
| reduce-right: | | Folding of Lists |
| reduce-right: | | SRFI 1 |
| reference-barrier: | | Reference barriers |
| reference-barrier: | | SRFI 124 |
| regexp: | | SRFI 115 |
| regexp-extract: | | SRFI 115 |
| regexp-fold: | | SRFI 115 |
| regexp-match->list: | | SRFI 115 |
| regexp-match-count: | | SRFI 115 |
| regexp-match-submatch: | | SRFI 115 |
| regexp-match-submatch-end: | | SRFI 115 |
| regexp-match-submatch-start: | | SRFI 115 |
| regexp-match?: | | SRFI 115 |
| regexp-matches: | | SRFI 115 |
| regexp-matches?: | | SRFI 115 |
| regexp-partition: | | SRFI 115 |
| regexp-replace: | | SRFI 115 |
| regexp-replace-all: | | SRFI 115 |
| regexp-search: | | SRFI 115 |
| regexp-split: | | SRFI 115 |
| regexp?: | | SRFI 115 |
| regsexp-match-string: | | Regsexp Procedures |
| regsexp-search-string-forward: | | Regsexp Procedures |
| remainder: | | Numerical operations |
| remainder: | | R7RS |
| remove: | | Filtering Lists |
| remove: | | SRFI 1 |
| remove!: | | Filtering Lists |
| remove!: | | SRFI 1 |
| rename-file: | | File Manipulation |
| resize-window on x-graphics-device: | | Custom Operations on X Graphics Devices |
| restart/effector: | | The Named Restart Abstraction |
| restart/interactor: | | Finding and Invoking General Restart Code |
| restart/interactor: | | The Named Restart Abstraction |
| restart/name: | | The Named Restart Abstraction |
| restart?: | | The Named Restart Abstraction |
| retry: | | Restarts |
| retry: | | Invoking Standard Restart Code |
| retry: | | Invoking Standard Restart Code |
| reverse: | | Miscellaneous List Operations |
| reverse: | | R7RS |
| reverse: | | SRFI 1 |
| reverse!: | | Miscellaneous List Operations |
| reverse!: | | SRFI 1 |
| reverse-list->string: | | SRFI 140 |
| reverse-list->vector: | | SRFI 133 |
| reverse-list-accumulator: | | SRFI 158 |
| reverse-vector->generator: | | SRFI 158 |
| reverse-vector->list: | | SRFI 133 |
| reverse-vector-accumulator: | | SRFI 158 |
| round: | | Numerical operations |
| round: | | R7RS |
| round->exact: | | Numerical operations |
| round-quotient: | | Numerical operations |
| round-remainder: | | Numerical operations |
| round/: | | Numerical operations |
| rsc-macro-transformer: | | SC Transformer Definition |
| rsqrt: | | Numerical operations |
| run-shell-command: | | Subprocess Procedures |
| run-synchronous-subprocess: | | Subprocess Procedures |
| runtime: | | Machine Time |
| rx: | | SRFI 115 |
|
| S | | |
|---|
| safe-accessors: | | Structure Definitions |
| sc-macro-transformer: | | SC Transformer Definition |
| scheme-subprocess-environment: | | Subprocess Options |
| second: | | Selecting List Components |
| second: | | SRFI 1 |
| seq: | | Regular S-Expressions |
| seq: | | *Matcher |
| seq: | | *Parser |
| set!: | | Top-Level Definitions |
| set!: | | Assignments |
| set!: | | R7RS |
| set-apply-hook-extra!: | | Application Hooks |
| set-apply-hook-procedure!: | | Application Hooks |
| set-background-color on x-graphics-device: | | Custom Operations on X Graphics Devices |
| set-bit: | | Bit operations |
| set-border-color on x-graphics-device: | | Custom Operations on X Graphics Devices |
| set-border-width on x-graphics-device: | | Custom Operations on X Graphics Devices |
| set-car!: | | Pairs |
| set-car!: | | R7RS |
| set-car!: | | SRFI 1 |
| set-cdr!: | | Lists |
| set-cdr!: | | Pairs |
| set-cdr!: | | String Ports |
| set-cdr!: | | R7RS |
| set-cdr!: | | SRFI 1 |
| set-cell-contents!: | | Parameters |
| set-current-input-port!: | | Ports |
| set-current-output-port!: | | Ports |
| set-current-parser-macros!: | | Parser-language Macros |
| set-entity-extra!: | | Application Hooks |
| set-entity-procedure!: | | Application Hooks |
| set-ephemeron-datum!: | | Ephemerons |
| set-ephemeron-key!: | | Ephemerons |
| set-file-modes!: | | File Manipulation |
| set-file-times!: | | File Manipulation |
| set-font on x-graphics-device: | | Custom Operations on X Graphics Devices |
| set-foreground-color on x-graphics-device: | | Custom Operations on X Graphics Devices |
| set-hash-table-rehash-size!: | | Resizing of Hash Tables |
| set-hash-table-rehash-threshold!: | | Resizing of Hash Tables |
| set-hash-table/rehash-size!: | | Resizing of Hash Tables |
| set-hash-table/rehash-threshold!: | | Resizing of Hash Tables |
| set-input-buffer-size on textual input port: | | Textual Input Port Operations |
| set-input-port-blocking-mode!: | | Blocking Mode |
| set-input-port-terminal-mode!: | | Terminal Mode |
| set-interaction-i/o-port!: | | Ports |
| set-internal-border-width on x-graphics-device: | | Custom Operations on X Graphics Devices |
| set-mouse-color on x-graphics-device: | | Custom Operations on X Graphics Devices |
| set-mouse-shape on x-graphics-device: | | Custom Operations on X Graphics Devices |
| set-notification-output-port!: | | Ports |
| set-output-buffer-size on textual output port: | | Textual Output Port Operations |
| set-output-port-blocking-mode: | | Blocking Mode |
| set-output-port-terminal-mode!: | | Terminal Mode |
| set-parser-buffer-pointer!: | | Parser Buffers |
| set-port/state!: | | Constructors and Accessors for Textual Ports |
| set-record-type-unparser-method!: | | Custom Output |
| set-textual-port-state!: | | Constructors and Accessors for Textual Ports |
| set-trace-output-port!: | | Ports |
| set-working-directory-pathname!: | | Working Directory |
| set-xml-!attlist-definitions!: | | XML Structure |
| set-xml-!attlist-name!: | | XML Structure |
| set-xml-!element-content-type!: | | XML Structure |
| set-xml-!element-name!: | | XML Structure |
| set-xml-!entity-name!: | | XML Structure |
| set-xml-!entity-value!: | | XML Structure |
| set-xml-!notation-id!: | | XML Structure |
| set-xml-!notation-name!: | | XML Structure |
| set-xml-declaration-encoding!: | | XML Structure |
| set-xml-declaration-standalone!: | | XML Structure |
| set-xml-declaration-version!: | | XML Structure |
| set-xml-document-declaration!: | | XML Structure |
| set-xml-document-dtd!: | | XML Structure |
| set-xml-document-misc-1!: | | XML Structure |
| set-xml-document-misc-2!: | | XML Structure |
| set-xml-document-misc-3!: | | XML Structure |
| set-xml-document-root!: | | XML Structure |
| set-xml-dtd-external!: | | XML Structure |
| set-xml-dtd-internal!: | | XML Structure |
| set-xml-dtd-root!: | | XML Structure |
| set-xml-element-attributes!: | | XML Structure |
| set-xml-element-content!: | | XML Structure |
| set-xml-element-name!: | | XML Structure |
| set-xml-external-id-id!: | | XML Structure |
| set-xml-external-id-uri!: | | XML Structure |
| set-xml-parameter-!entity-name!: | | XML Structure |
| set-xml-parameter-!entity-value!: | | XML Structure |
| set-xml-processing-instructions-name!: | | XML Structure |
| set-xml-processing-instructions-text!: | | XML Structure |
| set-xml-unparsed-!entity-id!: | | XML Structure |
| set-xml-unparsed-!entity-name!: | | XML Structure |
| set-xml-unparsed-!entity-notation!: | | XML Structure |
| seventh: | | Selecting List Components |
| seventh: | | SRFI 1 |
| sexp: | | *Matcher |
| sexp: | | *Parser |
| shell-file-name: | | Subprocess Options |
| shift-left: | | Bit operations |
| shift-right: | | Bit operations |
| shiftin: | | Bit operations |
| shiftout: | | Bit operations |
| signal-condition: | | Error System |
| signal-condition: | | Condition Signalling |
| signal-condition: | | Condition Signalling |
| signal-condition: | | Condition Signalling |
| signal-condition: | | Condition Handling |
| signal-condition: | | Condition Handling |
| signal-condition: | | Condition Handling |
| signal-condition: | | Condition Handling |
| signed-integer->bit-string: | | Integer Conversions of Bit Strings |
| simplest-exact-rational: | | Numerical operations |
| simplest-rational: | | Numerical operations |
| sin: | | Numerical operations |
| sin: | | R7RS |
| sin-pi*: | | Numerical operations |
| singleton-wt-tree: | | Construction of Weight-Balanced Trees |
| sixth: | | Selecting List Components |
| sixth: | | SRFI 1 |
| soft-link-file: | | File Manipulation |
| sort: | | Miscellaneous List Operations |
| sort!: | | Modifying Vectors |
| source->parser-buffer: | | Parser Buffers |
| span: | | SRFI 1 |
| span!: | | SRFI 1 |
| split-at: | | SRFI 1 |
| split-at!: | | SRFI 1 |
| sqrt: | | Implementation restrictions |
| sqrt: | | Numerical operations |
| sqrt: | | R7RS |
| sqrt1pm1: | | Numerical operations |
| square: | | R7RS |
| standard-error-handler: | | Condition Handling |
| standard-error-handler: | | Condition Handling |
| standard-error-hook: | | Condition Handling |
| standard-print-method: | | Custom Output |
| standard-unparser-method: | | Custom Output |
| standard-warning-handler: | | Condition Handling |
| standard-warning-handler: | | Condition Handling |
| standard-warning-hook: | | Condition Handling |
| store-value: | | Restarts |
| store-value: | | Invoking Standard Restart Code |
| store-value: | | Invoking Standard Restart Code |
| stream: | | Streams |
| stream->list: | | Streams |
| stream-car: | | Streams |
| stream-cdr: | | Streams |
| stream-first: | | Streams |
| stream-head: | | Streams |
| stream-length: | | Streams |
| stream-map: | | Streams |
| stream-null?: | | Streams |
| stream-pair?: | | Streams |
| stream-ref: | | Streams |
| stream-rest: | | Streams |
| stream-tail: | | Streams |
| string: | | Strings |
| string: | | *Matcher |
| string: | | R7RS |
| string: | | SRFI 140 |
| string*: | | Strings |
| string->char-set: | | SRFI 14 |
| string->char-set!: | | SRFI 14 |
| string->decoded-time: | | Time-Format Conversion |
| string->file-time: | | Time-Format Conversion |
| string->generator: | | SRFI 158 |
| string->list: | | Strings |
| string->list: | | R7RS |
| string->list: | | SRFI 140 |
| string->nfc: | | Strings |
| string->nfd: | | Strings |
| string->number: | | Numerical input and output |
| string->number: | | R7RS |
| string->parser-buffer: | | Parser Buffers |
| string->symbol: | | Symbols |
| string->symbol: | | R7RS |
| string->uninterned-symbol: | | Symbols |
| string->universal-time: | | Time-Format Conversion |
| string->utf16: | | SRFI 140 |
| string->utf16be: | | SRFI 140 |
| string->utf16le: | | SRFI 140 |
| string->utf8: | | R7RS |
| string->utf8: | | SRFI 140 |
| string->vector: | | Construction of Vectors |
| string->vector: | | R7RS |
| string->vector: | | SRFI 140 |
| string->xml: | | XML Input |
| string-accumulator: | | SRFI 158 |
| string-any: | | Strings |
| string-any: | | SRFI 140 |
| string-append: | | Strings |
| string-append: | | R7RS |
| string-append: | | SRFI 140 |
| string-append*: | | Strings |
| string-builder: | | Strings |
| string-ci: | | Regular S-Expressions |
| string-ci: | | *Matcher |
| string-ci-comparator: | | SRFI 162 |
| string-ci-hash: | | SRFI 69 |
| string-ci-hash: | | SRFI 125 |
| string-ci-hash: | | SRFI 128 |
| string-ci<=?: | | Strings |
| string-ci<=?: | | R7RS |
| string-ci<=?: | | SRFI 140 |
| string-ci<?: | | Strings |
| string-ci<?: | | R7RS |
| string-ci<?: | | SRFI 140 |
| string-ci=?: | | Strings |
| string-ci=?: | | Strings |
| string-ci=?: | | R7RS |
| string-ci=?: | | SRFI 140 |
| string-ci>=?: | | Strings |
| string-ci>=?: | | R7RS |
| string-ci>=?: | | SRFI 140 |
| string-ci>?: | | Strings |
| string-ci>?: | | R7RS |
| string-ci>?: | | SRFI 140 |
| string-comparator: | | SRFI 162 |
| string-compare: | | Strings |
| string-compare-ci: | | Strings |
| string-concatenate: | | SRFI 140 |
| string-concatenate-reverse: | | SRFI 140 |
| string-contains: | | SRFI 140 |
| string-contains-right: | | SRFI 140 |
| string-copy: | | Strings |
| string-copy: | | R7RS |
| string-copy!: | | Strings |
| string-copy!: | | R7RS |
| string-count: | | Strings |
| string-count: | | SRFI 140 |
| string-downcase: | | Strings |
| string-downcase: | | R7RS |
| string-downcase: | | SRFI 140 |
| string-drop: | | SRFI 140 |
| string-drop-right: | | SRFI 140 |
| string-end: | | Regular S-Expressions |
| string-every: | | Strings |
| string-every: | | SRFI 140 |
| string-fill!: | | Strings |
| string-fill!: | | R7RS |
| string-filter: | | SRFI 140 |
| string-find-first-index: | | Searching and Matching Strings |
| string-find-last-index: | | Searching and Matching Strings |
| string-find-next-char: | | Searching and Matching Strings |
| string-find-next-char-ci: | | Searching and Matching Strings |
| string-find-next-char-in-set: | | Searching and Matching Strings |
| string-find-previous-char: | | Searching and Matching Strings |
| string-find-previous-char-ci: | | Searching and Matching Strings |
| string-find-previous-char-in-set: | | Searching and Matching Strings |
| string-fold: | | SRFI 140 |
| string-fold-right: | | SRFI 140 |
| string-foldcase: | | Strings |
| string-foldcase: | | R7RS |
| string-foldcase: | | SRFI 140 |
| string-for-each: | | Strings |
| string-for-each: | | R7RS |
| string-for-each: | | SRFI 140 |
| string-for-each-index: | | SRFI 140 |
| string-hash: | | Strings |
| string-hash: | | Symbols |
| string-hash: | | Construction of Hash Tables |
| string-hash: | | SRFI 69 |
| string-hash: | | SRFI 125 |
| string-hash: | | SRFI 128 |
| string-hash-ci: | | Strings |
| string-head: | | Strings |
| string-in-nfc?: | | Strings |
| string-in-nfd?: | | Strings |
| string-index: | | SRFI 140 |
| string-index-right: | | SRFI 140 |
| string-is-xml-name?: | | XML Names |
| string-is-xml-nmtoken?: | | XML Names |
| string-join: | | SRFI 140 |
| string-joiner: | | Strings |
| string-joiner*: | | Strings |
| string-length: | | Implementation restrictions |
| string-length: | | Strings |
| string-length: | | R7RS |
| string-length: | | SRFI 140 |
| string-lower-case?: | | Strings |
| string-map: | | Strings |
| string-map: | | R7RS |
| string-map: | | SRFI 140 |
| string-map-index: | | SRFI 140 |
| string-match-backward: | | Searching and Matching Strings |
| string-match-forward: | | Searching and Matching Strings |
| string-null?: | | Strings |
| string-null?: | | SRFI 140 |
| string-pad: | | SRFI 140 |
| string-pad-left: | | Strings |
| string-pad-right: | | Strings |
| string-pad-right: | | SRFI 140 |
| string-padder: | | Strings |
| string-prefix-ci?: | | Searching and Matching Strings |
| string-prefix-length: | | SRFI 140 |
| string-prefix?: | | Searching and Matching Strings |
| string-prefix?: | | SRFI 140 |
| string-ref: | | Storage Model |
| string-ref: | | Strings |
| string-ref: | | R7RS |
| string-ref: | | SRFI 140 |
| string-remove: | | SRFI 140 |
| string-repeat: | | SRFI 140 |
| string-replace: | | Strings |
| string-replace: | | SRFI 140 |
| string-search-all: | | Searching and Matching Strings |
| string-search-backward: | | Searching and Matching Strings |
| string-search-forward: | | Searching and Matching Strings |
| string-set!: | | Storage Model |
| string-set!: | | Strings |
| string-set!: | | Symbols |
| string-set!: | | R7RS |
| string-skip: | | SRFI 140 |
| string-skip-right: | | SRFI 140 |
| string-slice: | | Strings |
| string-split: | | SRFI 140 |
| string-splitter: | | Strings |
| string-start: | | Regular S-Expressions |
| string-suffix-ci?: | | Searching and Matching Strings |
| string-suffix-length: | | SRFI 140 |
| string-suffix?: | | Searching and Matching Strings |
| string-suffix?: | | SRFI 140 |
| string-tabulate: | | SRFI 140 |
| string-tail: | | Strings |
| string-take: | | SRFI 140 |
| string-take-right: | | SRFI 140 |
| string-titlecase: | | Strings |
| string-titlecase: | | SRFI 129 |
| string-titlecase: | | SRFI 140 |
| string-trim: | | Strings |
| string-trim: | | SRFI 140 |
| string-trim-both: | | SRFI 140 |
| string-trim-left: | | Strings |
| string-trim-right: | | Strings |
| string-trim-right: | | SRFI 140 |
| string-trimmer: | | Strings |
| string-unfold: | | SRFI 140 |
| string-unfold-right: | | SRFI 140 |
| string-upcase: | | Strings |
| string-upcase: | | R7RS |
| string-upcase: | | SRFI 140 |
| string-upper-case?: | | Strings |
| string-word-breaks: | | Strings |
| string-wt-type: | | Construction of Weight-Balanced Trees |
| string<=?: | | Strings |
| string<=?: | | R7RS |
| string<=?: | | SRFI 140 |
| string<?: | | Strings |
| string<?: | | R7RS |
| string<?: | | SRFI 140 |
| string=?: | | Equivalence Predicates |
| string=?: | | Equivalence Predicates |
| string=?: | | Strings |
| string=?: | | Strings |
| string=?: | | Symbols |
| string=?: | | Symbols |
| string=?: | | Construction of Hash Tables |
| string=?: | | Construction of Hash Tables |
| string=?: | | R7RS |
| string=?: | | SRFI 140 |
| string>=?: | | Strings |
| string>=?: | | R7RS |
| string>=?: | | SRFI 140 |
| string>?: | | Strings |
| string>?: | | R7RS |
| string>?: | | SRFI 140 |
| string?: | | Strings |
| string?: | | R7RS |
| string?: | | SRFI 140 |
| strong-hash-table/constructor: | | Construction of Hash Tables |
| sublist: | | Cutting and Pasting Lists |
| substring: | | Strings |
| substring: | | R7RS |
| substring: | | SRFI 140 |
| substring->parser-buffer: | | Parser Buffers |
| substring?: | | Searching and Matching Strings |
| subvector: | | Cutting Vectors |
| subvector->list: | | Construction of Lists |
| subvector-fill!: | | Modifying Vectors |
| subvector-move-left!: | | Modifying Vectors |
| subvector-move-right!: | | Modifying Vectors |
| sum-accumulator: | | SRFI 158 |
| symbol->string: | | Storage Model |
| symbol->string: | | Equivalence Predicates |
| symbol->string: | | Equivalence Predicates |
| symbol->string: | | Symbols |
| symbol->string: | | R7RS |
| symbol-append: | | Symbols |
| symbol-hash: | | Symbols |
| symbol-hash: | | SRFI 128 |
| symbol-hash-mod: | | Symbols |
| symbol<?: | | Symbols |
| symbol=?: | | R7RS |
| symbol?: | | Symbols |
| symbol?: | | R7RS |
| syntax-error: | | R7RS |
| syntax-rules: | | Pattern Language |
| syntax-rules: | | R7RS |
| system-clock: | | Machine Time |
| system-global-environment: | | Environment Variables |
| system-library-directory-pathname: | | Miscellaneous Pathnames |
| system-library-pathname: | | Miscellaneous Pathnames |
|
| T | | |
|---|
| t: | | Booleans |
| take: | | Cutting and Pasting Lists |
| take: | | SRFI 1 |
| take!: | | SRFI 1 |
| take-right: | | SRFI 1 |
| take-while: | | SRFI 1 |
| take-while!: | | SRFI 1 |
| tan: | | Numerical operations |
| tan: | | R7RS |
| tan-pi*: | | Numerical operations |
| tcp-server-connection-accept: | | TCP Sockets |
| template: | | Entry Format |
| temporary-directory-pathname: | | File Manipulation |
| temporary-file-pathname: | | File Manipulation |
| tenth: | | Selecting List Components |
| tenth: | | SRFI 1 |
| textual-i/o-port-type?: | | Textual Port Types |
| textual-input-port->parser-buffer: | | Parser Buffers |
| textual-input-port-type?: | | Textual Port Types |
| textual-output-port-type?: | | Textual Port Types |
| textual-port-operation: | | Constructors and Accessors for Textual Ports |
| textual-port-operation-names: | | Constructors and Accessors for Textual Ports |
| textual-port-state: | | Constructors and Accessors for Textual Ports |
| textual-port-type: | | Constructors and Accessors for Textual Ports |
| textual-port-type?: | | Textual Port Types |
| textual-port?: | | Ports |
| textual-port?: | | R7RS |
| the-environment: | | Top-level Environments |
| third: | | Selecting List Components |
| third: | | SRFI 1 |
| thunk?: | | Arity |
| time-zone->string: | | External Representation of Time |
| time-zone?: | | Decoded Time |
| toggle-bit: | | Bit operations |
| top-level-environment?: | | Top-level Environments |
| trace-output-port: | | Ports |
| trailing: | | Strings |
| trailing: | | Strings |
| transform: | | *Parser |
| tree-copy: | | Pairs |
| true: | | Booleans |
| truncate: | | Numerical operations |
| truncate: | | R7RS |
| truncate->exact: | | Numerical operations |
| truncate-quotient: | | Numerical operations |
| truncate-quotient: | | R7RS |
| truncate-remainder: | | Numerical operations |
| truncate-remainder: | | R7RS |
| truncate/: | | Numerical operations |
| truncate/: | | R7RS |
| type: | | Structure Definitions |
| type: | | Structure Definitions |
| type-descriptor: | | Structure Definitions |
|
| U | | |
|---|
| u8-ready?: | | Input Procedures |
| u8-ready?: | | R7RS |
| ucs-range->char-set: | | SRFI 14 |
| ucs-range->char-set!: | | SRFI 14 |
| unbind-variable: | | Top-level Environments |
| unfold: | | SRFI 1 |
| unfold-right: | | SRFI 1 |
| unhash: | | Object Hashing |
| unhash-object: | | Object Hashing |
| unicode-char?: | | Unicode |
| unicode-code-point?: | | Unicode |
| unicode-scalar-value?: | | Unicode |
| universal-time->file-time: | | Time-Format Conversion |
| universal-time->global-decoded-time: | | Time-Format Conversion |
| universal-time->global-time-string: | | Time-Format Conversion |
| universal-time->local-decoded-time: | | Time-Format Conversion |
| universal-time->local-time-string: | | Time-Format Conversion |
| unless: | | R7RS |
| unparser/set-tagged-pair-method!: | | Custom Output |
| unparser/set-tagged-vector-method!: | | Custom Output |
| unquote: | | Quoting |
| unquote: | | Lists |
| unquote: | | R7RS |
| unquote-splicing: | | Quoting |
| unquote-splicing: | | Lists |
| unquote-splicing: | | R7RS |
| unread-char: | | Input Procedures |
| unsigned-integer->bit-string: | | Integer Conversions of Bit Strings |
| unzip1: | | SRFI 1 |
| unzip2: | | SRFI 1 |
| unzip3: | | SRFI 1 |
| unzip4: | | SRFI 1 |
| unzip5: | | SRFI 1 |
| use-pty?: | | Subprocess Options |
| use-value: | | Restarts |
| use-value: | | Invoking Standard Restart Code |
| user-homedir-pathname: | | Miscellaneous Pathnames |
| user-initial-environment: | | Initial and Current Environments |
| user-initial-environment: | | Environment Variables |
| user-initial-environment: | | REPL Environment |
| utf16->string: | | SRFI 140 |
| utf16be->string: | | SRFI 140 |
| utf16le->string: | | SRFI 140 |
| utf8->string: | | R7RS |
| utf8->string: | | SRFI 140 |
|
| V | | |
|---|
| valid-hash-number?: | | Object Hashing |
| valid-object-hash?: | | Object Hashing |
| valid-sre?: | | SRFI 115 |
| values: | | Continuations |
| values: | | *Parser |
| values: | | R7RS |
| vector: | | Construction of Vectors |
| vector: | | R7RS |
| vector->generator: | | SRFI 158 |
| vector->list: | | Construction of Lists |
| vector->list: | | Construction of Vectors |
| vector->list: | | R7RS |
| vector->string: | | Construction of Vectors |
| vector->string: | | R7RS |
| vector->string: | | SRFI 140 |
| vector-accumulator: | | SRFI 158 |
| vector-accumulator!: | | SRFI 158 |
| vector-any: | | SRFI 133 |
| vector-append: | | R7RS |
| vector-append-subvectors: | | SRFI 133 |
| vector-binary-search: | | Selecting Vector Components |
| vector-binary-search: | | SRFI 133 |
| vector-comparator: | | SRFI 162 |
| vector-concatenate: | | SRFI 133 |
| vector-copy: | | Construction of Vectors |
| vector-copy: | | R7RS |
| vector-copy!: | | R7RS |
| vector-count: | | SRFI 133 |
| vector-cumulate: | | SRFI 133 |
| vector-eighth: | | Selecting Vector Components |
| vector-empty?: | | SRFI 133 |
| vector-every: | | SRFI 133 |
| vector-fifth: | | Selecting Vector Components |
| vector-fill!: | | Modifying Vectors |
| vector-fill!: | | R7RS |
| vector-first: | | Selecting Vector Components |
| vector-fold: | | SRFI 133 |
| vector-fold-right: | | SRFI 133 |
| vector-for-each: | | Construction of Vectors |
| vector-for-each: | | R7RS |
| vector-fourth: | | Selecting Vector Components |
| vector-grow: | | Construction of Vectors |
| vector-head: | | Cutting Vectors |
| vector-index: | | SRFI 133 |
| vector-index-right: | | SRFI 133 |
| vector-length: | | Implementation restrictions |
| vector-length: | | Selecting Vector Components |
| vector-length: | | R7RS |
| vector-map: | | Construction of Vectors |
| vector-map: | | R7RS |
| vector-map!: | | SRFI 133 |
| vector-partition: | | SRFI 133 |
| vector-ref: | | Storage Model |
| vector-ref: | | Selecting Vector Components |
| vector-ref: | | R7RS |
| vector-reverse!: | | SRFI 133 |
| vector-reverse-copy: | | SRFI 133 |
| vector-reverse-copy!: | | SRFI 133 |
| vector-second: | | Selecting Vector Components |
| vector-set!: | | Selecting Vector Components |
| vector-set!: | | R7RS |
| vector-seventh: | | Selecting Vector Components |
| vector-sixth: | | Selecting Vector Components |
| vector-skip: | | SRFI 133 |
| vector-skip-right: | | SRFI 133 |
| vector-swap!: | | SRFI 133 |
| vector-tail: | | Cutting Vectors |
| vector-third: | | Selecting Vector Components |
| vector-unfold: | | SRFI 133 |
| vector-unfold!: | | SRFI 133 |
| vector-unfold-right: | | SRFI 133 |
| vector-unfold-right!: | | SRFI 133 |
| vector=: | | SRFI 133 |
| vector?: | | Selecting Vector Components |
| vector?: | | R7RS |
| versin: | | Numerical operations |
| versin-pi*: | | Numerical operations |
|
| W | | |
|---|
| warn: | | Condition Signalling |
| warn: | | Condition Signalling |
| warn: | | Invoking Standard Restart Code |
| weak-car: | | Weak Pairs |
| weak-cdr: | | Weak Pairs |
| weak-cons: | | Weak Pairs |
| weak-hash-table/constructor: | | Construction of Hash Tables |
| weak-pair/car?: | | Weak Pairs |
| weak-pair?: | | Weak Pairs |
| weak-set-car!: | | Weak Pairs |
| weak-set-cdr!: | | Weak Pairs |
| when: | | R7RS |
| where: | | Prompting |
| with-current-parser-macros: | | Parser-language Macros |
| with-current-unparser-state: | | Custom Output |
| with-exception-handler: | | R7RS |
| with-input-from-binary-file: | | File Ports |
| with-input-from-file: | | File Ports |
| with-input-from-file: | | R7RS |
| with-input-from-port: | | Ports |
| with-input-from-string: | | String Ports |
| with-input-port-blocking-mode: | | Blocking Mode |
| with-input-port-terminal-mode: | | Terminal Mode |
| with-interaction-i/o-port: | | Ports |
| with-notification-output-port: | | Ports |
| with-output-port-blocking-mode: | | Blocking Mode |
| with-output-port-terminal-mode: | | Terminal Mode |
| with-output-to-binary-file: | | File Ports |
| with-output-to-file: | | File Ports |
| with-output-to-file: | | R7RS |
| with-output-to-port: | | Ports |
| with-output-to-string: | | String Ports |
| with-output-to-truncated-string: | | String Ports |
| with-pointer: | | *Matcher |
| with-pointer: | | *Parser |
| with-restart: | | Error System |
| with-restart: | | Restarts |
| with-restart: | | Establishing Restart Code |
| with-restart: | | Finding and Invoking General Restart Code |
| with-simple-restart: | | Restarts |
| with-simple-restart: | | Restarts |
| with-simple-restart: | | Establishing Restart Code |
| with-simple-restart: | | Finding and Invoking General Restart Code |
| with-timings: | | Machine Time |
| with-trace-output-port: | | Ports |
| with-working-directory-pathname: | | Working Directory |
| withdraw-window on x-graphics-device: | | Custom Operations on X Graphics Devices |
| within-continuation: | | Continuations |
| working-directory: | | Subprocess Options |
| working-directory-pathname: | | Working Directory |
| write: | | External Representations |
| write: | | Symbols |
| write: | | Symbols |
| write: | | Ports |
| write: | | String Ports |
| write: | | String Ports |
| write: | | Output Procedures |
| write: | | Error Messages |
| write: | | R7RS |
| write-bytevector: | | Output Procedures |
| write-bytevector: | | R7RS |
| write-char: | | Entry Format |
| write-char: | | Ports |
| write-char: | | Output Procedures |
| write-char: | | R7RS |
| write-char on textual output port: | | Textual Output Port Operations |
| write-condition-report: | | Condition Handling |
| write-condition-report: | | Condition State |
| write-condition-report: | | Simple Condition Instance Operations |
| write-line: | | Output Procedures |
| write-restart-report: | | The Named Restart Abstraction |
| write-shared: | | Output Procedures |
| write-shared: | | R7RS |
| write-simple: | | Output Procedures |
| write-simple: | | R7RS |
| write-string: | | Output Procedures |
| write-string: | | Format |
| write-string: | | R7RS |
| write-substring: | | Output Procedures |
| write-substring on textual output port: | | Textual Output Port Operations |
| write-to-string: | | String Ports |
| write-u8: | | Ports |
| write-u8: | | Output Procedures |
| write-u8: | | R7RS |
| write-xml: | | XML Output |
| write-xml-file: | | XML Output |
| wt-tree/add: | | Basic Operations on Weight-Balanced Trees |
| wt-tree/add!: | | Basic Operations on Weight-Balanced Trees |
| wt-tree/delete: | | Basic Operations on Weight-Balanced Trees |
| wt-tree/delete!: | | Basic Operations on Weight-Balanced Trees |
| wt-tree/delete-min: | | Indexing Operations on Weight-Balanced Trees |
| wt-tree/delete-min!: | | Indexing Operations on Weight-Balanced Trees |
| wt-tree/difference: | | Advanced Operations on Weight-Balanced Trees |
| wt-tree/empty?: | | Basic Operations on Weight-Balanced Trees |
| wt-tree/fold: | | Advanced Operations on Weight-Balanced Trees |
| wt-tree/for-each: | | Advanced Operations on Weight-Balanced Trees |
| wt-tree/index: | | Indexing Operations on Weight-Balanced Trees |
| wt-tree/index-datum: | | Indexing Operations on Weight-Balanced Trees |
| wt-tree/index-pair: | | Indexing Operations on Weight-Balanced Trees |
| wt-tree/intersection: | | Advanced Operations on Weight-Balanced Trees |
| wt-tree/lookup: | | Basic Operations on Weight-Balanced Trees |
| wt-tree/member?: | | Basic Operations on Weight-Balanced Trees |
| wt-tree/min: | | Indexing Operations on Weight-Balanced Trees |
| wt-tree/min-datum: | | Indexing Operations on Weight-Balanced Trees |
| wt-tree/min-pair: | | Indexing Operations on Weight-Balanced Trees |
| wt-tree/rank: | | Indexing Operations on Weight-Balanced Trees |
| wt-tree/set-equal?: | | Advanced Operations on Weight-Balanced Trees |
| wt-tree/size: | | Basic Operations on Weight-Balanced Trees |
| wt-tree/split<: | | Advanced Operations on Weight-Balanced Trees |
| wt-tree/split>: | | Advanced Operations on Weight-Balanced Trees |
| wt-tree/subset?: | | Advanced Operations on Weight-Balanced Trees |
| wt-tree/union: | | Advanced Operations on Weight-Balanced Trees |
| wt-tree/union-merge: | | Advanced Operations on Weight-Balanced Trees |
| wt-tree?: | | Basic Operations on Weight-Balanced Trees |
|
| X | | |
|---|
| x-character-bounds/ascent: | | Custom Operations on X Graphics Devices |
| x-character-bounds/descent: | | Custom Operations on X Graphics Devices |
| x-character-bounds/lbearing: | | Custom Operations on X Graphics Devices |
| x-character-bounds/rbearing: | | Custom Operations on X Graphics Devices |
| x-character-bounds/width: | | Custom Operations on X Graphics Devices |
| x-close-all-displays: | | Utilities for X Graphics |
| x-font-structure/all-chars-exist: | | Custom Operations on X Graphics Devices |
| x-font-structure/character-bounds: | | Custom Operations on X Graphics Devices |
| x-font-structure/default-char: | | Custom Operations on X Graphics Devices |
| x-font-structure/direction: | | Custom Operations on X Graphics Devices |
| x-font-structure/max-ascent: | | Custom Operations on X Graphics Devices |
| x-font-structure/max-bounds: | | Custom Operations on X Graphics Devices |
| x-font-structure/max-descent: | | Custom Operations on X Graphics Devices |
| x-font-structure/min-bounds: | | Custom Operations on X Graphics Devices |
| x-font-structure/name: | | Custom Operations on X Graphics Devices |
| x-font-structure/start-index: | | Custom Operations on X Graphics Devices |
| x-geometry-string: | | Utilities for X Graphics |
| x-graphics/close-display: | | Utilities for X Graphics |
| x-graphics/open-display: | | Utilities for X Graphics |
| x-open-display: | | X Graphics Type |
| x-size on textual output port: | | Textual Output Port Operations |
| xcons: | | Pairs |
| xcons: | | SRFI 1 |
| xml-!attlist: | | XML Structure |
| xml-!attlist-definitions: | | XML Structure |
| xml-!attlist-name: | | XML Structure |
| xml-!attlist?: | | XML Structure |
| xml-!element: | | XML Structure |
| xml-!element-content-type: | | XML Structure |
| xml-!element-name: | | XML Structure |
| xml-!element?: | | XML Structure |
| xml-!entity: | | XML Structure |
| xml-!entity-name: | | XML Structure |
| xml-!entity-value: | | XML Structure |
| xml-!entity?: | | XML Structure |
| xml-!notation: | | XML Structure |
| xml-!notation-id: | | XML Structure |
| xml-!notation-name: | | XML Structure |
| xml-!notation?: | | XML Structure |
| xml->string: | | XML Output |
| xml->wide-string: | | XML Output |
| xml-declaration: | | XML Structure |
| xml-declaration-encoding: | | XML Structure |
| xml-declaration-standalone: | | XML Structure |
| xml-declaration-version: | | XML Structure |
| xml-declaration?: | | XML Structure |
| xml-document: | | XML Structure |
| xml-document-declaration: | | XML Structure |
| xml-document-dtd: | | XML Structure |
| xml-document-misc-1: | | XML Structure |
| xml-document-misc-2: | | XML Structure |
| xml-document-misc-3: | | XML Structure |
| xml-document-root: | | XML Structure |
| xml-document?: | | XML Structure |
| xml-dtd: | | XML Structure |
| xml-dtd-external: | | XML Structure |
| xml-dtd-internal: | | XML Structure |
| xml-dtd-root: | | XML Structure |
| xml-dtd?: | | XML Structure |
| xml-element: | | XML Structure |
| xml-element-attributes: | | XML Structure |
| xml-element-content: | | XML Structure |
| xml-element-name: | | XML Structure |
| xml-element?: | | XML Structure |
| xml-external-id: | | XML Structure |
| xml-external-id-id: | | XML Structure |
| xml-external-id-uri: | | XML Structure |
| xml-external-id?: | | XML Structure |
| xml-name->symbol: | | XML Names |
| xml-name-local: | | XML Names |
| xml-name-prefix: | | XML Names |
| xml-name-string: | | XML Names |
| xml-name-uri: | | XML Names |
| xml-name=?: | | XML Names |
| xml-name?: | | XML Names |
| xml-nmtoken?: | | XML Names |
| xml-parameter-!entity: | | XML Structure |
| xml-parameter-!entity-name: | | XML Structure |
| xml-parameter-!entity-value: | | XML Structure |
| xml-parameter-!entity?: | | XML Structure |
| xml-processing-instructions: | | XML Structure |
| xml-processing-instructions-name: | | XML Structure |
| xml-processing-instructions-text: | | XML Structure |
| xml-processing-instructions?: | | XML Structure |
| xml-qname-local: | | XML Names |
| xml-qname-prefix: | | XML Names |
| xml-qname?: | | XML Names |
| xml-unparsed-!entity: | | XML Structure |
| xml-unparsed-!entity-id: | | XML Structure |
| xml-unparsed-!entity-name: | | XML Structure |
| xml-unparsed-!entity-notation: | | XML Structure |
| xml-unparsed-!entity?: | | XML Structure |
| xml-uri: | | XML Names |
| xmlns-uri: | | XML Names |
| xsubstring: | | SRFI 140 |
|
| Y | | |
|---|
| y-size: | | Textual Port Primitives |
| y-size on textual output port: | | Textual Output Port Operations |
|
| Z | | |
|---|
| zero?: | | Numerical operations |
| zero?: | | Numerical operations |
| zero?: | | R7RS |
| zip: | | SRFI 1 |
|