source: project/chicken/trunk/types.db @ 14987

;;;; types.db - Type-information for core library functions -*- Scheme -*-
;
; Copyright (c 2009, The Chicken Team
; All rights reserved.
;
; Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following
; conditions are met:
;
;   Redistributions of source code must retain the above copyright notice, this list of conditions and the following
;     disclaimer. 
;   Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
;     disclaimer in the documentation and/or other materials provided with the distribution. 
;   Neither the name of the author nor the names of its contributors may be used to endorse or promote
;     products derived from this software without specific prior written permission. 
;
; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
; AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
; CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
; CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
; SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION HOWEVER CAUSED AND ON ANY
; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
; OTHERWISE ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
; POSSIBILITY OF SUCH DAMAGE.


;; scheme
 
(not (procedure not (*) boolean))
(boolean? (procedure boolean (*) boolean))
(eq? (procedure eq? (* *) boolean))
(eqv? (procedure eqv? (* *) boolean))
(equal? (procedure equal? (* *) boolean))
(pair? (procedure pair? (*) boolean))
(cons (procedure cons (* *) pair))
(car (procedure car (pair) *))
(cdr (procedure cdr (pair) *))
(caar (procedure caar (pair) *))
(cadr (procedure cadr (pair) *))
(cdar (procedure cdar (pair) *))
(cddr (procedure cddr (pair) *))
(caaar (procedure caaar (pair) *))
(caadr (procedure caadr (pair) *))
(cadar (procedure cadar (pair) *))
(caddr (procedure caddr (pair) *))
(cdaar (procedure cdaar (pair) *))
(cdadr (procedure cdadr (pair) *))
(cddar (procedure cddar (pair) *))
(cdddr (procedure cdddr (pair) *))
(caaaar (procedure caaaar (pair) *))
(caaadr (procedure caaadr (pair) *))
(caadar (procedure caadar (pair) *))
(caaddr (procedure caaddr (pair) *))
(cadaar (procedure cadaar (pair) *))
(cadadr (procedure cadadr (pair) *))
(caddar (procedure caddar (pair) *))
(cadddr (procedure cadddr (pair) *))
(cdaaar (procedure cdaaar (pair) *))
(cdaadr (procedure cdaadr (pair) *))
(cdadar (procedure cdadar (pair) *))
(cdaddr (procedure cdaddr (pair) *))
(cddaar (procedure cddaar (pair) *))
(cddadr (procedure cddadr (pair) *))
(cdddar (procedure cdddar (pair) *))
(cddddr (procedure cddddr (pair) *))
(set-car! (procedure set-car! (pair *) undefined))
(set-cdr! (procedure set-cdr! (pair *) undefined))
(null? (procedure null? (*) boolean))
(list? (procedure list? (*) boolean))
(list (procedure list (#!rest) list))
(length (procedure length (list) fixnum))
(list-tail (procedure list-tail (list fixnum) *))
(list-ref (procedure list-ref (list fixnum) *))
(append (procedure append (list #!rest) list))
(reverse (procedure reverse (list) list))
(memq (procedure memq (* list) *))      ; result type: (or list boolean) ?
(memv (procedure memv (* list) *))
(member (procedure member (* list #!optional (procedure (* *) *)) *))
(assq (procedure assq (* list) *))
(assv (procedure assv (* list) *))
(assoc (procedure assoc (* list #!optional (procedure (* *) *)) *))
(symbol? (procedure symbol? (*) boolean))
(symbol->string (procedure symbol->string (symbol) string))
(string->symbol (procedure string->symbol (string) symbol))
(number? (procedure number? (*) boolean))
(integer? (procedure integer? (*) boolean))
(exact? (procedure exact? (*) boolean))
(real? (procedure real? (*) boolean))
(complex? (procedure complex? (*) boolean))
(inexact? (procedure inexact? (*) boolean))
(rational? (procedure rational? (*) boolean))
(zero? (procedure zero? (number) boolean))
(odd? (procedure odd? (number) boolean))
(even? (procedure even? (number) boolean))
(positive? (procedure positive? (number) boolean))
(negative? (procedure negative? (number) boolean))
(max (procedure max (#!rest number) number))
(min (procedure min (#!rest number) number))
(+ (procedure + (#!rest number) number))
(- (procedure - (number #!rest number) number))
(* (procedure * (#!rest number) number))
(/ (procedure / (number #!rest number) number))
(= (procedure = (#!rest number) boolean))
(> (procedure > (#!rest number) boolean))
(< (procedure < (#!rest number) boolean))
(>= (procedure >= (#!rest number) boolean))
(<= (procedure <= (#!rest number) boolean))
(quotient (procedure quotient (number number) number))
(remainder (procedure remainder (number number) number))
(modulo (procedure modulo (number number) number))
(gcd (procedure gcd (#!rest number) number))
(lcm (procedure lcm (#!rest number) number))
(abs (procedure abs (number) number))
(floor (procedure floor (number) number))
(ceiling (procedure ceiling (number) number))
(truncate (procedure truncate (number) number))
(round (procedure round (number) number))
(exact->inexact (procedure exact->inexact (number) number))
(inexact->exact (procedure inexact->exact (number) number))
(exp (procedure exp (number) float))
(log (procedure log (number) float))
(expt (procedure expt (number number) number))
(sqrt (procedure sqrt (number) float))
(sin (procedure sin (number) float))
(cos (procedure cos (number) float))
(tan (procedure tan (number) float))
(asin (procedure asin (number) float))
(acos (procedure acos (number) float))
(atan (procedure atan (number number) float))
(number->string (procedure number->string (number #!optional number) string))
(string->number (procedure string->number (string #!optional number) (or number boolean)))
(char? (procedure char? (*) boolean))
(char=? (procedure char=? (char char) boolean))
(char>? (procedure char>? (char char) boolean))
(char<? (procedure char<? (char char) boolean))
(char>=? (procedure char>=? (char char) boolean))
(char<=? (procedure char<=? (char char) boolean))
(char-ci=? (procedure char-ci=? (char char) boolean))
(char-ci<? (procedure char-ci<? (char char) boolean))
(char-ci>? (procedure char-ci>? (char char) boolean))
(char-ci>=? (procedure char-ci>=? (char char) boolean))
(char-ci<=? (procedure char-ci<=? (char char) boolean))
(char-alphabetic? (procedure char-alphabetic? (char) boolean))
(char-whitespace? (procedure char-whitespace? (char) boolean))
(char-numeric? (procedure char-numeric? (char) boolean))
(char-upper-case? (procedure char-upper-case? (char) boolean))
(char-lower-case? (procedure char-lower-case? (char) boolean))
(char-upcase (procedure char-upcase (char) char))
(char-downcase (procedure char-downcase (char) char))
(char->integer (procedure char->integer (char) fixnum))
(integer->char (procedure integer->char (fixnum) char))
(string? (procedure string? (*) boolean))
(string=? (procedure string=? (string string) boolean))
(string>? (procedure string>? (string string) boolean))
(string<? (procedure string<? (string string) boolean))
(string>=? (procedure string>=? (string string) boolean))
(string<=? (procedure string<=? (string string) boolean))
(string-ci=? (procedure string-ci=? (string string) boolean))
(string-ci<? (procedure string-ci<? (string string) boolean))
(string-ci>? (procedure string-ci>? (string string) boolean))
(string-ci>=? (procedure string-ci>=? (string string) boolean))
(string-ci<=? (procedure string-ci<=? (string string) boolean))
(make-string (procedure make-string (fixnum #!optional char) string))
(string-length (procedure string-length (string) fixnum))
(string-ref (procedure string-ref (string fixnum) char))
(string-set! (procedure string-set! (string fixnum char) undefined))
(string-append (procedure string-append (#!rest string) string))
;(string-copy (procedure string-copy (string) string)) - we use the more general version from srfi-13
(string->list (procedure string->list (string) list))
(list->string (procedure list->string (list) string))
(substring (procedure substring (string fixnum #!optional fixnum) string))
(string-fill! (procedure string-fill! (string char) string))
(vector? (procedure vector? (*) boolean))
(make-vector (procedure make-vector (fixnum #!optional *) vector))
(vector-ref (procedure vector-ref (vector fixnum) *))
(vector-set! (procedure vector-set! (vector fixnum *) undefined))
(string (procedure string (#!rest char) string))
(vector (procedure vector (#!rest) vector))
(vector-length (procedure vector-length (vector) fixnum))
(vector->list (procedure vector->list (vector) list))
(list->vector (procedure list->vector (list) vector))
(vector-fill! (procedure vector-fill! (vector *) vector))
(procedure? (procedure procedure? (*) boolean))
(map (procedure map (procedure #!rest list) list))
(for-each (procedure for-each (procedure #!rest list) undefined))
(apply (procedure apply (procedure #!rest) . *))
(force (procedure force (*) *))
(call-with-current-continuation (procedure call-with-current-continuation (procedure) . *))
(input-port? (procedure input-port? (*) boolean))
(output-port? (procedure output-port? (*) boolean))
(current-input-port (procedure current-input-port (#!optional port) port))
(current-output-port (procedure current-output-port (#!optional port) port))
(call-with-input-file (procedure call-with-input-file (string (procedure (port) . *)) . *))
(call-with-output-file (procedure call-with-output-file (string (procedure (port) . *)) . *))
(open-input-file (procedure open-input-file (string) port))
(open-output-file (procedure open-output-file (string) port))
(close-input-port (procedure close-input-port (port) undefined))
(close-output-port (procedure close-output-port (port) undefined))
(load (procedure load (string #!optional procedure) undefined))
(read (procedure read (#!optional port) *))
(eof-object? (procedure eof-object? (*) boolean))
(read-char (procedure read-char (#!optional port) *)) ; result (or eof char) ?
(peek-char (procedure peek-char (#!optional port) *))
(write (procedure write (* #!optional port) undefined))
(display (procedure display (* #!optional port) undefined))
(write-char (procedure write-char (char #!optional port) undefined))
(newline (procedure newline (#!optional port) undefined))
(with-input-from-file (procedure with-input-from-file (string procedure #!optional symbol) . *))
(with-output-to-file (procedure with-output-to-file (string procedure #!optional symbol) . *))
(dynamic-wind (procedure dynamic-wind (procedure procedure procedure) . *))
(values (procedure values (#!rest values) . *))
(call-with-values (procedure call-with-values (procedure procedure) . *))
(eval (procedure eval (* #!optional *) *))
(char-ready? (procedure char-ready? (#!optional port) boolean))
(imag-part (procedure imag-part (number) number))
(real-part (procedure real-part (number) number))
(magnitude (procedure magnitude (number) number))
(numerator (procedure numerator (number) number))
(denominator (procedure denominator (number) number))
(scheme-report-environment (procedure scheme-report-environment (#!optional fixnum) *))
(null-environment (procedure null-environment (#!optional fixnum) *))
(interaction-environment (procedure interaction-environment () *))

;; chicken

(abort (procedure abort (*) noreturn))
(add1 (procedure add1 (number) number))
(argc+argv (procedure argc+argv () fixnum list))
(argv (procedure argv () list))
(arithmetic-shift (procedure arithmetic-shift (number number) number))
(bit-set? (procedure bit-set? (number fixnum) boolean))
(bitwise-and (procedure bitwise-and (#!rest number) number))
(bitwise-ior (procedure bitwise-ior (#!rest number) number))
(bitwise-not (procedure bitwise-not (number) number))
(bitwise-xor (procedure bitwise-xor (#!rest number) number))
(blob->string (procedure blob->string (blob) string))
(blob-size (procedure blob-size (blob) fixnum))
(blob? (procedure blob? (*) boolean))
(blob=? (procedure blob=? (blob blob) boolean))
(breakpoint (procedure breakpoint (#!optional *) . *))
(build-platform (procedure build-platform () symbol))
(c-runtime (procedure c-runtime () symbol))
(call/cc (procedure call/cc (procedure) . *))
(case-sensitive (procedure case-sensitive (#!optional *) *))
(char-name (procedure char-name ((or char symbol) #!optional char) *))
(chicken-home (procedure chicken-home () string))
(chicken-version (procedure chicken-version (#!optional *) string))
(command-line-arguments (procedure command-line-arguments () list))
(condition-predicate (procedure condition-predicate (symbol) (procedure ((struct condition)) boolean)))
(condition-property-accessor (procedure condition-property-accessor (symbol symbol #!optional *) (procedure ((struct condition)) *)))
(condition? (procedure condition? (*) boolean))
(continuation-capture (procedure continuation-capture ((procedure ((struct continuation)) . *)) *))
(continuation-graft (procedure continuation-graft ((struct continuation) (procedure () . *)) *))
(continuation-return (procedure continuation-return (procedure #!rest) . *)) ;XXX make return type more specific?
(continuation? (procedure continuation? (*) boolean))
(copy-read-table (procedure copy-read-table ((struct read-table)) (struct read-table)))
(cpu-time (procedure cpu-time () fixnum fixnum))
(current-error-port (procedure current-error-port (#!optional port) port))
(current-exception-handler (procedure current-exception-handler () procedure))
(current-gc-milliseconds (procedure current-gc-milliseconds () fixnum))
(current-milliseconds (procedure current-milliseconds () fixnum))
(current-read-table (procedure current-read-table () (struct read-table)))
(current-seconds (procedure current-seconds () number))
(define-reader-ctor (procedure define-reader-ctor (symbol procedure) undefined))
(delete-file (procedure delete-file (string) undefined))
(enable-warnings (procedure enable-warnings (#!optional *) *))
(errno (procedure errno () fixnum))
(error (procedure error (#!rest) noreturn))
(exit (procedure exit (#!optional fixnum) noreturn))
(exit-handler (procedure exit-handler (#!optional procedure) procedure))
(expand (procedure expand (* #!optional *) *))
(extension-information (procedure extension-information (symbol) *))
(feature? (procedure feature? (symbol) boolean))
(features (procedure features () list))
(file-exists? (procedure file-exists? (string) *))
(fixnum-bits fixnum)
(fixnum-precision fixnum)
(fixnum? (procedure fixnum? (*) boolean))
(flonum-decimal-precision fixnum)
(flonum-epsilon float)
(flonum-maximum-decimal-exponent fixnum)
(flonum-maximum-exponent fixnum)
(flonum-minimum-decimal-exponent fixnum)
(flonum-minimum-exponent fixnum)
(flonum-precision fixnum)
(flonum-print-precision (procedure (#!optional fixnum) fixnum))
(flonum-radix fixnum)
(flonum? (procedure flonum? (*) boolean))
(flush-output (procedure flush-output (#!optional port) undefined))
(force-finalizers (procedure force-finalizers () undefined))
(fp- (procedure fp- (float float) float))
(fp* (procedure fp* (float float) float))
(fp/ (procedure fp/ (float float) float))
(fp+ (procedure fp+ (float float) float))
(fp< (procedure fp< (float float) boolean))
(fp<= (procedure fp<= (float float) boolean))
(fp= (procedure fp= (float float) boolean))
(fp> (procedure fp> (float float) boolean))
(fp>= (procedure fp>= (float float) boolean))
(fpmax (procedure fpmax (float float) float))
(fpmin (procedure fpmin (float float) float))
(fpneg (procedure fpneg (float) float))
(fx- (procedure fx- (fixnum fixnum) fixnum))
(fx* (procedure fx* (fixnum fixnum) fixnum))
(fx/ (procedure fx/ (fixnum fixnum) fixnum))
(fx+ (procedure fx+ (fixnum fixnum) fixnum))
(fx< (procedure fx< (fixnum fixnum) boolean))
(fx<= (procedure fx<= (fixnum fixnum) boolean))
(fx= (procedure fx= (fixnum fixnum) boolean))
(fx> (procedure fx> (fixnum fixnum) boolean))
(fx>= (procedure fx>= (fixnum fixnum) boolean))
(fxand (procedure fxand (fixnum fixnum) fixnum))
(fxior (procedure fxior (fixnum fixnum) fixnum))
(fxmax (procedure fxmax (fixnum fixnum) fixnum))
(fxmin (procedure fxmin (fixnum fixnum) fixnum))
(fxmod (procedure fxmod (fixnum fixnum) fixnum))
(fxneg (procedure fxneg (fixnum) fixnum))
(fxnot (procedure fxnot (fixnum) fixnum))
(fxshl (procedure fxshl (fixnum fixnum) fixnum))
(fxshr (procedure fxshr (fixnum fixnum) fixnum))
(fxxor (procedure fxxor (fixnum fixnum) fixnum))
(gc (procedure gc (#!optional *) fixnum))
(gensym (procedure gensym (#!optional *) symbol))
(get (procedure get (symbol symbol) *))
(get-call-chain (procedure get-call-chain (#!optional fixnum *) list))
(get-environment-variable (procedure get-environment-variable (string) *))
(get-keyword (procedure get-keyword (symbol list #!optional *) *))
(get-output-string (procedure get-output-string (port) string))
(get-properties (procedure get-properties (symbol list) symbol * list))
(getenv (procedure getenv (string) (or string boolean)))
(getter-with-setter (procedure getter-with-setter (procedure procedure) procedure))
(implicit-exit-handler (procedure implicit-exit-handler (#!optional procedure) procedure))
(keyword->string (procedure keyword->string (symbol) string))
(keyword-style (procedure keyword-style (#!optional *) *))
(keyword? (procedure keyword? (*) boolean))
(load-library (procedure load-library (* string) undefined))
(load-relative (procedure load-relative (string #!optional procedure) undefined))
(load-verbose (procedure load-verbose (#!optional *) *))
(machine-byte-order (procedure machine-byte-order () symbol))
(machine-type (procedure machine-type () symbol))
(make-blob (procedure make-blob (fixnum) blob))
(make-composite-condition (procedure make-composite-condition (#!rest (struct condition)) (struct condition)))
(make-parameter (procedure make-parameter (* #!optional procedure) procedure))
(make-property-condition (procedure make-property-condition (symbol #!rest *) (struct condition)))
(maximum-flonum float)
(memory-statistics (procedure memory-statistics () vector))
(minimum-flonum float)
(most-negative-fixnum fixnum)
(most-positive-fixnum fixnum)
(on-exit (procedure on-exit ((procedure () . *)) undefined))
(open-input-string (procedure open-input-string (string #!rest) port))
(open-output-string (procedure open-output-string (#!rest) port))
(parentheses-synonyms (procedure parentheses-synonyms (#!optional *) *))
(port-name (procedure port-name (#!optional port) *))
(port-position (procedure port-position (#!optional port) fixnum))
(port? (procedure port? (*) boolean))
(print (procedure print (#!rest *) undefined))
(print-call-chain (procedure print-call-chain (#!optional port fixnum * string) undefined))
(print-error-message (procedure print-error-message (* #!optional port string) undefined))
(print* (procedure print* (#!rest) undefined))
(procedure-information (procedure procedure-information (procedure) *))
(program-name (procedure program-name () string))
(promise? (procedure promise? (*) boolean))
(put! (procedure put! (symbol symbol *) undefined))
(register-feature! (procedure register-feature! (#!rest symbol) undefined))
(remprop! (procedure remprop! (symbol symbol) undefined))
(rename-file (procedure rename-file (string string) undefined))
(repl (procedure repl () undefined))
(repl-prompt (procedure repl-prompt (#!optional procedure) procedure))
(repository-path (procedure repository-path (#!optional *) string))
(require (procedure require (#!rest *) undefined))
(reset (procedure reset () undefined))
(reset-handler (procedure reset-handler (#!optional procedure) procedure))
(return-to-host (procedure return-to-host () . *))
(reverse-list->string (procedure reverse-list->string (list) string))
(set-finalizer! (procedure set-finalizer! (* (procedure (*) . *)) undefined))
(set-gc-report! (procedure set-gc-report! (*) undefined))
(set-parameterized-read-syntax! (procedure set-parameterized-read-syntax! (char procedure) undefined))
(set-port-name! (procedure set-port-name! (port string) undefined))
(set-read-syntax! (procedure set-read-syntax! (char procedure) undefined))
(set-sharp-read-syntax! (procedure set-sharp-read-syntax! (char procedure) undefined))
(setter (procedure setter (procedure) procedure))
(signal (procedure signal (*) . *))
(signum (procedure signum (number) number))
(singlestep (procedure singlestep (procedure) . *))
(software-type (procedure software-type () symbol))
(software-version (procedure software-version () symbol))
(string->blob (procedure string->blob (string) blob))
(string->keyword (procedure string->keyword (string) symbol))
(string->uninterned-symbol (procedure string->uninterned-symbol (string) symbol))
(strip-syntax (procedure strip-syntax (*) *))
(sub1 (procedure sub1 (number) number))
(symbol-escape (procedure symbol-escape (#!optional *) *))
(symbol-plist (procedure symbol-plist (symbol) list))
(syntax-error (procedure syntax-error (#!rest) noreturn))
(system (procedure system (string) fixnum))
(unregister-feature! (procedure unregister-feature! (#!rest symbol) undefined))
(vector-resize (procedure vector-resize (vector fixnum) vector))
(void (procedure void () undefined))
(warning (procedure warning (#!rest) . *))
(with-exception-handler (procedure with-exception-handler (procedure procedure) . *))

;; data-structures

(->string (procedure ->string (*) string))
(alist-ref (procedure alist-ref (* list #!optional (procedure (* *) *) *) *))
(alist-update! (procedure alist-update! (* * list #!optional (procedure (* *) *)) *))
(always? (procedure always? (#!rest) boolean))
(any? (procedure any? (*) boolean))
(atom? (procedure atom? (*) boolean))
(binary-search (procedure binary-search (vector (procedure (*) *)) *))
(butlast (procedure butlast (pair) list))
(chop (procedure chop (list fixnum) list))
(complement (procedure complement (procedure) procedure))
(compose (procedure compose (#!rest procedure) procedure))
(compress (procedure compress (list list) list))
(conc (procedure conc (#!rest) string))
(conjoin (procedure conjoin (#!rest (procedure (*) *)) (procedure (*) *)))
(constantly (procedure constantly (#!rest) . *))
(disjoin (procedure disjoin (#!rest (procedure (*) *)) (procedure (*) *)))
(each (procedure each (#!rest procedure) procedure))
(flatten (procedure flatten (pair) list))
(flip (procedure flip ((procedure (* *) . *)) procedure))
(identity (procedure identity (*) *))
(intersperse (procedure intersperse (list *) list))
(join (procedure join (list list) list))
(left-section (procedure left-section (procedure #!rest) procedure))
(list->queue (procedure list->queue (list) (struct queue)))
(list-of? (procedure list-of? ((procedure (*) *)) (procedure (list) boolean)))
(make-queue (procedure make-queue () (struct queue)))
(merge (procedure merge (list list (procedure (* *) *)) list))
(merge! (procedure merge! (list list (procedure (* *) *)) list))
(never? (procedure never? (#!rest) boolean))
(none? (procedure none? (*) boolean))
(noop (procedure noop (#!rest) *))
(o (procedure o (#!rest (procedure (*) *)) (procedure (*) *)))
(project (procedure project (fixnum) procedure))
(queue->list (procedure queue->list ((struct queue)) list))
(queue-add! (procedure queue-add! ((struct queue) *) undefined))
(queue-empty? (procedure queue-empty? ((struct queue)) boolean))
(queue-first (procedure queue-first ((struct queue)) *))
(queue-last (procedure queue-last ((struct queue)) *))
(queue-push-back! (procedure queue-push-back! ((struct queue) *) undefined))
(queue-push-back-list! (procedure queue-push-back-list! ((struct queue) list) undefined))
(queue-remove! (procedure queue-remove! ((struct queue)) undefined))
(queue? (procedure queue? (*) boolean))
(rassoc (procedure rassoc (* list #!optional (procedure (* *) *)) *))
(right-section (procedure right-section (procedure #!rest) procedure))
(shuffle (procedure shuffle (list (procedure (fixnum) fixnum)) list))
(sort (procedure sort ((or list vector) (procedure (* *) *)) (or list vector)))
(sort! (procedure sort! ((or list vector) (procedure (* *) *)) (or list vector)))
(sorted? (procedure sorted? ((or list vector) (procedure (* *) *)) boolean))
(string-chomp (procedure string-chomp (string #!optional string) string))
(string-chop (procedure string-chop (string fixnum) list))
(string-compare3 (procedure string-compare3 (string string) fixnum))
(string-compare3-ci (procedure string-compare3-ci (string string) fixnum))
(string-intersperse (procedure string-intersperse (list #!optional string) string))
(string-split (procedure string-split (string #!optional string *) list))
(string-translate (procedure string-translate (string string #!optional string) string))
(string-translate* (procedure string-translate* (string list) string))
(substring-ci=? (procedure substring-ci=? (string string #!optional fixnum fixnum fixnum) boolean))
(substring-index (procedure substring-index (string string #!optional fixnum) *))
(substring-index-ci (procedure substring-index-ci (string string #!optional fixnum) *))
(substring=? (procedure substring=? (string string #!optional fixnum fixnum fixnum) boolean))
(tail? (procedure tail? (* *) boolean))

;; extras

(format (procedure format (string #!rest) *))
(fprintf (procedure fprintf (port string #!rest) undefined))
(pp (procedure pp (* #!optional port) undefined))
(pretty-print (procedure pretty-print (* #!optional port) undefined))
(pretty-print-width (procedure pretty-print-width (#!optional *) *))
(printf (procedure printf (string #!rest) undefined))
(random (procedure random (number) number))
(random-seed (procedure random-seed (#!optional number) number))
(randomize (procedure randomize (#!optional number) undefined))
(read-byte (procedure read-byte (#!optional port) fixnum))
(read-file (procedure read-file (#!optional port (procedure (port) *) fixnum) list))
(read-line (procedure read-line (#!optional port fixnum) *))
(read-lines (procedure read-lines (#!optional port fixnum) list))
(read-string (procedure read-string (#!optional * port) string))
(read-string! (procedure read-string! (fixnum string #!optional port fixnum) fixnum))
(read-token (procedure read-token ((procedure (char) *) #!optional port) string))
(sprintf (procedure sprintf (string #!rest) string))
(write-byte (procedure write-byte (fixnum #!optional port) undefined))
(write-line (procedure write-line (string #!optional port) undefined))
(write-string (procedure write-string (string #!optional * port) undefined))

;; files

(delete-file* (procedure delete-file* (string) boolean))
(file-copy (procedure file-copy (string string #!optional * fixnum) undefined))
(file-move (procedure file-move (string string #!optional * fixnum) undefined))
(make-pathname (procedure make-pathname (* * #!optional string string) string))
(directory-null? (procedure directory-null? (string) boolean))
(make-absolute-pathname (procedure make-absolute-pathname (* * #!optional string string) string))
(create-temporary-file (procedure create-temporary-file (#!optional string) string))
(decompose-pathname (procedure decompose-pathname (string) * * *))
(absolute-pathname? (procedure absolute-pathname? (string) boolean))
(pathname-directory (procedure pathname-directory (string) *))
(pathname-extension (procedure pathname-extension (string) *))
(pathname-file (procedure pathname-file (string) *))
(pathname-replace-directory (procedure pathname-replace-directory (string string) string))
(pathname-replace-extension (procedure pathname-replace-extension (string string) string))
(pathname-replace-file (procedure pathname-replace-file (string string) string))
(pathname-strip-directory (procedure pathname-strip-directory (string) string))
(pathname-strip-extension (procedure pathname-strip-extension (string) string))
(normalize-pathname (procedure normalize-pathname (string) string))

;; irregex

(irregex (procedure irregex (#!rest) *))
(string->irregex (procedure string->irregex (string #!rest) *))
(sre->irregex (procedure sre->irregex (#!rest) *))
(string->sre (procedure string->sre (string #!rest) *))
(irregex? (procedure irregex? (*) boolean))
(irregex-match-data? (procedure irregex-match-data? (*) boolean))
(irregex-new-matches (procedure irregex-new-matches (*) *))
(irregex-reset-matches! (procedure irregex-reset-matches! (*) *))
(irregex-match-start (procedure irregex-match-start (* #!optional *) *))
(irregex-match-end (procedure irregex-match-end (* #!optional *) *))
(irregex-match-substring (procedure irregex-match-substring (* #!optional *) *))
(irregex-search (procedure irregex-search (* string #!optional fixnum fixnum) *))
(irregex-search/matches (procedure irregex-search/matches (* string fixnum fixnum *) *))
(irregex-match (procedure irregex-match (* string) *))
(irregex-match-string (procedure irregex-match-string (*) *))
(irregex-replace (procedure irregex-replace (* string #!rest) *))
(irregex-replace/all (procedure irregex-replace/all (* string #!rest) *))
(irregex-dfa (procedure irregex-dfa (*) *))
(irregex-dfa/search (procedure irregex-dfa/search (*) *))
(irregex-dfa/extract (procedure irregex-dfa/extract (*) *))
(irregex-nfa (procedure irregex-nfa (*) *))
(irregex-flags (procedure irregex-flags (*) *))
(irregex-submatches (procedure irregex-submatches (*) *))
(irregex-lengths (procedure irregex-lengths (*) *))
(irregex-names (procedure irregex-names (*) *))

;; lolevel

(address->pointer (procedure address->pointer (fixnum) pointer))
(align-to-word (procedure align-to-word (*) *))
(allocate (procedure allocate (fixnum) pointer))
(block-ref (procedure block-ref (* fixnum) *))
(block-set! (procedure block-set! (* fixnum *) *))
(extend-procedure (procedure extend-procedure (procedure *) procedure))
(extended-procedure? (procedure extended-procedure? (*) boolean))
(free (procedure free (pointer) *))
(global-bound? (procedure global-bound? (symbol) boolean))
(global-make-unbound! (procedure global-make-unbound! (symbol) symbol))
(global-ref (procedure global-ref (symbol) *))
(global-set! (procedure global-set! (symbol *) *))
(locative->object (procedure locative->object (locative) *))
(locative-ref (procedure locative-ref (locative) *))
(locative-set! (procedure locative-set! (locative *) *))
(locative? (procedure locative? (*) boolean))
(make-locative (procedure make-locative (* #!optional fixnum) locative))
(make-record-instance (procedure make-record-instance (* #!rest) *))
(make-weak-locative (procedure make-weak-locative (* #!optional fixnum) locative))
(move-memory! (procedure move-memory! (* * #!optional fixnum fixnum fixnum) *))
(mutate-procedure (procedure mutate-procedure (procedure procedure) procedure))
(null-pointer (procedure null-pointer () pointer))
(null-pointer? (procedure null-pointer? (pointer) boolean))
(number-of-bytes (procedure number-of-bytes (*) fixnum))
(number-of-slots (procedure number-of-slots (*) fixnum))
(object->pointer (procedure object->pointer (*) *))
(object-become! (procedure object-become! (list) *))
(object-copy (procedure object-copy (*) *))
(object-evict (procedure object-evict (* #!optional (procedure (fixnum) pointer)) *))
(object-evict-to-location (procedure object-evict-to-location (* pointer #!optional fixnum) * pointer))
(object-evicted? (procedure object-evicted? (*) boolean))
(object-release (procedure object-release (* #!optional (procedure (pointer) *)) *))
(object-size (procedure object-size (*) fixnum))
(object-unevict (procedure object-unevict (* #!optional *) *))
(pointer->address (procedure pointer->address (pointer) number))
(pointer-like? (procedure pointer-like? (*) boolean))
(pointer->object (procedure pointer->object (pointer) *))
(pointer-f32-ref (procedure pointer-f32-ref (pointer) number))
(pointer-f32-set! (procedure pointer-f32-set! (pointer number) undefined))
(pointer-f64-ref (procedure pointer-f64-ref (pointer) number))
(pointer-f64-set! (procedure pointer-f64-set! (pointer number) undefined))
(pointer-offset (procedure pointer-offset (pointer fixnum) pointer))
(pointer-s16-ref (procedure pointer-s16-ref (pointer) fixnum))
(pointer-s16-set! (procedure pointer-s16-set! (pointer fixnum) undefined))
(pointer-s32-ref (procedure pointer-s32-ref (pointer) number))
(pointer-s32-set! (procedure pointer-s32-set! (pointer number) undefined))
(pointer-s8-ref (procedure pointer-s8-ref (pointer) fixnum))
(pointer-s8-set! (procedure pointer-s8-set! (pointer fixnum) undefined))
(pointer-tag (procedure pointer-tag (pointer) *))
(pointer-u16-ref (procedure pointer-u16-ref (pointer) fixnum))
(pointer-u16-set! (procedure pointer-u16-set! (pointer fixnum) undefined))
(pointer-u32-ref (procedure pointer-u32-ref (pointer) number))
(pointer-u32-set! (procedure pointer-u32-set! (pointer number) undefined))
(pointer-u8-ref (procedure pointer-u8-ref (pointer) fixnum))
(pointer-u8-set! (procedure pointer-u8-set! (pointer fixnum) undefined))
(pointer=? (procedure pointer=? (pointer pointer) boolean))
(pointer? (procedure pointer? (*) boolean))
(procedure-data (procedure procedure-data (procedure) *))
(record->vector (procedure record->vector (*) vector))
(record-instance? (procedure record-instance? (*) boolean))
(record-instance-length (procedure record-instance-length (*) fixnum))
(record-instance-slot (procedure record-instance-slot (* fixnum) *))
(record-instance-slot-set! (procedure record-instance-slot-set! (* fixnum *) undefined))
(record-instance-type (procedure record-instance-type (*) *))
(set-invalid-procedure-call-handler! (procedure set-invalid-procedure-call-handler! (procedure) undefined))
(set-procedure-data! (procedure set-procedure-data! (procedure *) undefined))
(tag-pointer (procedure tag-pointer (pointer *) pointer))
(tagged-pointer? (procedure tagged-pointer? (*) boolean))
(unbound-variable-value (procedure unbound-variable-value (#!optional *) undefined))
(vector-like? (procedure vector-like? (*) boolean))

;; ports

(call-with-input-string (procedure call-with-input-string (string (procedure (port) . *)) . *))
(call-with-output-string (procedure call-with-output-string ((procedure (port) . *)) string))
(make-input-port (procedure make-input-port ((procedure () char) (procedure () *) (procedure () . *) #!optional * * *) port))
(make-output-port (procedure make-output-port ((procedure (string) . *) (procedure () . *) #!optional (procedure () . *)) port))
(port-for-each (procedure port-for-each ((procedure (*) *) (procedure () . *)) undefined))
(port-map (procedure port-map ((procedure (*) *) (procedure () . *)) list))
(port-fold (procedure port-fold ((procedure (* *) *) * (procedure () *)) *))
(make-broadcast-port (procedure make-broadcast-port (#!rest port) port))
(make-concatenated-port (procedure make-concatenated-port (port #!rest port) port))
(with-error-output-to-port (procedure with-error-output-to-port (port (procedure () . *)) . *))
(with-input-from-port (procedure with-input-from-port (port (procedure () . *)) . *))
(with-input-from-string (procedure with-input-from-string (string (procedure () . *)) . *))
(with-output-to-port (procedure with-output-to-port (port (procedure () . *)) . *))
(with-output-to-string (procedure with-output-to-string ((procedure () . *)) . *))
(with-error-output-to-port (procedure with-error-output-to-port (port (procedure () . *)) . *))

;; posix

(_exit (procedure _exit (fixnum) noreturn))
(call-with-input-pipe (procedure call-with-input-pipe (string (procedure (port) . *) #!optional symbol) . *))
(call-with-output-pipe (procedure call-with-output-pipe (string (procedure (port) . *) #!optional symbol) . *))
(canonical-path (procedure canonical-path (string) string))
(change-directory (procedure change-directory (string) undefined))
(change-file-mode (procedure change-file-mode (string fixnum) undefined))
(change-file-owner (procedure change-file-owner (string fixnum) undefined))
(close-input-pipe (procedure close-input-pipe (port) fixnum))
(close-output-pipe (procedure close-output-pipe (port) fixnum))
(create-directory (procedure create-directory (string #!optional *) undefined))
(create-fifo (procedure create-fifo (string #!optional fixnum) undefined))
(create-pipe (procedure create-pipe () fixnum fixnum))
(create-session (procedure create-session () fixnum))
(create-symbolic-link (procedure create-symbolic-link (string string) undefined))
(current-directory (procedure current-directory () string))
(current-effective-group-id (procedure current-effective-group-id () fixnum))
(current-effective-user-id (procedure current-effective-user-id () fixnum))
(current-effective-user-name (procedure current-effective-user-name () string))
(current-environment deprecated)
(get-environment-variables (procedure get-environment-variables () list))
(current-group-id (procedure current-group-id () fixnum))
(current-process-id (procedure current-process-id () fixnum))
(current-user-id (procedure current-user-id () fixnum))
(current-user-name (procedure current-user-name () string))
(delete-directory (procedure delete-directory (string) undefined))
(directory (procedure directory (string #!optional *) list))
(directory? (procedure directory? (string) boolean))
(duplicate-fileno (procedure duplicate-fileno (fixnum #!optional fixnum) fixnum))
(errno/2big fixnum)
(errno/acces fixnum)
(errno/again fixnum)
(errno/badf fixnum)
(errno/busy fixnum)
(errno/child fixnum)
(errno/deadlk fixnum)
(errno/dom fixnum)
(errno/exist fixnum)
(errno/fault fixnum)
(errno/fbig fixnum)
(errno/ilseq fixnum)
(errno/intr fixnum)
(errno/inval fixnum)
(errno/io fixnum)
(errno/isdir fixnum)
(errno/mfile fixnum)
(errno/mlink fixnum)
(errno/nametoolong fixnum)
(errno/nfile fixnum)
(errno/nodev fixnum)
(errno/noent fixnum)
(errno/noexec fixnum)
(errno/nolck fixnum)
(errno/nomem fixnum)
(errno/nospc fixnum)
(errno/nosys fixnum)
(errno/notdir fixnum)
(errno/notempty fixnum)
(errno/notty fixnum)
(errno/nxio fixnum)
(errno/perm fixnum)
(errno/pipe fixnum)
(errno/range fixnum)
(errno/rofs fixnum)
(errno/spipe fixnum)
(errno/srch fixnum)
(errno/wouldblock fixnum)
(errno/xdev fixnum)
(fcntl/dupfd fixnum)
(fcntl/getfd fixnum)
(fcntl/getfl fixnum)
(fcntl/setfd fixnum)
(fcntl/setfl fixnum)
(fifo? (procedure fifo? (string) boolean))
(file-access-time (procedure file-access-time (string) number))
(file-change-time (procedure file-change-time (string) number))
(file-close (procedure file-close (fixnum) undefined))
(file-control (procedure file-control (fixnum fixnum #!optional fixnum) fixnum))
(file-execute-access? (procedure file-execute-access? (string) boolean))
(file-link (procedure file-link (string string) undefined))
(file-lock (procedure file-lock (string fixnum #!optional *) (struct lock)))
(file-lock/blocking (procedure file-lock/blocking (string fixnum #!optional *) (struct lock)))
(file-mkstemp (procedure file-mkstemp (string) fixnum string))
(file-modification-time (procedure file-modification-time (string) number))
(file-open (procedure file-open (string fixnum #!optional fixnum) fixnum))
(file-owner (procedure file-owner (string) fixnum))
(file-permissions (procedure file-permissions (string) fixnum))
(file-position (procedure file-position (string) fixnum))
(file-read (procedure file-read (fixnum fixnum #!optional *) list))
(file-read-access? (procedure file-read-access? (string) boolean))
(file-select (procedure file-select (list list #!optional fixnum) list list))
(file-size (procedure file-size (string) fixnum))
(file-stat (procedure file-stat (string #!optional *) vector))
(file-test-lock (procedure file-test-lock (port fixnum #!optional *) boolean))
(file-truncate (procedure file-truncate (string fixnum) undefined))
(file-unlock (procedure file-unlock ((struct lock)) undefined))
(file-write (procedure file-write (fixnum * #!optional fixnum) fixnum))
(file-write-access? (procedure file-write-access? (string) boolean))
(fileno/stderr fixnum)
(fileno/stdin fixnum)
(fileno/stdout fixnum)
(find-files (procedure find-files (string * #!optional (procedure (string string) *) * fixnum) list))
(get-groups (procedure get-groups () list))
(get-host-name (procedure get-host-name () string))
(glob (procedure glob (#!rest string) list))
(group-information (procedure group-information (fixnum #!optional *) *))
(initialize-groups (procedure initialize-groups (fixnum fixnum) undefined))
(local-time->seconds (procedure local-time->seconds (vector) number))
(local-timezone-abbreviation (procedure local-timezone-abbreviation () string))
(map-file-to-memory (procedure map-file-to-memory (* fixnum fixnum fixnum fixnum #!optional fixnum) (struct mmap)))
(map/anonymous fixnum)
(map/file fixnum)
(map/fixed fixnum)
(map/private fixnum)
(map/shared fixnum)
(memory-mapped-file-pointer (procedure memory-mapped-file-pointer ((struct mmap)) pointer))
(memory-mapped-file? (procedure memory-mapped-file? (*) boolean))
(open-input-file* (procedure open-input-file* (fixnum #!optional symbol) port))
(open-input-pipe (procedure open-input-pipe (string #!optional symbol) port))
(open-output-file* (procedure open-output-file* (fixnum #!optional symbol) port))
(open-output-pipe (procedure open-output-pipe (string #!optional symbol) port))
(open/append fixnum)
(open/binary fixnum)
(open/creat fixnum)
(open/excl fixnum)
(open/fsync fixnum)
(open/noctty fixnum)
(open/nonblock fixnum)
(open/rdonly fixnum)
(open/rdwr fixnum)
(open/read fixnum)
(open/sync fixnum)
(open/text fixnum)
(open/trunc fixnum)
(open/write fixnum)
(open/wronly fixnum)
(parent-process-id (procedure parent-process-id () fixnum))
(perm/irgrp fixnum)
(perm/iroth fixnum)
(perm/irusr fixnum)
(perm/irwxg fixnum)
(perm/irwxo fixnum)
(perm/irwxu fixnum)
(perm/isgid fixnum)
(perm/isuid fixnum)
(perm/isvtx fixnum)
(perm/iwgrp fixnum)
(perm/iwoth fixnum)
(perm/iwusr fixnum)
(perm/ixgrp fixnum)
(perm/ixoth fixnum)
(perm/ixusr fixnum)
(pipe/buf fixnum)
(port->fileno (procedure port->fileno (port) fixnum))
(process (procedure process (string #!optional list list) port port fixnum))
(process* (procedure process* (string #!optional list list) port port fixnum *))
(process-execute (procedure process-execute (string #!optional list list) noreturn))
(process-fork (procedure process-fork (#!optional (procedure () . *)) fixnum))
(process-group-id (procedure process-group-id () fixnum))
(process-run (procedure process-run (string #!optional list) fixnum))
(process-signal (procedure process-signal (fixnum #!optional fixnum) undefined))
(process-wait (procedure process-wait (fixnum #!optional *) fixnum fixnum fixnum))
(prot/exec fixnum)
(prot/none fixnum)
(prot/read fixnum)
(prot/write fixnum)
(read-symbolic-link (procedure read-symbolic-link (string) string))
(regular-file? (procedure regular-file? (string) boolean))
(seconds->local-time (procedure seconds->local-time (number) vector))
(seconds->string (procedure seconds->string (number) string))
(seconds->utc-time (procedure seconds->utc-time (number) vector))
(seek/cur fixnum)
(seek/end fixnum)
(seek/set fixnum)
(set-alarm! (procedure set-alarm! (number) number))
(set-buffering-mode! (procedure set-buffering-mode! (port symbol #!optional fixnum) undefined))
(set-groups! (procedure set-groups! (list) undefined))
(set-root-directory! (procedure set-root-directory! (string) undefined))
(set-signal-handler! (procedure set-signal-handler! (fixnum (procedure (fixnum) . *)) undefined))
(set-signal-mask! (procedure set-signal-mask! (list) undefined))
(setenv (procedure setenv (string string) undefined))
(signal-handler (procedure signal-handler (fixnum) (procedure (fixnum) . *)))
(signal-mask (procedure signal-mask () fixnum))
(signal-mask! (procedure signal-mask! (fixnum) undefined))
(signal-masked? (procedure signal-masked? (fixnum) boolean))
(signal-unmask! (procedure signal-unmask! (fixnum) undefined))
(signal/abrt fixnum)
(signal/alrm fixnum)
(signal/chld fixnum)
(signal/cont fixnum)
(signal/fpe fixnum)
(signal/hup fixnum)
(signal/ill fixnum)
(signal/int fixnum)
(signal/io fixnum)
(signal/kill fixnum)
(signal/pipe fixnum)
(signal/prof fixnum)
(signal/quit fixnum)
(signal/segv fixnum)
(signal/stop fixnum)
(signal/term fixnum)
(signal/trap fixnum)
(signal/tstp fixnum)
(signal/urg fixnum)
(signal/usr1 fixnum)
(signal/usr2 fixnum)
(signal/vtalrm fixnum)
(signal/winch fixnum)
(signal/xcpu fixnum)
(signal/xfsz fixnum)
(signals-list list)
(sleep (procedure sleep (fixnum) fixnum))
(stat-block-device? (procedure stat-block-device? (string) boolean))
(stat-char-device? (procedure stat-char-device? (string) boolean))
(stat-directory? (procedure stat-directory? (string) boolean))
(stat-fifo? (procedure stat-fifo? (string) boolean))
(stat-regular? (procedure stat-regular? (string) boolean))
(stat-socket? (procedure stat-socket? (string) boolean))
(stat-symlink? (procedure stat-symlink? (string) boolean))
(string->time (procedure string->time (string #!optional string) vector))
(symbolic-link? (procedure symbolic-link? (string) boolean))
(system-information (procedure system-information () list))
(terminal-name (procedure terminal-name (port) string))
(terminal-port? (procedure terminal-port? (port) boolean))
(terminal-size (procedure terminal-size (port) fixnum fixnum))
(time->string (procedure time->string (vector #!optional string) string))
(unmap-file-from-memory (procedure unmap-file-from-memory ((struct mmap) #!optional fixnum) undefined))
(unsetenv (procedure unsetenv (string) undefined))
(user-information (procedure user-information (fixnum #!optional *) *))
(utc-time->seconds (procedure utc-time->seconds (vector) number))
(with-input-from-pipe (procedure with-input-from-pipe (string (procedure () . *) #!optional symbol) . *))
(with-output-to-pipe (procedure with-output-to-pipe (string (procedure () . *) #!optional symbol) . *))

;; regex

(glob->regexp (procedure glob->regexp (string) string))
(glob? (procedure glob? (string) boolean))
(grep (procedure grep (* list) list))
(regexp (procedure regexp (* #!optional * * *) (struct regexp)))
(regexp-escape (procedure regexp-escape (string) string))
(regexp? (procedure regexp? (*) boolean))
(string-match (procedure string-match (* string) *))
(string-match-positions (procedure string-match-positions (* string) *))
(string-search (procedure string-search (* string #!optional fixnum fixnum) *))
(string-search-positions (procedure string-search-positions (* string #!optional fixnum fixnum) *))
(string-split-fields (procedure string-split-fields (* string #!optional * fixnum) list))
(string-substitute (procedure string-substitute (* string string #!optional *) string))
(string-substitute* (procedure string-substitute* (string list #!optional *) string))

;; srfi-1

(alist-cons (procedure alist-cons (* * *) list))
(alist-copy (procedure alist-copy (list) list))
(alist-delete (procedure alist-delete (* list #!optional (procedure (* *) *)) list))
(alist-delete! (procedure alist-delete! (* list #!optional (procedure (* *) *)) undefined))
(any (procedure any ((procedure (* #!rest) *) list #!rest list) *))
(append! (procedure append! (#!rest list) list))
(append-map (procedure append-map ((procedure (#!rest) *) list #!rest list) pair))
(append-map! (procedure append-map! ((procedure (#!rest) *) list #!rest list) pair))
(append-reverse (procedure append-reverse (list list) list))
(append-reverse! (procedure append-reverse! (list list) list))
(break (procedure break ((procedure (*) *) list) list list))
(break! (procedure break! ((procedure (*) *) list) list list))
(car+cdr (procedure car+cdr (pair) * *))
(circular-list (procedure circular-list (#!rest) list))
(circular-list? (procedure circular-list? (*) boolean))
(concatenate (procedure concatenate (list) list))
(concatenate! (procedure concatenate! (list) list))
(cons* (procedure cons* (* #!rest) pair))
(count (procedure count ((procedure (*) *) list #!rest list) fixnum))
(delete (procedure delete (* list #!optional (procedure (* *) *)) list))
(delete! (procedure delete! (* list #!optional (procedure (* *) *)) list))
(delete-duplicates (procedure delete-duplicates (list #!optional (procedure (* *) *)) list))
(delete-duplicates! (procedure delete-duplicates! (list #!optional (procedure (* *) *)) list))
(dotted-list? (procedure dotted-list? (*) boolean))
(drop (procedure drop (list fixnum) list))
(drop-right (procedure drop-right (list fixnum) list))
(drop-right! (procedure drop-right! (list fixnum) list))
(drop-while (procedure drop-while ((procedure (*) *) list) list))
(eighth (procedure eighth (pair) *))
(every (procedure every ((procedure (* #!rest) *) list #!rest list) *))
(fifth (procedure fifth (pair) *))
(filter (procedure filter ((procedure (*) *) list) list))
(filter! (procedure filter! ((procedure (*) *) list) list))
(filter-map (procedure filter-map ((procedure (*) *) list #!rest list) list))
(find (procedure find ((procedure (*) *) list) *))
(find-tail (procedure find-tail ((procedure (*) *) list) *))
(first (procedure first (pair) *))
(fold (procedure fold ((procedure (* #!rest) *) * #!rest list) *))
(fold-right (procedure fold-right ((procedure (* #!rest) *) * #!rest list) *))
(fourth (procedure fourth (pair) *))
(iota (procedure iota (fixnum #!optional fixnum fixnum) list))
(last (procedure last (pair) *))
(last-pair (procedure last-pair (pair) *))
(length+ (procedure length+ (list) *))
(list-copy (procedure list-copy (list) list))
(list-index (procedure list-index ((procedure (* #!rest) *) list #!rest list) fixnum))
(list-tabulate (procedure list-tabulate (fixnum (procedure (fixnum) *)) list))
(list= (procedure list= (#!rest list) boolean))
(lset-adjoin (procedure lset-adjoin ((procedure (* *) *) list #!rest) list))
(lset-diff+intersection (procedure lset-diff+intersection ((procedure (* *) *) list #!rest list) list))
(lset-diff+intersection! (procedure lset-diff+intersection! ((procedure (* *) *) list #!rest list) list))
(lset-difference (procedure lset-difference ((procedure (* *) *) list #!rest list) list))
(lset-difference! (procedure lset-difference! ((procedure (* *) *) list #!rest list) list))
(lset-intersection (procedure lset-intersection ((procedure (* *) *) list #!rest list) list))
(lset-intersection! (procedure lset-intersection! ((procedure (* *) *) list #!rest list) list))
(lset-union (procedure lset-union ((procedure (* *) *) list #!rest list) list))
(lset-union! (procedure lset-union! ((procedure (* *) *) list #!rest list) list))
(lset-xor (procedure lset-xor ((procedure (* *) *) list #!rest list) list))
(lset-xor! (procedure lset-xor! ((procedure (* *) *) list #!rest list) list))
(lset<= (procedure lset<= ((procedure (* *) *) list #!rest list) list))
(lset= (procedure lset= ((procedure (* *) *) list #!rest list) list))
(make-list (procedure make-list (fixnum #!optional *) list))
(map! (procedure map! ((procedure (*) *) list #!rest list) list))
(map-in-order (procedure map-in-order ((procedure (*) *) list #!rest list) list))
(ninth (procedure ninth (pair) *))
(not-pair? (procedure not-pair? (*) boolean))
(null-list? (procedure null-list? (list) boolean))
(pair-fold (procedure pair-fold (procedure * list #!rest list) *))
(pair-fold-right (procedure pair-fold-right (procedure * list #!rest list) *))
(pair-for-each (procedure pair-for-each ((procedure (#!rest) . *) list #!rest list) undefined))
(partition (procedure partition ((procedure (*) *) list) list list))
(partition! (procedure partition! ((procedure (*) *) list) list list))
(proper-list? (procedure proper-list? (*) boolean))
(reduce (procedure reduce ((procedure (* *) *) * list) *))
(reduce-right (procedure reduce-right ((procedure (* *) *) * list) *))
(remove (procedure remove ((procedure (*) *) list) list))
(remove! (procedure remove! ((procedure (*) *) list) list))
(reverse! (procedure reverse! (list) list))
(second (procedure second (pair) *))
(seventh (procedure seventh (pair) *))
(sixth (procedure sixth (pair) *))
(span (procedure span ((procedure (*) *) list) list list))
(span! (procedure span! ((procedure (*) *) list) list list))
(split-at (procedure split-at (list fixnum) list list))
(split-at! (procedure split-at! (list fixnum) list list))
(take (procedure take (list fixnum) list))
(take! (procedure take! (list fixnum) list))
(take-right (procedure take-right (list fixnum) list))
(take-while (procedure take-while ((procedure (*) *) list) list))
(take-while! (procedure take-while! ((procedure (*) *) list) list))
(tenth (procedure tenth (pair) *))
(third (procedure third (pair) *))
(unfold (procedure unfold ((procedure (*) *) (procedure (*) *) (procedure (*) *) * #!optional (procedure (*) *)) *))
(unfold-right (procedure unfold-right ((procedure (*) *) (procedure (*) *) (procedure (*) *) * #!optional (procedure (*) *)) *))
(unzip1 (procedure unzip1 (list) list))
(unzip2 (procedure unzip2 (list) list list))
(unzip3 (procedure unzip3 (list) list list list))
(unzip4 (procedure unzip4 (list) list list list list))
(unzip5 (procedure unzip5 (list) list list list list list))
(xcons (procedure xcons (* *) pair))
(zip (procedure zip (list #!rest list) list))

;; srfi-13

(check-substring-spec (procedure check-substring-spec (* string fixnum fixnum) undefined))
(kmp-step (procedure kmp-step (string vector char fixnum (procedure (char char) *) fixnum) fixnum))
(make-kmp-restart-vector (procedure make-kmp-restart-vector (string #!optional (procedure (* *) *) fixnum fixnum) vector))
(string->list (procedure string->list (string) list))
(string-any (procedure string-any (* string #!optional fixnum fixnum) boolean))
(string-append/shared (procedure string-append/shared (#!rest string) string))
(string-ci< (procedure string-ci< (string string #!optional fixnum fixnum) boolean))
(string-ci<= (procedure string-ci<= (string string #!optional fixnum fixnum) boolean))
(string-ci<> (procedure string-ci<> (string string #!optional fixnum fixnum) boolean))
(string-ci= (procedure string-ci= (string string #!optional fixnum fixnum) boolean))
(string-ci> (procedure string-ci> (string string #!optional fixnum fixnum) boolean))
(string-ci>= (procedure string-ci>= (string string #!optional fixnum fixnum) boolean))
(string-compare (procedure string-compare (string string (procedure (fixnum) *) (procedure (fixnum) *) (procedure (fixnum) *) #!optional fixnum fixnum fixnum fixnum) *))
(string-compare-ci (procedure string-compare (string string (procedure (fixnum) *) (procedure (fixnum) *) (procedure (fixnum) *) #!optional fixnum fixnum fixnum fixnum) *))
(string-concatenate (procedure string-concatenate (list) string))
(string-concatenate-reverse (procedure string-concatenate-reverse (list) string))
(string-concatenate-reverse/shared (procedure string-concatenate-reverse/shared (list) string))
(string-concatenate/shared (procedure string-concatenate/shared (list) string))
(string-contains (procedure string-contains (string string #!optional fixnum fixnum fixnum fixnum) *))
(string-contains-ci (procedure string-contains-ci (string string #!optional fixnum fixnum fixnum fixnum) *))
(string-copy (procedure string-copy (string #!optional fixnum fixnum) string))
(string-copy! (procedure string-copy! (string fixnum string #!optional fixnum fixnum) undefined))
(string-count (procedure string-count (string * #!optional fixnum fixnum) fixnum))
(string-delete (procedure string-delete (* string #!optional fixnum fixnum) string))
(string-downcase (procedure string-downcase (string #!optional fixnum fixnum) string))
(string-downcase! (procedure string-downcase! (string #!optional fixnum fixnum) string))
(string-drop (procedure string-drop (string fixnum) string))
(string-drop-right (procedure string-drop-right (string fixnum) string))
(string-every (procedure string-every (* string #!optional fixnum fixnum) boolean))
(string-fill! (procedure string-fill! (string char) string))
(string-filter (procedure string-filter (* string #!optional fixnum fixnum) string))
(string-fold (procedure string-fold ((procedure (char *) *) * string #!optional fixnum fixnum) *))
(string-fold-right (procedure string-fold-right ((procedure (char *) *) * string #!optional fixnum fixnum) *))
(string-for-each (procedure string-for-each ((procedure (char) . *) string #!optional fixnum fixnum) undefined))
(string-for-each-index (procedure string-for-each-index ((procedure (fixnum) . *) string #!optional fixnum fixnum) undefined))
(string-index (procedure string-index (string * #!optional fixnum fixnum) *))
(string-index-right (procedure string-index-right (string * #!optional fixnum fixnum) *))
(string-join (procedure string-join (list #!optional string symbol) string))
(string-kmp-partial-search (procedure string-kmp-partial-search (string vector string fixnum #!optional (procedure (char char) *) fixnum fixnum fixnum) fixnum))
(string-map (procedure string-map ((procedure (char) char) string #!optional fixnum fixnum) string))
(string-map! (procedure string-map! ((procedure (char) char) string #!optional fixnum fixnum) string))
(string-null? (procedure string-null? (string) boolean))
(string-pad (procedure string-pad (string fixnum #!optional char fixnum fixnum) string))
(string-pad-right (procedure string-pad-right (string fixnum #!optional char fixnum fixnum) string))
(string-parse-final-start+end (procedure string-parse-final-start+end (procedure string #!rest) . *))
(string-parse-start+end (procedure string-parse-start+end (procedure string #!rest) . *))
(string-prefix-ci? (procedure string-prefix-ci? (string string #!optional fixnum fixnum fixnum fixnum) boolean))
(string-prefix-length (procedure string-prefix-length (string string #!optional fixnum fixnum fixnum fixnum) fixnum))
(string-prefix-length-ci (procedure string-prefix-length-ci (string string #!optional fixnum fixnum fixnum fixnum) fixnum))
(string-prefix? (procedure string-prefix? (string string #!optional fixnum fixnum fixnum fixnum) boolean))
(string-replace (procedure string-replace (string string fixnum fixnum #!optional fixnum fixnum) string))
(string-reverse (procedure string-reverse (string #!optional fixnum fixnum) string))
(string-reverse! (procedure string-reverse! (string #!optional fixnum fixnum) string))
(string-skip (procedure string-skip (string * #!optional fixnum fixnum) fixnum))
(string-skip-right (procedure string-skip-right (string * #!optional fixnum fixnum) fixnum))
(string-suffix-ci? (procedure string-suffix-ci? (string string #!optional fixnum fixnum fixnum fixnum) fixnum))
(string-suffix-length (procedure string-suffix-length (string string #!optional fixnum fixnum fixnum fixnum) fixnum))
(string-suffix-length-ci (procedure string-suffix-length-ci (string string #!optional fixnum fixnum fixnum fixnum) fixnum))
(string-suffix? (procedure string-suffix? (string string #!optional fixnum fixnum fixnum fixnum) fixnum))
(string-tabulate (procedure string-tabulate ((procedure (fixnum) char) fixnum) string))
(string-take (procedure string-take (string fixnum) string))
(string-take-right (procedure string-take-right (string fixnum) string))
(string-titlecase (procedure string-titlecase (string #!optional fixnum fixnum) string))
(string-titlecase! (procedure string-titlecase! (string #!optional fixnum fixnum) string))
(string-tokenize (procedure string-tokenize (string #!optional * fixnum fixnum) list))
(string-trim (procedure string-trim (string #!optional * fixnum fixnum) string))
(string-trim-both (procedure string-trim-both (string #!optional * fixnum fixnum) string))
(string-trim-right (procedure string-trim-right (string #!optional * fixnum fixnum) string))
(string-unfold (procedure string-unfold (procedure procedure procedure * #!optional * procedure) string))
(string-unfold-right (procedure string-unfold-right (procedure procedure procedure * #!optional * procedure) string))
(string-upcase (procedure string-upcase (string #!optional fixnum fixnum) string))
(string-upcase! (procedure string-upcase! (string #!optional fixnum fixnum) string))
(string-xcopy! (procedure string-xcopy! (string string string fixnum #!optional fixnum fixnum fixnum) string))
(string< (procedure string< (string string #!optional fixnum fixnum fixnum fixnum) boolean))
(string<= (procedure string<= (string string #!optional fixnum fixnum fixnum fixnum) boolean))
(string<> (procedure string<> (string string #!optional fixnum fixnum fixnum fixnum) boolean))
(string= (procedure string= (string string #!optional fixnum fixnum fixnum fixnum) boolean))
(string> (procedure string> (string string #!optional fixnum fixnum fixnum fixnum) boolean))
(string>= (procedure string>= (string string #!optional fixnum fixnum fixnum fixnum) boolean))
(substring-spec-ok? (procedure substring-spec-ok? (string fixnum fixnum) boolean))
(substring/shared (procedure substring/shared (string fixnum #!optional fixnum) string))
(xsubstring (procedure xsubstring (string fixnum #!optional fixnum fixnum fixnum) string))

;; srfi-14

(->char-set (procedure ->char-set (*) (struct char-set)))
(char-set (procedure char-set (#!rest char) (struct char-set)))
(char-set->list (procedure char-set->list ((struct char-set)) list))
(char-set->string (procedure char-set->string ((struct char-set)) string))
(char-set-adjoin (procedure char-set-adjoin ((struct char-set) #!rest char) (struct char-set)))
(char-set-adjoin! (procedure char-set-adjoin! ((struct char-set) #!rest char) (struct char-set)))
(char-set-any (procedure char-set-any ((procedure (char) *) (struct char-set)) *))
(char-set-complement (procedure char-set-complement ((struct char-set)) (struct char-set)))
(char-set-complement! (procedure char-set-complement! ((struct char-set)) (struct char-set)))
(char-set-contains? (procedure char-set-contains? ((struct char-set) char) boolean))
(char-set-copy (procedure char-set-copy ((struct char-set)) (struct char-set)))
(char-set-count (procedure char-set-count ((procedure (char) *) (struct char-set)) fixnum))
(char-set-cursor (procedure char-set-cursor ((struct char-set)) fixnum))
(char-set-cursor-next (procedure char-set-cursor-next ((struct char-set) fixnum) fixnum))
(char-set-delete (procedure char-set-delete ((struct char-set) #!rest char) (struct char-set)))
(char-set-delete! (procedure char-set-delete! ((struct char-set) #!rest char) (struct char-set)))
(char-set-diff+intersection (procedure char-set-diff+intersection ((struct char-set) #!rest (struct char-set)) (struct char-set) (struct char-set)))
(char-set-diff+intersection! (procedure char-set-diff+intersection! ((struct char-set) #!rest (struct char-set)) (struct char-set) (struct char-set)))
(char-set-difference (procedure char-set-difference ((struct char-set) #!rest (struct char-set)) (struct char-set)))
(char-set-difference! (procedure char-set-difference! ((struct char-set) #!rest (struct char-set)) (struct char-set)))
(char-set-every (procedure char-set-every ((procedure (char) *) (struct char-set)) boolean))
(char-set-filter (procedure char-set-filter ((procedure (char) *) (struct char-set) #!optional (struct char-set)) (struct char-set)))
(char-set-filter! (procedure char-set-filter! ((procedure (char) *) (struct char-set) #!optional (struct char-set)) (struct char-set)))
(char-set-fold (procedure char-set-fold ((procedure (char *) *) * (struct char-set)) *))
(char-set-for-each (procedure char-set-for-each ((procedure (char) . *) (struct char-set)) undefined))
(char-set-hash (procedure char-set-hash ((struct char-set) #!optional number) number))
(char-set-intersection (procedure char-set-intersection (#!rest (struct char-set)) (struct char-set)))
(char-set-intersection! (procedure char-set-intersection! (#!rest (struct char-set)) (struct char-set)))
(char-set-map (procedure char-set-map ((procedure (char) char) (struct char-set)) (struct char-set)))
(char-set-ref (procedure char-set-ref ((struct char-set) fixnum) char))
(char-set-size (procedure char-set-size ((struct char-set)) fixnum))
(char-set-unfold (procedure char-set-unfold (procedure procedure procedure * #!optional (struct char-set)) (struct char-set)))
(char-set-unfold! (procedure char-set-unfold! () (procedure procedure procedure * (struct char-set)) (struct char-set)))
(char-set-union (procedure char-set-union (#!rest (struct char-set)) (struct char-set)))
(char-set-union! (procedure char-set-union! (#!rest (struct char-set)) (struct char-set)))
(char-set-xor (procedure char-set-xor (#!rest (struct char-set)) (struct char-set)))
(char-set-xor! (procedure char-set-xor! (#!rest (struct char-set)) (struct char-set)))
(char-set:ascii (struct char-set))
(char-set:blank (struct char-set))
(char-set:digit (struct char-set))
(char-set:empty (struct char-set))
(char-set:full (struct char-set))
(char-set:graphic (struct char-set))
(char-set:hex-digit (struct char-set))
(char-set:iso-control (struct char-set))
(char-set:letter (struct char-set))
(char-set:letter+digit (struct char-set))
(char-set:lower-case (struct char-set))
(char-set:printing (struct char-set))
(char-set:punctuation (struct char-set))
(char-set:s (procedure (struct char-set) *))
(char-set:symbol (struct char-set))
(char-set:title-case (struct char-set))
(char-set:upper-case (struct char-set))
(char-set:whitespace (struct char-set))
(char-set<= (procedure char-set<= (#!rest (struct char-set)) boolean))
(char-set= (procedure char-set= (#!rest (struct char-set)) boolean))
(char-set? (procedure char-set? (*) boolean))
(end-of-char-set? (procedure end-of-char-set? (fixnum) boolean))
(list->char-set (procedure list->char-set (list #!optional (struct char-set)) (struct char-set)))
(list->char-set! (procedure list->char-set! (list #!optional (struct char-set)) (struct char-set)))
(string->char-set (procedure string->char-set (string #!optional (struct char-set)) (struct char-set)))
(string->char-set! (procedure string->char-set! (string #!optional (struct char-set)) (struct char-set)))
(ucs-range->char-set (procedure ucs-range->char-set (fixnum fixnum #!optional * (struct char-set)) (struct char-set)))
(ucs-range->char-set! (procedure ucs-range->char-set! (fixnum fixnum #!optional * (struct char-set)) (struct char-set)))

;; srfi-18

(abandoned-mutex-exception? (procedure abandoned-mutex-exception? (*) boolean))
(condition-variable-broadcast! (procedure condition-variable-broadcast! ((struct condition-variable)) undefined))
(condition-variable-signal! (procedure condition-variable-signal! ((struct condition-variable)) undefined))
(condition-variable-specific (procedure condition-variable-specific ((struct condition-vasriable)) *))
(condition-variable-specific-set! (procedure condition-variable-specific-set! ((struct condition-variable) *) undefined))
(condition-variable? (procedure condition-variable? (*) boolean))
(current-thread (procedure current-thread () (struct thread)))
(current-time (procedure current-time () number))
(join-timeout-exception? (procedure join-timeout-exception? (*) boolean))
(make-condition-variable (procedure make-condition-variable (#!optional *) (struct condition-variable)))
(make-mutex (procedure make-mutex (#!optional *) (struct mutex)))
(make-thread (procedure make-thread ((procedure () . *) #!optional *) (struct thread)))
(milliseconds->time (procedure milliseconds->time (fixnum) (struct time)))
(mutex-lock! (procedure mutex-lock! ((struct mutex) #!optional * (struct thread)) boolean))
(mutex-name (procedure mutex-name ((struct mutex)) *))
(mutex-specific (procedure mutex-specific ((struct mutex)) *))
(mutex-specific-set! (procedure mutex-specific-set! ((struct mutex) *) undefined))
(mutex-state (procedure mutex-state ((struct mutex)) symbol))
(mutex-unlock! (procedure mutex-unlock! ((struct mutex) #!optional (struct condition-variable) *) undefined))
(mutex? (procedure mutex? (*) boolean))
(raise (procedure raise (*) noreturn))
(seconds->time (procedure seconds->time (number) (struct time)))
(terminated-thread-exception? (procedure terminated-thread-exception? (*) boolean))
(thread-join! (procedure thread-join! ((struct thread) #!optional *) *))
(thread-name (procedure thread-name ((struct thread)) *))
(thread-quantum (procedure thread-quantum ((struct thread)) fixnum))
(thread-quantum-set! (procedure thread-quantum-set! ((struct thread) fixnum) undefined))
(thread-resume! (procedure thread-resume! ((struct thread)) undefined))
(thread-signal! (procedure thread-signal! ((struct thread) *) undefined))
(thread-sleep! (procedure thread-sleep! (*) undefined))
(thread-specific (procedure thread-specific ((struct thread)) *))
(thread-specific-set! (procedure thread-specific-set! ((struct thread) *) undefined))
(thread-start! (procedure thread-start! ((or (struct thread) (procedure () . *))) (struct thread)))
(thread-state (procedure thread-state ((struct thread)) symbol))
(thread-suspend! (procedure thread-suspend! ((struct thread)) undefined))
(thread-terminate! (procedure thread-terminate! ((struct thread)) undefined))
(thread-wait-for-i/o! (procedure thread-wait-for-i/o! (fixnum #!optional symbol) undefined))
(thread-yield! (procedure thread-yield! () undefined))
(thread? (procedure thread? (*) boolean))
(time->milliseconds (procedure time->milliseconds ((struct time)) fixnum))
(time->seconds (procedure time->seconds ((struct time)) number))
(time? (procedure time? (*) boolean))
(uncaught-exception-reason (procedure uncaught-exception-reason ((struct condition)) *))
(uncaught-exception? (procedure uncaught-exception? (*) boolean))

;; srfi-4

(blob->f32vector (procedure blob->f32vector (blob) (struct f32vector)))
(blob->f32vector/shared (procedure blob->f32vector/shared (blob) (struct f32vector)))
(blob->f64vector (procedure blob->f64vector (blob) (struct f64vector)))
(blob->f64vector/shared (procedure blob->f64vector/shared (blob) (struct f64vector)))
(blob->s16vector (procedure blob->s16vector (blob) (struct s16vector)))
(blob->s16vector/shared (procedure blob->s16vector/shared (blob) (struct s16vector)))
(blob->s32vector (procedure blob->s32vector (blob) (strucrt s32vector)))
(blob->s32vector/shared (procedure blob->s32vector/shared (blob) (struct s32vector)))
(blob->s8vector (procedure blob->s8vector (blob) (struct u8vector)))
(blob->s8vector/shared (procedure blob->s8vector/shared (blob) (struct u8vector)))
(blob->u16vector (procedure blob->u16vector (blob) (struct u16vector)))
(blob->u16vector/shared (procedure blob->u16vector/shared (blob) (struct u16vector)))
(blob->u32vector (procedure blob->u32vector (blob) (struct u32vector)))
(blob->u32vector/shared (procedure blob->u32vector/shared (blob) (struct u32vector)))
(blob->u8vector (procedure blob->u8vector (blob) (struct u8vector)))
(blob->u8vector/shared (procedure blob->u8vector/shared (blob) (struct u8vector)))
(f32vector (procedure f32vector (#!rest number) (struct f32vector)))
(f32vector->blob (procedure f32vector->blob ((struct f32vector)) blob))
(f32vector->blob/shared (procedure f32vector->blob/shared ((struct f232vector)) blob))
(f32vector->list (procedure f32vector->list ((struct f32vector)) list))
(f32vector-length (procedure f32vector-length ((struct f32vector)) fixnum))
(f32vector-ref (procedure f32vector-ref ((struct f32vector) fixnum) float))
(f32vector-set! (procedure f32vector-set! ((struct f32vector) fixnum number) undefined))
(f32vector? (procedure f32vector? (*) boolean))
(f64vector (procedure f64vector (#!rest number) (struct f64vector)))
(f64vector->blob (procedure f64vector->blob ((struct f32vector)) blob))
(f64vector->blob/shared (procedure f64vector->blob/shared ((struct f64vector)) blob))
(f64vector->list (procedure f64vector->list ((struct f64vector)) blob))
(f64vector-length (procedure f64vector-length ((struct f64vector)) fixnum))
(f64vector-ref (procedure f64vector-ref ((struct f64vector) fixnum) float))
(f64vector-set! (procedure f64vector-set! ((struct f64vector) fixnum number) undefined))
(f64vector? (procedure f64vector? (*) boolean))
(list->f32vector (procedure list->f32vector (list) (struct f32vector)))
(list->f64vector (procedure list->f64vector (list) (struct f64vector)))
(list->s16vector (procedure list->s16vector (list) (struct s16vector)))
(list->s32vector (procedure list->s32vector (list) (struct s32vector)))
(list->s8vector (procedure list->s8vector (list) (struct s8vector)))
(list->u16vector (procedure list->u16vector (list) (struct u16vector)))
(list->u32vector (procedure list->u32vector (list) (struct u32vector)))
(list->u8vector (procedure list->u8vector (list) (struct u8vector)))
(make-f32vector (procedure make-f32vector (fixnum #!optional * * *) (struct f32vector)))
(make-f64vector (procedure make-f64vector (fixnum #!optional * * *) (struct f64vector)))
(make-s16vector (procedure make-s16vector (fixnum #!optional * * *) (struct s16vector)))
(make-s32vector (procedure make-s32vector (fixnum #!optional * * *) (struct s32vector)))
(make-s8vector (procedure make-s8vector (fixnum #!optional * * *) (struct s8vector)))
(make-u16vector (procedure make-u16vector (fixnum #!optional * * *) (struct u16vector)))
(make-u32vector (procedure make-u32vector (fixnum #!optional * * *) (struct u32vector)))
(make-u8vector (procedure make-u8vector (fixnum #!optional * * *) (struct u8vector)))
(read-u8vector (procedure read-u8vector (#!optional fixnum port) (struct u8vector)))
(read-u8vector! (procedure read-u8vector! (fixnum (struct u8vector) #!optional port fixnum) (struct u8vector)))
(release-number-vector (procedure release-number-vector (*) undefined))
(s16vector (procedure s16vector (#!rest fixnum) (struct s16vector)))
(s16vector->blob (procedure s16vector->blob ((struct s16vector)) blob))
(s16vector->blob/shared (procedure s16vector->blob/shared ((struct s16vector)) blob))
(s16vector->list (procedure s16vector->list ((struct s16vector)) list))
(s16vector-length (procedure s16vector-length ((struct s16vector)) fixnum))
(s16vector-ref (procedure s16vector-ref ((struct s16vector) fixnum) fixnum))
(s16vector-set! (procedure s16vector-set! ((struct s16vewctor) fixnum fixnum) undefined))
(s16vector? (procedure s16vector? (*) boolean))
(s32vector (procedure s32vector (#!rest number) (struct s32vector)))
(s32vector->blob (procedure s32vector->blob ((structs 32vector)) blob))
(s32vector->blob/shared (procedure s32vector->blob/shared ((struct s32vector)) blob))
(s32vector->list (procedure s32vector->list ((struct s32vector)) list))
(s32vector-length (procedure s32vector-length ((struct s32vector)) fixnum))
(s32vector-ref (procedure s32vector-ref ((struct s32vector) fixnum) number))
(s32vector-set! (procedure s32vector-set! ((struct s32vector) fixnum number) undefined))
(s32vector? (procedure s32vector? (*) boolean))
(s8vector (procedure s8vector (#!rest fixnum) (struct s8vector)))
(s8vector->blob (procedure s8vector->blob ((struct s8vector)) blob))
(s8vector->blob/shared (procedure s8vector->blob/shared ((struct s8vector)) blob))
(s8vector->list (procedure s8vector->list ((struct s8vector)) list))
(s8vector-length (procedure s8vector-length ((struct s8vector)) fixnum))
(s8vector-ref (procedure s8vector-ref ((struct s18vector) fixnum) fixnum))
(s8vector-set! (procedure s8vector-set! ((struct s8vector) fixnum fixnum) undefined))
(s8vector? (procedure s8vector? (*) boolean))
(subf32vector (procedure subf32vector ((struct f32vector) fixnum fixnum) (struct f32vector)))
(subf64vector (procedure subf64vector ((struct f64vector) fixnum fixnum) (struct f64vector)))
(subs16vector (procedure subs16vector ((struct s16vector) fixnum fixnum) (struct s16vector)))
(subs32vector (procedure subs32vector ((struct s32vector) fixnum fixnum) (struct s32vector)))
(subs8vector (procedure subs8vector  ((struct s8vector) fixnum fixnum) (struct s8vector)))
(subu16vector (procedure subu16vector ((struct u16vector) fixnum fixnum) (struct u16vector)))
(subu32vector (procedure subu32vector ((struct u32vector) fixnum fixnum) (struct u32vector)))
(subu8vector (procedure subu8vector ((struct u8vector) fixnum fixnum) (struct u8vector)))
(u16vector (procedure u16vector (#!rest fixnum) (struct u16vector)))
(u16vector->blob (procedure u16vector->blob ((struct u16vector)) blob))
(u16vector->blob/shared (procedure u16vector->blob/shared ((struct u16vector)) blob))
(u16vector->list (procedure u16vector->list ((struct u16vector)) list))
(u16vector-length (procedure u16vector-length ((struct u16vector)) fixnum))
(u16vector-ref (procedure u16vector-ref ((struct u16vector) fixnum) fixnum))
(u16vector-set! (procedure u16vector-set! ((struct u16vector) fixnum fixnum) undefined))
(u16vector? (procedure u16vector? (*) boolean))
(u32vector (procedure u32vector (#!rest number) (struct u32vector)))
(u32vector->blob (procedure u32vector->blob ((struct u32vector)) blob))
(u32vector->blob/shared (procedure u32vector->blob/shared ((struct u32vector)) blob))
(u32vector->list (procedure u32vector->list ((struct u32vector)) list))
(u32vector-length (procedure u32vector-length ((struct u32vector)) fixnum))
(u32vector-ref (procedure u32vector-ref ((struct u32vector) fixnum) number))
(u32vector-set! (procedure u32vector-set! ((struct u32vector) fixnum number) undefined))
(u32vector? (procedure u32vector? (*) boolean))
(u8vector (procedure u8vector (#!rest fixnum) (struct u8vector)))
(u8vector->blob (procedure u8vector->blob ((struct u8vector)) blob))
(u8vector->blob/shared (procedure u8vector->blob/shared ((struct u8vector)) blob))
(u8vector->list (procedure u8vector->list ((struct u8vector)) list))
(u8vector-length (procedure u8vector-length ((struct u8vector)) fixnum))
(u8vector-ref (procedure u8vector-ref ((struct u8vector) fixnum) fixnum))
(u8vector-set! (procedure u8vector-set! ((struct u8vector) fixnum fixnum) undefined))
(u8vector? (procedure u8vector? (*) boolean))
(write-u8vector (procedure write-u8vector ((struct u8vector) #!optional port fixnum fixnum) undefined))

;; srfi-69

(alist->hash-table (procedure alist->hash-table (list #!rest) (struct hash-table)))
(eq?-hash (procedure eq?-hash (* #!optional fixnum) fixnum))
(equal?-hash (procedure equal?-hash (* #!optional fixnum) fixnum))
(eqv?-hash (procedure eqv?-hash (* #!optional fixnum) fixnum))
(hash (procedure hash (* #!optional fixnum) fixnum))
(hash-by-identity (procedure hash-by-identity (* #!optional fixnum) fixnum))
(hash-table->alist (procedure hash-table->alist ((struct hash-table)) list))
(hash-table-clear! (procedure hash-table-clear! ((struct hash-table)) undefined))
(hash-table-copy (procedure hash-table-copy ((struct hash-table)) (struct hash-table)))
(hash-table-delete! (procedure hash-table-delete! ((struct hash-table) *) boolean))
(hash-table-equivalence-function (procedure hash-table-equivalence-function ((struct hash-table)) (procedure (* *) *)))
(hash-table-exists? (procedure hash-table-exists? ((struct hash-table) *) boolean))
(hash-table-fold (procedure hash-table-fold ((struct hash-table) (procedure (* * *) *) *) *))
(hash-table-for-each (procedure hash-table-for-each ((struct hash-table) (procedure (* *) . *)) undefined))
(hash-table-has-initial? (procedure hash-table-has-initial? ((struct hash-table)) boolean))
(hash-table-hash-function (procedure hash-table-hash-function ((struct hash-table)) (procedure (* fixnum) fixnum)))
(hash-table-initial (procedure hash-table-initial ((struct hash-table)) *))
(hash-table-keys (procedure hash-table-keys ((struct hash-table)) list))
(hash-table-map (procedure hash-table-map ((struct hash-table) (procedure (* *) *)) list))
(hash-table-max-load (procedure hash-table-max-load ((struct hash-table)) fixnum))
(hash-table-merge (procedure hash-table-merge ((struct hash-table) (struct hash-table)) (struct hash-table)))
(hash-table-merge! (procedure hash-table-merge! ((struct hash-table) (struct hash-table)) undefined))
(hash-table-min-load (procedure hash-table-min-load ((struct hash-table)) fixnum))
(hash-table-ref (procedure hash-table-ref ((struct hash-table) * #!optional (procedure () *)) *))
(hash-table-ref/default (procedure hash-table-ref/default ((struct hash-table) * *) *))
(hash-table-remove! (procedure hash-table-remove! ((struct hash-table) (procedure (* *) *)) undefined))
(hash-table-set! (procedure hash-table-set! ((struct hash-table) * *) undefined))
(hash-table-size (procedure hash-table-size ((struct hash-table)) fixnum))
(hash-table-update! (procedure hash-table-update! ((struct hash-table) * #!optional (procedure (*) *) (procedure () *)) *))
(hash-table-update!/default (procedure hash-table-update!/default ((struct hash-table) * (procedure (*) *) (procedure () *)) *))
(hash-table-values (procedure hash-table-values ((struct hash-table)) list))
(hash-table-walk (procedure hash-table-walk ((struct hash-table) (procedure (* *) . *)) undefined))
(hash-table-weak-keys (procedure hash-table-weak-keys ((struct hash-table)) boolean))
(hash-table-weak-values (procedure hash-table-weak-values ((struct hash-table)) boolean))
(hash-table? (procedure hash-table? (*) boolean))
(keyword-hash (procedure keyword-hash (* #!optional fixnum) fixnum))
(make-hash-table (procedure make-hash-table (#!rest) (struct hash-table)))
(number-hash (procedure number-hash (fixnum #!optional fixnum) fixnum))
(object-uid-hash (procedure object-uid-hash (* #!optional fixnum) fixnum))
(symbol-hash (procedure symbol-hash (symbol #!optional fixnum) fixnum))
(string-hash (procedure string-hash (string #!optional fixnum fixnum fixnum) number))
(string-hash-ci (procedure string-hash-ci (string #!optional fixnum fixnum fixnum) number))
(string-ci-hash (procedure string-ci-hash (string #!optional fixnum fixnum fixnum) number))

;; tcp

(tcp-abandon-port (procedure tcp-abandon-port (port) undefined))
(tcp-accept (procedure tcp-accept ((struct tcp-listener)) port port))
(tcp-accept-ready? (procedure tcp-accept-ready? ((struct tcp-listener)) boolean))
(tcp-accept-timeout (procedure tcp-accept-timeout (#!optional number) number))
(tcp-addresses (procedure tcp-addresses (port) string string))
(tcp-buffer-size (procedure tcp-buffer-size (#!optional fixnum) fixnum))
(tcp-close (procedure tcp-close ((struct tcp-listener)) undefined))
(tcp-connect (procedure tcp-connect (string #!optional fixnum) port port))
(tcp-connect-timeout (procedure tcp-connect-timeout (#!optional number) number))
(tcp-listen (procedure tcp-listen (fixnum #!optional fixnum *) (struct tcp-listener)))
(tcp-listener-fileno (procedure tcp-listener-fileno ((struct tcp-listener)) fixnum))
(tcp-listener-port (procedure tcp-listener-port ((struct tcp-listener)) fixnum))
(tcp-listener? (procedure tcp-listener? (*) boolean))
(tcp-port-numbers (procedure tcp-port-numbers (port) fixnum fixnum))
(tcp-read-timeout (procedure tcp-read-timeout (#!optional number) number))
(tcp-write-timeout (procedure tcp-write-timeout (#!optional number) number))

;; utils

(for-each-argv-line (procedure for-each-argv-line ((procedure (string) . *)) undefined))
(for-each-line (procedure for-each-line ((procedure (string) . *) #!optional port) undefined))
(read-all (procedure read-all (#!optional (or port string)) string))
(system* (procedure system* (string #!rest) undefined))
(qs (procedure qs (string) string))

;; missing: setup-api, setup-download