Skip to content


Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

1429 lines (1393 sloc) 86.799 kb
;;;; types.db - Type-information for core library functions -*- Scheme -*-
; Copyright (c)2009-2011, 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.
;; 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-append (procedure symbol-append (#!rest symbol) symbol))
(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 #!optional 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))
(vector-copy! (procedure vector-copy! (vector vector #!optional fixnum) undefined))
(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) . *) #!rest) . *))
(call-with-output-file (procedure call-with-output-file (string (procedure (port) . *) #!rest) . *))
(open-input-file (procedure open-input-file (string #!rest symbol) port))
(open-output-file (procedure open-output-file (string #!rest symbol) 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 #!rest symbol) . *))
(with-output-to-file (procedure with-output-to-file (string procedure #!rest 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 () *))
(port-closed? (procedure port-closed? (port) boolean))
;; 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 (#!optional list) 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))
(condition->list (procedure condition->list ((struct condition)) list))
(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 (#!optional procedure) procedure))
(current-gc-milliseconds (procedure current-gc-milliseconds () fixnum))
(current-milliseconds (procedure current-milliseconds () float))
(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) string))
(enable-warnings (procedure enable-warnings (#!optional *) *))
(equal=? (procedure equal=? (* *) boolean))
(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) *))
(directory-exists? (procedure directory-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))
(fpabs (procedure fpabs (float) float))
(fpacos (procedure fpacos (float) float))
(fpasin (procedure fpasin (float) float))
(fpatan (procedure fpatan (float) float))
(fpatan2 (procedure fpatan2 (float float) float))
(fpceiling (procedure fpceiling (float) float))
(fpcos (procedure fpcos (float) float))
(fpexp (procedure fpexp (float) float))
(fpexpt (procedure fpexpt (float float) float))
(fpfloor (procedure fpfloor (float) float))
(fpinteger? (procedure fpinteger? (float) boolean))
(fplog (procedure fplog (float) float))
(fpmax (procedure fpmax (float float) float))
(fpmin (procedure fpmin (float float) float))
(fpneg (procedure fpneg (float) float))
(fpround (procedure fpround (float) float))
(fpsin (procedure fpsin (float) float))
(fpsqrt (procedure fpsqrt (float) float))
(fptan (procedure fptan (float) float))
(fptruncate (procedure fptruncate (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))
(fxeven? (procedure fxeven? (fixnum) boolean))
(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))
(fxodd? (procedure fxodd? (fixnum) boolean))
(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 #!optional *) *))
(get-call-chain (procedure get-call-chain (#!optional fixnum *) list))
(get-condition-property (procedure get-condition-property ((struct condition) symbol symbol #!optional *) *))
(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 (deprecated get-environment-variable))
(getter-with-setter (procedure getter-with-setter (procedure procedure #!optional string) 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 (symbol #!optional 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 (#!optional string) 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) string))
(repl (procedure repl () undefined))
(repl-prompt (procedure repl-prompt (#!optional procedure) procedure))
(repository-path (procedure repository-path (#!optional *) *))
(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 (*) . *)) *))
(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 (#!rest) 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 deprecated)
(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 (deprecated void))
(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)) *))
(queue? (procedure queue? (*) boolean))
(rassoc (procedure rassoc (* list #!optional (procedure (* *) *)) *))
(right-section deprecated)
(reverse-string-append (procedure reverse-string-append (list) string))
(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))
(topological-sort (procedure topological-sort (list (procedure (* *) *)) list))
(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 * #!optional *) 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 (#!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))
(randomize (procedure randomize (#!optional number) undefined))
(read-buffered (procedure read-buffered (#!optional port) string))
(read-byte (procedure read-byte (#!optional port) fixnum))
(read-file (procedure read-file (#!optional (or port string) (procedure (port) *) fixnum) list))
(read-line (procedure read-line (#!optional port fixnum) *))
(read-lines (procedure read-lines (#!optional (or port string) 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) *))
(file-copy (procedure file-copy (string string #!optional * fixnum) fixnum))
(file-move (procedure file-move (string string #!optional * fixnum) fixnum))
(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-directory (procedure create-temporary-directory () string))
(create-temporary-file (procedure create-temporary-file (#!optional string) string))
(decompose-directory (procedure decompose-directory (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 #!optional symbol) string))
;; irregex
(irregex (procedure irregex (#!rest) *))
(irregex-dfa (procedure irregex-dfa (*) *))
(irregex-dfa/extract (procedure irregex-dfa/extract (*) *))
(irregex-dfa/search (procedure irregex-dfa/search (*) *))
(irregex-extract (procedure irregex-extract (* string #!optional fixnum fixnum) list))
(irregex-flags (procedure irregex-flags (*) *))
(irregex-fold (procedure irregex-fold (* (procedure (fixnum (struct regexp-match)) *) * string #!optional (procedure (fixnum *) *) fixnum fixnum) *))
(irregex-fold/chunked (procedure irregex-fold/chunked (* (procedure (fixnum (struct regexp-match)) *) * procedure * #!optional (procedure (fixnum *) *) fixnum fixnum) *))
(irregex-lengths (procedure irregex-lengths (*) *))
(irregex-match (procedure irregex-match (* string) *))
(irregex-match-data? (procedure irregex-match-data? (*) boolean))
(irregex-match-end (procedure irregex-match-end (* #!optional *) *))
(irregex-match-end-index (procedure irregex-match-end-index ((struct regexp-match) #!optional *) fixnum))
(irregex-match-names (procedure irregex-match-names ((struct regexp-match)) list))
(irregex-match-num-submatches (procedure irregex-match-num-submatches ((struct regexp-match)) fixnum))
(irregex-match-start (procedure irregex-match-start (* #!optional *) *))
(irregex-match-start-index (procedure irregex-match-start-index ((struct regexp-match) #!optional *) fixnum))
(irregex-match-string (procedure irregex-match-string (*) *))
(irregex-match-subchunk (procedure irregex-match-subchunk ((struct regexp-match) #!optional *) *))
(irregex-match-substring (procedure irregex-match-substring (* #!optional *) *))
(irregex-match/chunked (procedure irregex-match/chunked (* * * #!optional fixnum) *))
(irregex-names (procedure irregex-names (*) *))
(irregex-new-matches (procedure irregex-new-matches (*) *))
(irregex-nfa (procedure irregex-nfa (*) *))
(irregex-num-submatches (procedure irregex-num-submatches (*) fixnum))
(irregex-opt (procedure irregex-opt (list) *))
(irregex-quote (procedure irregex-quote (string) string))
(irregex-replace (procedure irregex-replace (* string #!rest) *))
(irregex-replace/all (procedure irregex-replace/all (* string #!rest) *))
(irregex-reset-matches! (procedure irregex-reset-matches! (*) *))
(irregex-search (procedure irregex-search (* string #!optional fixnum fixnum) *))
(irregex-search/matches (procedure irregex-search/matches (* string fixnum fixnum *) *))
(irregex-split (procedure irregex-split (* string #!optional fixnum fixnum) list))
(irregex-submatches (procedure irregex-submatches (*) *))
(procedure irregex-match-valid-index? ((struct regexp-match) *) boolean))
(irregex? (procedure irregex? (*) boolean))
(procedure make-irregex-chunker
((procedure (*) *)
(procedure (*) *)
(procedure (*) *)
(procedure (*) *)
(procedure (* fixnum * fixnum) string)
(procedure (* fixnum * fixnum) *))
(maybe-string->sre (procedure maybe-string->sre (*) *))
(sre->irregex (procedure sre->irregex (#!rest) *))
(string->irregex (procedure string->irregex (string #!rest) *))
(string->sre (procedure string->sre (string #!rest) *))
;; 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 *) *))
(clear-unbound-variable-value! (procedure clear-unbound-variable-value! () undefined))
(extend-procedure (procedure extend-procedure (procedure *) procedure))
(extended-procedure? (procedure extended-procedure? (*) boolean))
(free (procedure free (pointer) *))
(global-bound? deprecated)
(global-make-unbound! deprecated)
(global-ref deprecated)
(global-set! deprecated)
(invalid-procedure-call-handler (procedure invalid-procedure-call-handler () procedure))
(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-pointer-vector (procedure make-pointer-vector (fixnum #!optional pointer) pointer-vector))
(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+ (procedure pointer+ (pointer fixnum) pointer))
(pointer->address (procedure pointer->address (pointer) number))
(pointer->object (procedure pointer->object (pointer) *))
(pointer-offset deprecated)
(pointer-like? (procedure pointer-like? (*) boolean))
(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-vector (procedure pointer-vector (#!rest pointer-vector) boolean))
(pointer-vector? (procedure pointer-vector? (*) boolean))
(pointer-vector-fill! (procedure pointer-vector-fill! (pointer-vector pointer) undefined))
(pointer-vector-length (procedure pointer-vector-length (pointer-vector) fixnum))
(pointer-vector-ref (procedure pointer-vector-ref (pointer-vector fixnum) pointer))
(pointer-vector-set! (procedure pointer-vector-set! (pointer-vector fixnum pointer) 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))
(set-unbound-variable-value! (procedure set-unbound-variable-value! (*) undefined))
(tag-pointer (procedure tag-pointer (pointer *) pointer))
(tagged-pointer? (procedure tagged-pointer? (* #!optional *) boolean))
(unbound-variable-value (procedure unbound-variable-value (#!optional *) undefined))
(unbound-variable-given-value (procedure unbound-variable-given-value () *))
(unbound-variable-signals-error? (procedure unbound-variable-signals-error? () boolean))
(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))
(copy-port (procedure copy-port (* * #!optional (procedure (*) *) (procedure (* *) *)) undefined))
(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 deprecated)
(change-directory (procedure change-directory (string) string))
(change-file-mode (procedure change-file-mode (string fixnum) undefined))
(change-file-owner (procedure change-file-owner (string fixnum 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 *) string))
(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 (#!optional string) 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) string))
(directory (procedure directory (string #!optional *) list))
(directory? (procedure directory? ((or string fixnum)) 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)
(file-access-time (procedure file-access-time ((or string fixnum)) number))
(file-change-time (procedure file-change-time ((or string fixnum)) number))
(file-close (procedure file-close (fixnum) undefined))
(file-control (procedure file-control (fixnum fixnum #!optional fixnum) fixnum))
(file-creation-mode (procedure file-creation-mode (#!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 (port #!optional fixnum *) (struct lock)))
(file-lock/blocking (procedure file-lock/blocking (port #!optional fixnum *) (struct lock)))
(file-mkstemp (procedure file-mkstemp (string) fixnum string))
(file-modification-time (procedure file-modification-time ((or string fixnum)) number))
(file-open (procedure file-open (string fixnum #!optional fixnum) fixnum))
(file-owner (procedure file-owner ((or string fixnum)) fixnum))
(file-permissions (procedure file-permissions ((or string fixnum)) fixnum))
(file-position (procedure file-position ((or port fixnum)) 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 ((or string fixnum)) number))
(file-stat (procedure file-stat ((or string fixnum) #!optional *) vector))
(file-test-lock (procedure file-test-lock (port #!optional fixnum *) boolean))
(file-truncate (procedure file-truncate ((or string fixnum) fixnum) undefined))
(file-type (procedure ((or string fixnum) #!optional * *) symbol))
(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 #!rest) 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? ((or string fixnum)) boolean))
(seconds->local-time (procedure seconds->local-time (#!optional number) vector))
(seconds->string (procedure seconds->string (#!optional number) string))
(seconds->utc-time (procedure seconds->utc-time (#!optional 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-file-position! (procedure set-file-position! ((or port fixnum) fixnum #!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))
(block-device? (procedure block-device? ((or string fixnum)) boolean))
(character-device? (procedure character-device? ((or string fixnum)) boolean))
(fifo? (procedure fifo? ((or string fixnum)) boolean))
(socket? (procedure socket? ((or string fixnum)) boolean))
(string->time (procedure string->time (string #!optional string) vector))
(symbolic-link? (procedure symbolic-link? ((or string fixnum)) 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) . *))
;; 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 (* #!rest) *) 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) *))
(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) boolean))
(lset= (procedure lset= ((procedure (* *) *) list #!rest list) boolean))
(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) (or fixnum boolean)))
(string-contains-ci (procedure string-contains-ci (string string #!optional fixnum fixnum fixnum fixnum) (or fixnum boolean)))
(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) (or fixnum boolean)))
(string-index-right (procedure string-index-right (string * #!optional fixnum fixnum) (or fixnum boolean)))
(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) (or fixnum boolean)))
(string-skip-right (procedure string-skip-right (string * #!optional fixnum fixnum) (or fixnum boolean)))
(string-suffix-ci? (procedure string-suffix-ci? (string string #!optional fixnum fixnum fixnum fixnum) boolean))
(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) boolean))
(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: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-name (procedure condition-variable-name ((struct condition-variable)) *))
(condition-variable-signal! (procedure condition-variable-signal! ((struct condition-variable)) undefined))
(condition-variable-specific (procedure condition-variable-specific ((struct condition-variable)) *))
(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 () (struct time)))
(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 deprecated)
(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 deprecated)
(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) number))
(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) * (procedure (*) *) #!optional (procedure () *)) *))
(hash-table-update!/default (procedure hash-table-update!/default ((struct hash-table) * (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 deprecated)
(for-each-line deprecated)
(read-all (procedure read-all (#!optional (or port string)) string))
(system* (procedure system* (string #!rest) undefined))
(qs (procedure qs (string) string))
(compile-file (procedure compile-file (string #!rest) (or boolean string)))
(compile-file-options (procedure compile-file-options (#!optional list) list))
(scan-input-lines (procedure scan-input-lines (* #!optional port) *))
(yes-or-no? (procedure yes-or-no? (string #!rest) *))
Jump to Line
Something went wrong with that request. Please try again.