Bigloo

& * + - . / 8 < = > @ A B C D E F G H I J K L M N O P Q R S T U V W Z

&
`&imap-error`
`&imap-parse-error`
`&mailbox-error`
`&maildir-error`

*
`*`
`*bx`
`dynamic-load-path`
`*elong`
`*fl`
`*fx`
`*llong`
`load-path`
	...
`pp-case`
`pp-width`

+
`+`
`+bx`
`+elong`
`+fl`
`+fx`
`+llong`

-
`-`
->
	...
`-bx`
`-elong`
`-fl`
`-fx`
`-llong`

.
.afile
.bigloorc

/
`/`
`/bx`
`/elong`
`/fl`
`/fx`
`/llong`

8
`8bits->utf8`
`8bits->utf8!`

<
`<`
`<=`
`<=bx`
`<=elong`
`<=fl`
`<=fx`
`<=llong`
`<bx`
`<elong`
`<fl`
`<fx`
`<lllong`

=
`=`
`=bx`
`=elong`
`=fl`
`=fx`
`=llong`

>
`>`
`>=`
`>=bx`
`>=elong`
`>=fl`
`>=fx`
`>=llong`
`>bx`
`>elong`
`>fl`
`>fx`
`>lllong`

@
@

A
`abandoned-mutex-exception?`
`abs`
`absfl`
abstract-class
`acos`
`acosfl`
`aes-ctr-decrypt`
`aes-ctr-decrypt-file`
`aes-ctr-decrypt-mmap`
`aes-ctr-decrypt-port`
`aes-ctr-decrypt-string`
`aes-ctr-encrypt`
`aes-ctr-encrypt-file`
`aes-ctr-encrypt-mmap`
`aes-ctr-encrypt-port`
`aes-ctr-encrypt-string`
`and`
`and-let*`
`any`
`append`
`append!`
`append-map`
`append-map!`
`append-output-binary-file`
`append-output-file`
`apply`
`args-parse`
`args-parse-usage`
`ascii-string?`
`asin`
`asinfl`
`assert`
`assoc`
`assq`
`assv`
`atan`
`atanfl`

B
`base64-decode`
`base64-decode-port`
`base64-encode`
`base64-encode-port`
`basename`
`begin`
`bibtex`
`bibtex-file`
`bibtex-parse-authors`
`bibtex-port`
`bibtex-string`
`bigloo-class-demangle`
`bigloo-class-mangled?`
`bigloo-compiler-debug`
`bigloo-compiler-debug-set!`
`bigloo-config`
`bigloo-debug`
`bigloo-debug-set!`
`bigloo-demangle`
`bigloo-dns-cache-validity-timeout`
`bigloo-dns-cache-validity-timeout-set!`
`bigloo-dns-enable-cache`
`bigloo-dns-enable-cache-set!`
`bigloo-eval-strict-module`
`bigloo-eval-strict-module-set!`
`bigloo-library-path`
`bigloo-library-path-set!`
`bigloo-mangle`
`bigloo-mangled?`
`bigloo-module-mangle`
`bigloo-need-mangling`
`bigloo-strict-r5rs-strings`
`bigloo-strict-r5rs-strings-set!`
`bigloo-trace`
`bigloo-trace-color`
`bigloo-trace-color-set!`
`bigloo-trace-set!`
`bigloo-trace-stack-depth`
`bigloo-trace-stack-depth-set!`
`bigloo-warning`
`bigloo-warning-set!`
`bignum->octet-string`
`bignum->string`
`bignum?`
`binary-port?`
`bind-exit`
`bit-and`
`bit-andelong`
`bit-andllong`
`bit-lsh`
`bit-lshelong`
`bit-lshllong`
`bit-not`
`bit-notelong`
`bit-notllong`
`bit-or`
`bit-orelong`
`bit-orllong`
`bit-rsh`
`bit-rshelong`
`bit-rshllong`
`bit-ursh`
`bit-urshelong`
`bit-urshllong`
`bit-xor`
`bit-xorelong`
`bit-xorllong`
`blit-string!`
`bm-mmap`
`bm-string`
`bm-table`
`bmh-mmap`
`bmh-string`
`bmh-table`
`boolean?`
`broadcast!`
`byte-code-compile`
`byte-code-run`

C
`caaar`
`caadr`
`caar`
`cadar`
`caddr`
`cadr`
`call-next-method`
`call-with-append-file`
`call-with-input-file`
`call-with-input-string`
`call-with-output-file`
`call-with-output-string`
`call-with-values`
`call/cc`
`car`
`case`
`cdddar`
`cddddr`
`cdr`
`ceiling`
`ceilingfl`
`certificate-issuer`
`certificate-subject`
`char->integer`
`char->ucs2`
`char-alphabetic?`
`char-ci<=?`
`char-ci<?`
`char-ci=?`
`char-ci>=?`
`char-ci>?`
`char-downcase`
`char-lower-case?`
`char-numeric?`
`char-ready?`
`char-upcase`
`char-upper-case?`
`char-whitespace?`
`char<=?`
`char<?`
`char=?`
`char>=?`
`char>?`
`char?`
`chdir`
`chmod`
class
	...
`class-all-fields`
`class-creator`
`class-field-accessor`
`class-field-info`
`class-field-mutable?`
`class-field-mutator`
`class-field-name`
`class-field?`
`class-fields`
`class-name`
`class-nil`
`class-predicate`
`class-subclasses`
`class-super`
`class?`
`client-socket-use-ssl!`
`close-binary-port`
`close-input-port`
`close-mmap`
`close-output-port`
`close-process-ports`
`close-semaphore`
`closed-input-port?`
`closed-output-port?`
`closelog`
`co-instantiate`
`command-line`
`Complete-DSA-Key`
`Complete-ElGamal-Key`
`Complete-RSA-Key`
`complex?`
`cond`
`cond-expand`
`condition-variable-broadcast!`
`condition-variable-name`
`condition-variable-signal!`
`condition-variable-specific`
`condition-variable-specific-set!`
`condition-variable-wait!`
`condition-variable?`
`cons`
`cons*`
`copy-file`
`copy-vector`
`cos`
`cosfl`
`cp1252->utf8`
`cp1252->utf8!`
`cram-md5sum-string`
`crc`
`crc-elong-le::elong`
`crc-elong::elong`
`crc-file`
`crc-length`
`crc-llong-le::llong`
`crc-llong::llong`
`crc-long-le::long`
`crc-long::long`
`crc-mmap`
`crc-names`
`crc-polynomial`
`crc-polynomial-be->le`
`crc-polynomial-le`
`crc-port`
`crc-string`
`create-hashtable`
`csv-for-each`
`csv-map`
`current-date`
`current-error-port`
`current-exception-handler`
`current-input-port`
`current-microseconds`
`current-nanoseconds`
`current-output-port`
`current-scheduler`
`current-seconds`
`current-thread`
`current-time`

D
`datagram-socket-receive`
`datagram-socket-send`
`date`
`date->iso8601-date`
`date->nanoseconds`
`date->rfc2822-date`
`date->seconds`
`date->string`
`date->utc-string`
`date-copy`
`date-day`
`date-hour`
`date-is-dst`
`date-minute`
`date-month`
`date-month-length`
`date-nanosecond`
`date-second`
`date-timezone`
`date-wday`
`date-week-day`
`date-yday`
`date-year`
`date-year-day`
`date?`
`day-aname`
`day-name`
`day-seconds`
`declare-library!`
`decrypt-file::bstring`
`decrypt-mmap::bstring`
`decrypt-port::bstring`
`decrypt-sendchars`
`decrypt-string::bstring`
`decrypt::bstring`
`default-scheduler`
`define`
`define-expander`
`define-generic`
`define-inline`
`define-macro`
`define-method`
`define-reader-ctor`
`define-record-type`
`define-struct`
`define-syntax`
`delay`
`delete`
`delete!`
`delete-directory`
`delete-duplicates`
`delete-duplicates!`
`delete-file`
`delete-semaphore`
directives
`directory->list`
`directory->path-list`
`directory?`
`dirname`
`display`
`display*`
`display-circle`
`display-string`
`display-substring`
`do`
`double->ieee-string`
`double->llong-bits`
`drop`
`DSA-Key`
`dsa-sign`
`dsa-verify`
`dump-trace-stack`
duplicate
`duplicate::`
`dynamic-load`
`dynamic-load-symbol`
`dynamic-load-symbol-get`
`dynamic-load-symbol-set`
`dynamic-unload`
`dynamic-wind`

E
`elgamal-decrypt`
`elgamal-encrypt`
`ElGamal-Key`
`elgamal-key-length`
`elong->fixnum`
`elong->flonum`
`elong->string`
`elong?`
`email-normalize`
`encrypt-file::bstring`
`encrypt-mmap::bstring`
`encrypt-port::bstring`
`encrypt-sendchars`
`encrypt-string::bstring`
`encrypt::bstring`
`eof-object?`
`eq?`
`equal?`
`eqv?`
`error`
`error-notify`
`error/location`
`eval`
`even?`
`evenbx?`
`evenelong?`
`evenfl?`
`evenfx?`
`evenllong?`
`every`
`exact->inexact`
`exact?`
`exception-notify`
`executable-name`
`exif`
`exif-date->date`
`exit`
`exp`
`expand`
`expand-once`
`expfl`
`export`
`expt`
`exptfl`
`extern`
`extract-private-rsa-key`
`extract-public-dsa-key`
`extract-public-elgamal-key`
`extract-public-rsa-key`

F
`file->string`
`file-access-time`
`file-change-time`
`file-exists?`
`file-gid`
`file-gzip?`
`file-mode`
`file-modification-time`
`file-musictag`
`file-name->list`
`file-name-canonicalize`
`file-name-canonicalize!`
`file-name-unix-canonicalize`
`file-name-unix-canonicalize!`
`file-separator`
`file-size`
`file-times-set!`
`file-type`
`file-uid`
`filter`
`filter!`
`filter-map`
final-class
`find`
`find-class`
`find-class-field`
`find-file/path`
`find-tail`
`finitefl?`
`fixnum->elong`
`fixnum->flonum`
`fixnum->llong`
`fixnum?`
`flac-musictag`
`float->ieee-string`
`float->int-bits`
`flonum->elong`
`flonum->fixnum`
`flonum->llong`
`flonum?`
`floor`
`floorfl`
`flush-binary-port`
`flush-output-port`
`for-each`
`force`
`format`
`fprint`
`fprintf`
`free-pragma::`
`from`

G
`gb2312->ucs2`
`gcd`
`generate-rsa-key`

`gensym`
`genuuid`
`get-class-serialization`
`get-custom-serialization`
`get-interfaces`
`get-opaque-serialization`
`get-output-string`
`get-procedure-serialization`
`get-process-serialization`
`get-prompter`
`get-protocol`
`get-protocols`
`get-repl-error-notifier`
`get-signal-handler`
`get-trace-stack`
`getenv`
`getgid`
`getgroups`
`getpid`
`getppid`
`getprop`
`getpwnam`
`getpwuid`
`getuid`
`gunzip-parse-header`
`gunzip-sendchars`

H
`hashtable->list`
`hashtable->vector`
`hashtable-add!`
`hashtable-clear!`
`hashtable-contains?`
`hashtable-filter!`
`hashtable-for-each`
`hashtable-get`
`hashtable-key-list`
`hashtable-map`
`hashtable-put!`
`hashtable-remove!`
`hashtable-size`
`hashtable-update!`
`hashtable-weak-data?`
`hashtable-weak-keys?`
`hashtable?`
`hmac-md5sum-string`
`hmac-sha1sum-string`
`hmac-sha256sum-string`
`host`
`hostinfo`
`hostname`
`hsl->rgb`
`hsv->rgb`
`http`
`http-chunks->port`
`http-chunks->procedure`
`http-parse-header`
`http-parse-response`
`http-parse-status-line`
`http-read-crlf`
`http-read-line`
`http-response-body->port`
`http-send-chunks`
`http-url-parse`
`hyphenate`

I
`id3::musictag`
`ieee-string->double`
`ieee-string->float`
`if`
`ignore`
`imap`
`imap-capability`
`imap-login`
`imap-logout`
`import`
`include`
`inexact->exact`
`inexact?`
`infinitefl?`
`inflate-sendchars`
`input-char`
`input-fill-string!`
`input-obj`
`input-port-close-hook`
`input-port-close-hook-set!`
`input-port-length`
`input-port-name`
`input-port-name-set!`
`input-port-position`
`input-port-reopen!`
`input-port-timeout-set!`
`input-port?`
`input-string`
`input-string-port?`
instantiate
`instantiate::`
`instantiate::fthread`
`instantiate::pthread`
`int-bits->float`
`integer->char`
`integer->second`
`integer->string`
`integer->string/padding`
`integer->ucs2`
`integer?`
`interaction-environment`
`inverse-utf8-table`
`iota`
`is-a?`
`isa?`
`iso-latin->utf8`
`iso-latin->utf8!`
`iso8601-date->date`
`iso8601-parse-date`

J
`java`
`join-timeout-exception?`
`jpeg-exif`
`jpeg-exif-comment-set!`

K
`keyword->string`
`keyword->symbol`
`keyword?`
`kmp-mmap`
`kmp-string`
`kmp-table`

L
`labels`
`lalr-grammar`
`lambda`
`last-pair`
`lcm`
`leap-year?`
`length`
`let`
`let*`
`let-syntax`
`letrec`
`letrec*`
`letrec-syntax`
`library`
`library-exists?`
`library-load`
`library-translation-table-add!`
`list`
`list->string`
`list->TAGvector`
`list->ucs2-string`
`list->vector`
`list-copy`
`list-ref`
`list-split`
`list-tabulate`
`list-tail`
`list?`
`llong->fixnum`
`llong->flonum`
`llong->string`
`llong-bits->double`
`llong?`
`load`
`load-hyphens`
`loada`
`loadq`
`lockf`
`log`
`logfl`

M
`mail-header->list`
`mailbox`
`mailbox-close`
`mailbox-folder-create!`
`mailbox-folder-dates`
`mailbox-folder-delete!`
`mailbox-folder-delete-messages!`
`mailbox-folder-exists?`
`mailbox-folder-header-fields`
`mailbox-folder-move!`
`mailbox-folder-rename!`
`mailbox-folder-select!`
`mailbox-folder-status`
`mailbox-folder-uids`
`mailbox-folder-unselect!`
`mailbox-folders`
`mailbox-hostname`
`mailbox-message`
`mailbox-message-body`
`mailbox-message-create!`
`mailbox-message-delete!`
`mailbox-message-flags`
`mailbox-message-flags-set!`
`mailbox-message-header`
`mailbox-message-header-field`
`mailbox-message-header-list`
`mailbox-message-info`
`mailbox-message-move!`
`mailbox-message-path`
`mailbox-message-size`
`mailbox-prefix`
`mailbox-separator`
`mailbox-subscribe!`
`mailbox-unsubscribe!`
`maildir`
`main`
`make-asynchronous-signal`
`make-client-socket`
`make-condition-variable`
`make-csv-lexer`
`make-datagram-server-socket`
`make-datagram-unbound-socket`
`make-date`
`make-directories`
`make-directory`
`make-elong`
`make-file-name`
`make-file-path`
`make-hashtable`
`make-hyphens`
`make-list`
`make-llong`
`make-mutex`
`make-scheduler`
`make-server-socket`
`make-shared-library-name`
`make-spinlock`
`make-ssl-client-socket`
`make-ssl-server-socket`
`make-static-library-name`
`make-string`
`make-string-ptr-null`
`make-symlink`
`make-TAGvector`
`make-thread`
`make-ucs2-string`
`make-vector`
`make-void*-null`
`make-weakptr`
`map`
`map!`
`match-case`
`match-lambda`
`max`
`maxbx`
`maxfl`
`maxfx`
`maxvalelong`
`maxvalfx`
`maxvalllong`
`md5sum`
`md5sum-file`
`md5sum-mmap`
`md5sum-port`
`md5sum-string`
`member`
`memq`
`memv`
`mime-content-decode`
`mime-content-decode-port`
`mime-content-disposition-decode`
`mime-content-disposition-decode-port`
`mime-multipart-decode`
`mime-multipart-decode-port`
`min`
`minbx`
`minfl`
`minfx`
`minvalelong`
`minvalfx`
`minvalllong`
`mixer`
`mixer-close`
`mixer-volume-get`
`mixer-volume-set!`
`mmap-get-char`
`mmap-get-string`
`mmap-length`
`mmap-name`
`mmap-put-char!`
`mmap-put-string!`
`mmap-read-position`
`mmap-read-position-set!`
`mmap-ref`
`mmap-set!`
`mmap-substring`
`mmap-substring-set!`
`mmap-write-position`
`mmap-write-position-set!`
`mmap?`
`module`
module class
module export-all
module export-exports
module export-module
`modulo`
`month-aname`
`month-name`
`mp3-musictag`
`mpc::music`
`mpd`
`mpd-database`
`mpg123::musicproc`
`mplayer::musicproc`
Multi-line comments
`multiple-value-bind`
`music`
`music-close`
`music-closed?`
`music-crossfade`
`music-event-loop`
`music-meta`
`music-next`
`music-pause`
`music-play`
`music-playlist-add!`
`music-playlist-clear!`
`music-playlist-delete!`
`music-playlist-get`
`music-prev`
`music-random-set!`
`music-repeat-set!`
`music-reset!`
`music-reset-error!`
`music-seek`
`music-song`
`music-songpos`
`music-status`
`music-stop`
`music-update-status!`
`music-volume-get`
`music-volume-set!`
`musicproc::music`
`musicstatus`
`musictag`
`mutex-lock!`
`mutex-name`
`mutex-specific`
`mutex-specific-set!`
`mutex-state`
`mutex-unlock!`
`mutex?`

N
`nanfl?`
`nanoeconds->date`
`native-repl-printer`
`negative?`
`negativebx?`
`negativeelong?`
`negativefl?`
`negativefx?`
`negativellong?`
`negbx`
`negelong`
`negfl`
`negfx`
`negllong`
`newline`
`not`
`null-environment`
`null?`
`number->string`
`number?`

O
`obj->string`
`object->struct`
`object-class`
`object-constructor`
`object-display`
`object-equal?`
`object-hashnumber`
`object-write`
`octet-string->bignum`
`odd?`
`oddbx?`
`oddelong?`
`oddfl?`
`oddfx?`
`oddllong?`
`ogg-musictag`
`open-input-binary-file`
`open-input-c-string`
`open-input-file`
`open-input-ftp-file`
`open-input-gzip-file`
`open-input-gzip-port`
`open-input-inflate-file`
`open-input-procedure`
`open-input-string`
`open-input-string!`
`open-input-zlib-file`
`open-input-zlib-port`
`open-mmap`
`open-output-binary-file`
`open-output-file`
`open-output-procedure`
`open-output-string`
`open-pipes`
`open-semaphore`
`openlog`
`operator`
`option`
`or`
`os-arch`
`os-charset`
`os-class`
`os-name`
`os-tmp`
`os-version`
`output-byte`
`output-char`
`output-obj`
`output-port-close-hook`
`output-port-close-hook-set!`
`output-port-flush-buffer`
`output-port-flush-buffer-set!`
`output-port-flush-hook`
`output-port-flush-hook-set!`
`output-port-name`
`output-port-name-set!`
`output-port-position`
`output-port-timeout-set!`
`output-port?`
`output-string`
`output-string-port?`

P
`pair-or-null?`
`pair?`
`password`
`path-separator`
`peek-byte`
`peek-char`
`pem-decode-port`
`pem-read-file`
`pgp-add-key-to-db`
`pgp-add-keys-to-db`
`pgp-db-print-keys`
`pgp-decrypt`
`pgp-encrypt`
`pgp-key->string`
`pgp-key-fingerprint`
`pgp-key-id`
`pgp-key?`
`pgp-make-key-db`
`pgp-password-encrypt`
`pgp-read-file`
`pgp-read-port`
`pgp-read-string`
`pgp-resolve-key`
`pgp-sign`
`pgp-signature-message`
`pgp-subkey->string`
`pgp-subkey?`
`pgp-subkeys`
`pgp-verify`
`pgp-write-file`
`pgp-write-port`
`pgp-write-string`
`PKCS1-v1.5-pad`
`PKCS1-v1.5-unpad`
`port->gzip-port`
`port->inflate-port`
`port->list`
`port->sexp-list`
`port->string-list`
`port->vcard::vcard`
`port->zlib-port`
`port?`
`positive?`
`positivebx?`
`positiveelong?`
`positivefl?`
`positivefx?`
`positivellong?`
`pp`
`pragma::`
`prefix`
`pregexp`
`pregexp-match`
`pregexp-match-positions`
`pregexp-quote`
`pregexp-replace`
`pregexp-replace*`
`pregexp-split`
`print`
`printf`
`procedure?`
`process-alive?`
`process-continue`
`process-error-port`
`process-exit-status`
`process-input-port`
`process-kill`
`process-list`
`process-output-port`
`process-pid`
`process-send-signal`
`process-stop`
`process-wait`
`process?`
`putenv`
`putprop!`
`pwd`

Q
`quasiquote`
`quit`
`quote`
`quoted-printable-decode`
`quoted-printable-decode-port`
`quoted-printable-encode`
`quoted-printable-encode-port`
`quotient`

`quotientelong`
`quotientllong`

R
`raise`
`random`
`randombx`
`randomfl`
`rational?`
`read`
`read-byte`
`read-case-insensitive`
`read-case-sensitive`
`read-certificate`
`read-char`
`read-chars`
`read-chars!`
`read-csv-record`
`read-csv-records`
`read-fill-string!`
`read-line`
`read-line-newline`
`read-lines`
`read-m3u`
`read-of-strings`
`read-pem-file`
`read-pem-key`
`read-pem-key-file`
`read-pem-key-port`
`read-pem-key-string`
`read-private-key`
`read-string`
`read/case`
`read/lalrp`
`read/rp`
`real->string`
`real?`
`receive`
`reduce`
`register-class-serialization!`
`register-compile-srfi!`
`register-crc!`
`register-custom-serialization!`
`register-exit-function!`
`register-opaque-serialization!`
`register-procedure-serialization!`
`register-process-serialization!`
`register-srfi!`
`regular-grammar`
`relative-file-name`
`remainder`
`remainderelong`
`remainderfl`
`remainderllong`
`remprop!`
`remq`
`remq!`
`rename-file`
`repl`
`reset-output-port`
`reverse`
`reverse!`
`rfc2047-decode`
`rfc2047-decode-port`
`rfc2822-address-display-name`
`rfc2822-date->date`
`rfc2822-parse-date`
`rgb-hsl`
`rgb-hsv`
`rgc-context`
`round`
`roundfl`
`rsa-decrypt`
`rsa-encrypt`
`RSA-Key`
`rsa-key-length`
`rsa-key=?`
`rsa-sign`
`rsa-verify`
`RSADP`
`RSAEP`
`RSAES-OAEP-decrypt`
`RSAES-OAEP-encrypt`
`RSAES-PKCS1-v1.5-decrypt`
`RSAES-PKCS1-v1.5-encrypt`
`RSASP1`
`RSASSA-PKCS1-v1.5-sign`
`RSASSA-PKCS1-v1.5-sign-bignum`
`RSASSA-PKCS1-v1.5-verify`
`RSASSA-PKCS1-v1.5-verify-bignum`
`RSASSA-PSS-sign`
`RSASSA-PSS-verify`
`RSAVP1`
`run-process`

S
`scheduler-broadcast!`
`scheduler-instant`
`scheduler-react!`
`scheduler-start!`
`scheduler-strict-order?`
`scheduler-strict-order?-set!`
`scheduler-terminate!`
`scheduler?`
`scheme-report-environment`
`seconds->date`
`seconds->string`
`seconds->utc-string`
`seed-random!`
`select`
`semaphore-post`
`semaphore-trywait`
`semaphore-value`
`semaphore-wait`
`semaphore?`
`send-chars`
`send-file`
`set!`
`set-car!`
`set-cdr!`
`set-input-port-position!`
`set-output-port-position!`
`set-prompter!`
`set-read-syntax!`
`set-repl-error-notifier!`
`set-repl-printer!`
`setgid`
`setuid`
`sha1sum`
`sha1sum-file`
`sha1sum-mmap`
`sha1sum-port`
`sha1sum-string`
`sha256sum`
`sha256sum-file`
`sha256sum-mmap`
`sha256sum-port`
`sha256sum-string`
`shrink!`
`signal`
`signbitfl`
`sin`
`sinfl`
`sleep`
`socket-accept`
`socket-client?`
`socket-close`
`socket-down?`
`socket-host-address`
`socket-hostname`
`socket-input`
`socket-local-address`
`socket-option`
`socket-option-set!`
`socket-output`
`socket-port-number`
`socket-server?`
`socket-shutdown`
`socket?`
`sort`
`soundcard::mixer`
`sqlite`
`sqlite-close`
`sqlite-eval`
`sqlite-exec`
`sqlite-format`
`sqlite-last-insert-rowid`
`sqlite-map`
`sqlite-name-of-tables`
`sqlite-table-name-of-columns`
`sqrt`
`sqrtfl`
`ssl-socket?`
`ssl-version`
`static`
`string`
`string->bignum`
`string->elong`
`string->key-hash`
`string->key-iterated-salted`
`string->key-salted`
`string->key-simple`
`string->key-zero`
`string->keyword`
`string->list`
`string->llong`
`string->mmap`
`string->number`
`string->obj`
`string->real`
`string->symbol`
`string->symbol-ci`
`string->vcard::vcard`
`string-append`
`string-capitalize`
`string-capitalize!`
`string-case`
`string-char-index`
`string-ci<=?`
`string-ci<?`
`string-ci=?`
`string-ci>=?`
`string-ci>?`
`string-compare3`
`string-compare3-ci`
`string-contains`
`string-contains-ci`
`string-copy`
`string-cut`
`string-delete`
`string-downcase`
`string-downcase!`
`string-fill!`
`string-for-read`
`string-hash`
`string-hex-extern`
`string-hex-intern`
`string-hex-intern!`
`string-index`
`string-index-right`
`string-length`
`string-natural-compare3`
`string-natural-compare3-ci`
`string-null?`
`string-prefix-ci?`
`string-prefix-length`
`string-prefix-length-ci`
`string-prefix?`
`string-ptr-null?`
`string-ref`
`string-replace`
`string-replace!`
`string-set!`
`string-shrink!`
`string-skip`
`string-skip-right`
`string-split`
`string-suffix-ci?`
`string-suffix-length`
`string-suffix-length-ci`
`string-suffix?`
`string-upcase`
`string-upcase!`
`string<=?`
`string<?`
`string=?`
`string>=?`
`string>?`
`string?`
`struct->object`
`struct?`
`substring`
`substring-at?`
`substring-ci-at?`
`substring-ci=?`
`substring=?`
`suffix`
`symbol->keyword`
`symbol->string`
`symbol-append`
`symbol-plist`
`symbol?`
`synchronize`
`syntax-rules`
`syslog`
`syslog-facility`
`syslog-level`
`syslog-option`
`system`
`system->string`

T
`TAGvector`
`TAGvector->list`
`TAGvector-length`
`TAGvector-ref`
`TAGvector-set!`
`TAGvector?`
`take`
`tan`
`tanfl`
`tar-header-checksum`
`tar-header-devmajor`
`tar-header-devminir`
`tar-header-gid`
`tar-header-gname`
`tar-header-linkname`
`tar-header-mode`
`tar-header-mtim`
`tar-header-name`
`tar-header-size`
`tar-header-type`
`tar-header-uid`
`tar-header-uname`
`tar-read-block`
`tar-read-header`
`tar-round-up-to-record-size`
`terminated-thread-exception?`
`the-byte`
`the-byte-ref`
`the-character`
`the-context`
`the-downcase-keyword`
`the-downcase-symbol`
`the-failure`
`the-fixnum`
`the-flonum`
`the-keyword`
`the-length`
`the-port`
`the-string`
`the-substring`
`the-subsymbol`
`the-symbol`
`the-upcase-keyword`
`the-upcase-symbol`
`thread-await!`
`thread-await*!`
`thread-await-values!`
`thread-await-values*!`
`thread-cleanup`
`thread-cleanup-set!`
`thread-get-values!`
`thread-get-values*!`
`thread-join!`
`thread-name`
`thread-parameter`
`thread-parameter-set!`
`thread-resume!`
`thread-sleep!`
`thread-specific`
`thread-specific-set!`
`thread-start!`
`thread-start-joinable!`
`thread-suspend!`
`thread-terminate!`
`thread-yield!`
`thread?`
`time`
`time->seconds`
`time?`
`trace-bold`
`trace-color`
`trace-item`
`trace-margin`
`trace-margin-set!`
`trace-port`
`trace-port-set!`
`trace-string`
`transcript-off`
`transcript-on`
`tree-copy`
`truncate`
`truncate-file`
`truncatefl`
`try`
`type`
`typeof`

U
`ucs2->char`
`ucs2->integer`
`ucs2-alphabetic?`
`ucs2-ci<=?`
`ucs2-ci<?`
`ucs2-ci=?`
`ucs2-ci>=?`
`ucs2-ci>?`
`ucs2-downcase`
`ucs2-lower-case?`
`ucs2-numeric?`
`ucs2-string`
`ucs2-string->list`
`ucs2-string->utf8-string`
`ucs2-string-append`
`ucs2-string-ci<=?`
`ucs2-string-ci<?`
`ucs2-string-ci=?`
`ucs2-string-ci>=?`
`ucs2-string-ci>?`
`ucs2-string-copy`
`ucs2-string-downcase`
`ucs2-string-downcase!`
`ucs2-string-fill!`
`ucs2-string-length`
`ucs2-string-ref`
`ucs2-string-set!`
`ucs2-string-upcase`
`ucs2-string-upcase!`
`ucs2-string<=?`
`ucs2-string<?`
`ucs2-string=?`
`ucs2-string>=?`
`ucs2-string>?`
`ucs2-string?`
`ucs2-substring`
`ucs2-upcase`
`ucs2-upper-case?`
`ucs2-whitespace?`
`ucs2<=?`
`ucs2<?`
`ucs2=?`
`ucs2>=?`
`ucs2>?`
`ucs2?`
`uncaught-exception-reason`
`uncaught-exception?`
`unix-path->list`
`unread-char!`
`unread-string!`
`unread-substring!`
`unregister-compile-srfi!`
`unregister-eval-srfi!`
`unregister-exit-function!`
`unregister-srfi!`
`unsigned->string`
`unspecified`
`untar`
`unwind-protect`
`uri-decode`
`uri-decode!`
`uri-decode-component`
`uri-decode-component!`
`uri-encode`
`uri-encode-component`
`url-decode`
`url-decode!`
`url-encode`
`url-parse`
`url-path-encode`
`url-sans-protocol-parse`
`use`
`utf8->8bits`
`utf8->8bits!`
`utf8->cp1252`
`utf8->cp1252!`
`utf8->iso-latin`
`utf8->iso-latin!`
`utf8->iso-latin-15`
`utf8->iso-latin-15!`
`utf8-codepoint-length`
`utf8-string->ucs2-string`
`utf8-string-encode`
`utf8-string-length`
`utf8-string-ref`
`utf8-string?`
`utf8-substring`

V
`values`
`vcard`
`vector`
`vector->list`
`vector-append`
`vector-copy`
`vector-copy!`
`vector-fill!`
`vector-for-each`
`vector-length`
`vector-map`
`vector-map!`
`vector-ref`
`vector-set!`
`vector-shrink!`
`vector?`
`void*-null?`
`vorbis::musictag`

W
`warning`
`warning-notify`
`warning/location`
`weakptr-data`
`weakptr?`
wide-class
`wide-object?`
widen!
`widen!::`
`with`
with-access
`with-access::`
`with-append-to-file`
`with-error-to-file`
`with-error-to-port`
`with-error-to-procedure`
`with-error-to-string`
`with-exception-handler`
`with-handler`
`with-input-from-file`
`with-input-from-port`
`with-input-from-procedure`
`with-input-from-string`
`with-lock`
`with-output-to-file`
`with-output-to-port`
`with-output-to-procedure`
`with-output-to-string`
`with-trace`
`write`
`write-byte`
`write-char`
`write-circle`
`write-m3u`
`write-pem-key`
`write-pem-key-file`
`write-pem-key-port`
`write-pem-key-string`

Z
`zero?`
`zerobx?`
`zeroelong?`
`zerofl?`
`zerofx?`
`zerollong?`