cyclone/docs/api/api-index.scm

((abs (scheme base))
(acos (scheme inexact))
(adb:clear! (scheme cyclone cps-optimizations))
(adbf:set-simple! (scheme cyclone cps-optimizations))
(adbf:set-unused-params! (scheme cyclone cps-optimizations))
(adbf:simple (scheme cyclone cps-optimizations))
(adb:function? (scheme cyclone cps-optimizations))
(adbf:unused-params (scheme cyclone cps-optimizations))
(adb:get (scheme cyclone cps-optimizations))
(adb:get-db (scheme cyclone cps-optimizations))
(adb:get default (scheme cyclone cps-optimizations))
(adb:make-fnc (scheme cyclone cps-optimizations))
(adb:make-var (scheme cyclone cps-optimizations))
(adb:set! (scheme cyclone cps-optimizations))
(adb:variable? (scheme cyclone cps-optimizations))
(adbv:assigned-value (scheme cyclone cps-optimizations))
(adbv:const? (scheme cyclone cps-optimizations))
(adbv:const-value (scheme cyclone cps-optimizations))
(adbv:defined-by (scheme cyclone cps-optimizations))
(adbv:global? (scheme cyclone cps-optimizations))
(adbv:reassigned? (scheme cyclone cps-optimizations))
(adbv:ref-by (scheme cyclone cps-optimizations))
(adbv:set-assigned-value! (scheme cyclone cps-optimizations))
(adbv:set-const! (scheme cyclone cps-optimizations))
(adbv:set-const-value! (scheme cyclone cps-optimizations))
(adbv:set-defined-by! (scheme cyclone cps-optimizations))
(adbv:set-global! (scheme cyclone cps-optimizations))
(adbv:set-reassigned! (scheme cyclone cps-optimizations))
(adbv:set-ref-by! (scheme cyclone cps-optimizations))
(address-family (srfi 106))
(address-info (srfi 106))
(alist->bag (srfi 113))
(alist-cons (srfi 1))
(alist-copy (srfi 1))
(alist-delete (srfi 1))
(alist-delete! (srfi 1))
(alist->hash-table (srfi 69))
(alpha-convert (scheme cyclone transforms))
(analyze-cps (scheme cyclone cps-optimizations))
(analyze-mutable-variables (scheme cyclone transforms))
(and (scheme base))
(and-let* (srfi 2))
(angle (scheme complex))
(any (scheme base))
(any (srfi 1))
(any-bits-set? (srfi 60))
(app? (scheme cyclone util))
(app->args (scheme cyclone transforms))
(append (scheme base))
(append! (srfi 1))
(append-map (srfi 1))
(append-map! (srfi 1))
(append-reverse (srfi 1))
(append-reverse! (srfi 1))
(app->fun (scheme cyclone transforms))
(apply (primitives))
(arithmetic-shift (srfi 60))
(ash (srfi 60))
(asin (scheme inexact))
(assoc (scheme base))
(assq (scheme base))
(assq-remove-key (scheme cyclone transforms))
(assq-remove-keys (scheme cyclone transforms))
(assv (scheme base))
(ast:ast->pp-sexp (scheme cyclone ast))
(ast:ast->sexp (scheme cyclone ast))
(ast:lambda? (scheme cyclone ast))
(ast:lambda-args (scheme cyclone ast))
(ast:lambda-body (scheme cyclone ast))
(ast:lambda-formals->list (scheme cyclone transforms))
(ast:lambda-formals-type (scheme cyclone transforms))
(ast:lambda-id (scheme cyclone ast))
(ast:make-lambda (scheme cyclone ast))
(ast:set-lambda-args! (scheme cyclone ast))
(ast:set-lambda-body! (scheme cyclone ast))
(ast:sexp->ast (scheme cyclone ast))
(atan (scheme inexact))
(atom (cyclone concurrent))
(atom? (cyclone concurrent))
(azip (scheme cyclone transforms))
(%adb:make-fnc (scheme cyclone cps-optimizations))
(%adb:make-var (scheme cyclone cps-optimizations))
(*af-inet6* (srfi 106))
(*af-inet* (srfi 106))
(*af-unspec* (srfi 106))
(*ai-addrconfig* (srfi 106))
(*ai-all* (srfi 106))
(*ai-canonname* (srfi 106))
(*ai-numerichost* (srfi 106))
(*ai-v4mapped* (srfi 106))
(* (primitives))
(- (primitives))
(+ (primitives))
( (primitives))
(< (primitives))
(<= (primitives))
(= (primitives))
(> (primitives))
(>= (primitives))
(=? (srfi 128))
(<? (srfi 128))
(>? (srfi 128))
(<=? (srfi 128))
(>=? (srfi 128))
(bag-adjoin (srfi 113))
(bag-adjoin! (srfi 113))
(bag->alist (srfi 113))
(bag-any? (srfi 113))
(bag (srfi 113))
(bag? (srfi 113))
(bag=? (srfi 113))
(bag<? (srfi 113))
(bag>? (srfi 113))
(bag<=? (srfi 113))
(bag>=? (srfi 113))
(bag-comparator (srfi 113))
(bag-contains? (srfi 113))
(bag-copy (srfi 113))
(bag-count (srfi 113))
(bag-decrement! (srfi 113))
(bag-delete-all (srfi 113))
(bag-delete-all! (srfi 113))
(bag-delete (srfi 113))
(bag-delete! (srfi 113))
(bag-difference (srfi 113))
(bag-difference! (srfi 113))
(bag-disjoint? (srfi 113))
(bag-element-comparator (srfi 113))
(bag-element-count (srfi 113))
(bag-empty? (srfi 113))
(bag-every? (srfi 113))
(bag-filter (srfi 113))
(bag-filter! (srfi 113))
(bag-find (srfi 113))
(bag-fold (srfi 113))
(bag-fold-unique (srfi 113))
(bag-for-each (srfi 113))
(bag-for-each-unique (srfi 113))
(bag-increment! (srfi 113))
(bag-intersection (srfi 113))
(bag-intersection! (srfi 113))
(bag->list (srfi 113))
(bag-map (srfi 113))
(bag-member (srfi 113))
(bag-partition (srfi 113))
(bag-partition! (srfi 113))
(bag-product (srfi 113))
(bag-product! (srfi 113))
(bag-remove (srfi 113))
(bag-remove! (srfi 113))
(bag-replace (srfi 113))
(bag-replace! (srfi 113))
(bag-search! (srfi 113))
(bag->set (srfi 113))
(bag-size (srfi 113))
(bag-sum (srfi 113))
(bag-sum! (srfi 113))
(bag-unfold (srfi 113))
(bag-union (srfi 113))
(bag-union! (srfi 113))
(bag-unique-size (srfi 113))
(bag-xor (srfi 113))
(bag-xor! (srfi 113))
(basename (scheme cyclone transforms))
(begin (scheme base))
(begin? (scheme cyclone util))
(begin->exps (scheme cyclone transforms))
(bit-count (srfi 60))
(bit-field (srfi 60))
(bit-set? (srfi 60))
(bitwise-and (srfi 60))
(bitwise-if (srfi 60))
(bitwise-ior (srfi 60))
(bitwise-merge (srfi 60))
(bitwise-not (srfi 60))
(bitwise-xor (srfi 60))
(boolean? (primitives))
(boolean=? (scheme base))
(boolean-hash (srfi 128))
(booleans->integer (srfi 60))
(box (srfi 111))
(box? (srfi 111))
(break (srfi 1))
(break! (srfi 1))
(built-in-syms (scheme cyclone transforms))
(bytevector (primitives))
(bytevector? (primitives))
(bytevector-append (primitives))
(bytevector-copy (scheme base))
(bytevector-copy! (scheme base))
(bytevector->generator (srfi 121))
(bytevector-length (primitives))
(bytevector-u8-ref (primitives))
(bytevector-u8-set! (primitives))
(caaaar (scheme cxr))
(caaadr (scheme cxr))
(caaar (scheme cxr))
(caadar (scheme cxr))
(caaddr (scheme cxr))
(caadr (scheme cxr))
(caar (primitives))
(cadaar (scheme cxr))
(cadadr (scheme cxr))
(cadar (scheme cxr))
(caddar (scheme cxr))
(cadddr (scheme cxr))
(caddr (scheme cxr))
(cadr (primitives))
(call cc (scheme base))
(call-with-current-continuation (scheme base))
(call-with-input-file (scheme file))
(call-with-output-file (scheme file))
(call-with-port (scheme base))
(call-with-socket (srfi 106))
(call-with-values (scheme base))
(car (primitives))
(car+cdr (srfi 1))
(case (scheme base))
(case-lambda (scheme case-lambda))
(c-code (cyclone foreign))
(cdaaar (scheme cxr))
(cdaadr (scheme cxr))
(cdaar (scheme cxr))
(cdadar (scheme cxr))
(cdaddr (scheme cxr))
(cdadr (scheme cxr))
(cdar (primitives))
(cddaar (scheme cxr))
(cddadr (scheme cxr))
(cddar (scheme cxr))
(cdddar (scheme cxr))
(cddddr (scheme cxr))
(cdddr (scheme cxr))
(cddr (primitives))
(c-define (cyclone foreign))
(c-define-type (cyclone foreign))
(cdr (primitives))
(ceiling (scheme base))
(cell? (scheme cyclone transforms))
(cell-get? (scheme cyclone transforms))
(cell-get->cell (scheme cyclone transforms))
(cell->value (scheme cyclone transforms))
(char-alphabetic? (scheme char))
(char? (primitives))
(char<=? (scheme base))
(char<? (scheme base))
(char=? (scheme base))
(char>=? (scheme base))
(char>? (scheme base))
(char-ci<=? (scheme char))
(char-ci<? (scheme char))
(char-ci=? (scheme char))
(char-ci>=? (scheme char))
(char-ci>? (scheme char))
(char-ci-hash (srfi 128))
(char-downcase (scheme char))
(char-foldcase (scheme char))
(char-hash (srfi 128))
(char->integer (primitives))
(char-lower-case? (scheme char))
(char-numeric? (scheme char))
(char-upcase (scheme char))
(char-upper-case? (scheme char))
(char-whitespace? (scheme char))
(circular-list? (srfi 1))
(circular-list (srfi 1))
(clear-mutables (scheme cyclone transforms))
(close-input-port (primitives))
(close-output-port (primitives))
(close-port (primitives))
(closure? (scheme cyclone transforms))
(closure-convert (scheme cyclone transforms))
(closure->env (scheme cyclone transforms))
(closure->fv (scheme cyclone transforms))
(closure->lam (scheme cyclone transforms))
(command-line (scheme process-context))
(command-line-arguments (primitives))
(comparator? (srfi 128))
(comparator-check-type (srfi 128))
(comparator-equality-predicate (srfi 128))
(comparator-hashable? (srfi 128))
(comparator-hash (srfi 128))
(comparator-hash-function (srfi 128))
(comparator-if<=> (srfi 128))
(comparator-ordered? (srfi 128))
(comparator-ordering-predicate (srfi 128))
(comparator-register-default! (srfi 128))
(comparator-test-type (srfi 128))
(comparator-type-test-predicate (srfi 128))
(compare-and-set! (cyclone concurrent))
(complex? (scheme base))
(concatenate (srfi 1))
(concatenate! (srfi 1))
(cond (scheme base))
(cond-expand (scheme base))
(condition-variable? (srfi 18))
(condition-variable-broadcast! (srfi 18))
(condition-variable-signal! (srfi 18))
(condition-variable-wait! (srfi 18))
(cons (primitives))
(cons* (srfi 1))
(const? (scheme cyclone util))
(copy-bit (srfi 60))
(copy-bit-field (srfi 60))
(cos (scheme inexact))
(count (srfi 1))
(cps-convert (scheme cyclone transforms))
(create-environment (scheme eval))
(current-error-port (scheme base))
(current-input-port (scheme base))
(current-jiffy (scheme time))
(current-output-port (scheme base))
(current-second (scheme time))
(current-test-applier (cyclone test))
(current-test-comparator (cyclone test))
(current-test-epsilon (cyclone test))
(current-test-group (cyclone test))
(current-test-group-reporter (cyclone test))
(current-test-skipper (cyclone test))
(current-test-verbosity (cyclone test))
(current-thread (srfi 18))
(current-thread-data (srfi 18))
(c-value (cyclone foreign))
(Cyc-er-compare? (scheme cyclone util))
(Cyc-er-rename (scheme cyclone util))
(cyc:error (scheme cyclone transforms))
(Cyc-minor-gc (srfi 18))
(*c-file-header-comment* (scheme cyclone common))
(*Cyc-version-banner* (scheme cyclone common))
(default-hash (srfi 128))
(default-random-source (srfi 27))
(define? (scheme cyclone util))
(define-c? (scheme cyclone util))
(define->exp (scheme cyclone util))
(define->lambda (scheme cyclone transforms))
(define-lambda? (scheme cyclone transforms))
(define-record-type (scheme base))
(define->var (scheme cyclone util))
(delay (scheme lazy))
(delay-force (scheme lazy))
(delete (scheme cyclone util))
(delete (srfi 1))
(delete! (srfi 1))
(delete-duplicates (scheme cyclone util))
(delete-duplicates (srfi 1))
(delete-duplicates! (srfi 1))
(delete-file (primitives))
(deliver (cyclone concurrent))
(denominator (scheme base))
(deref (cyclone concurrent))
(difference (scheme cyclone transforms))
(digit-value (scheme char))
(display (scheme write))
(do (scheme base))
(dotted-list? (srfi 1))
(drop (srfi 1))
(drop-right (srfi 1))
(drop-right! (srfi 1))
(drop-while (srfi 1))
(dynamic-wind (scheme base))
(*defined-macros* (scheme cyclone transforms))
(*do-code-gen* (scheme cyclone transforms))
(eighth (srfi 1))
(emergency-exit (scheme process-context))
(emit (scheme cyclone cgen))
(emit* (scheme cyclone cgen))
(emit-newline (scheme cyclone cgen))
(emits (scheme cyclone cgen))
(emits* (scheme cyclone cgen))
(env:add-binding-to-frame! (scheme cyclone util))
(env:all-values (scheme cyclone util))
(env:all-variables (scheme cyclone util))
(env:define-variable! (scheme cyclone util))
(env:enclosing-environment (scheme cyclone util))
(env:extend-environment (scheme cyclone util))
(env:first-frame (scheme cyclone util))
(env:frame-values (scheme cyclone util))
(env:frame-variables (scheme cyclone util))
(env-get? (scheme cyclone transforms))
(env-get->env (scheme cyclone transforms))
(env-get->field (scheme cyclone transforms))
(env-get->id (scheme cyclone transforms))
(env:lookup (scheme cyclone util))
(env:_lookup-variable-value (scheme cyclone util))
(env:lookup-variable-value (scheme cyclone util))
(env-make? (scheme cyclone transforms))
(env-make->fields (scheme cyclone transforms))
(env:make-frame (scheme cyclone util))
(env-make->id (scheme cyclone transforms))
(env-make->values (scheme cyclone transforms))
(env:set-variable-value! (scheme cyclone util))
(env:the-empty-environment (scheme cyclone util))
(eof-object? (primitives))
(eof-object (scheme base))
(eq? (primitives))
(equal? (primitives))
(eqv? (primitives))
(error (primitives))
(error (scheme base))
(eval (scheme eval))
(even? (scheme base))
(every (scheme base))
(every (srfi 1))
(exact? (scheme base))
(exact (scheme base))
(exact-integer? (scheme base))
(exit (primitives))
(expand (scheme eval))
(exp (scheme inexact))
(expt (scheme base))
(features (scheme base))
(fifth (srfi 1))
(file-exists? (primitives))
(filter (scheme cyclone util))
(filter (srfi 1))
(filter! (srfi 1))
(filter-map (srfi 1))
(filter-unused-variables (scheme cyclone transforms))
(find (srfi 1))
(find-tail (srfi 1))
(finite? (scheme inexact))
(first (srfi 1))
(first-set-bit (srfi 60))
(fixnum? (srfi 143))
(flatten (scheme cyclone util))
(floor (scheme base))
(floor (scheme base))
(floor-quotient (scheme base))
(floor-remainder (scheme base))
(floor-remainder (scheme base))
(flush-output-port (scheme base))
(fold (srfi 1))
(foldl (scheme base))
(foldr (scheme base))
(fold-right (srfi 1))
(force (scheme lazy))
(for-each (scheme base))
(formals->list (scheme cyclone util))
(fourth (srfi 1))
(free-vars (scheme cyclone transforms))
(future? (cyclone concurrent))
(future (cyclone concurrent))
(future-call (cyclone concurrent))
(future-deref (cyclone concurrent))
(future-done? (cyclone concurrent))
(fxabs (srfi 143))
(fxand (srfi 143))
(fx- (srfi 143))
(fx=? (srfi 143))
(fx<? (srfi 143))
(fx>? (srfi 143))
(fx<=? (srfi 143))
(fx>=? (srfi 143))
(fx+ (srfi 143))
(fx* (srfi 143))
(fxarithmetic-shift (srfi 143))
(fxarithmetic-shift-left (srfi 143))
(fxarithmetic-shift-right (srfi 143))
(fxbit-count (srfi 143))
(fxbit-field (srfi 143))
(fxbit-field-reverse (srfi 143))
(fxbit-field-rotate (srfi 143))
(fxbit-set? (srfi 143))
(fxcopy-bit (srfi 143))
(fxeven? (srfi 143))
(fxfirst-set-bit (srfi 143))
(fx-greatest (srfi 143))
(fxif (srfi 143))
(fxior (srfi 143))
(fx-least (srfi 143))
(fxlength (srfi 143))
(fxmax (srfi 143))
(fxmin (srfi 143))
(fxneg (srfi 143))
(fxnegative? (srfi 143))
(fxnot (srfi 143))
(fxodd? (srfi 143))
(fxpositive? (srfi 143))
(fxquotient (srfi 143))
(fxremainder (srfi 143))
(fxsqrt (srfi 143))
(fxsquare (srfi 143))
(fx-width (srfi 143))
(fxxor (srfi 143))
(fxzero? (srfi 143))
(gappend (srfi 121))
(gcd (scheme base))
(gcombine (srfi 121))
(gcons* (srfi 121))
(gdelete (srfi 121))
(gdelete-neighbor-dups (srfi 121))
(gdrop (srfi 121))
(gdrop-while (srfi 121))
(generator-any (srfi 121))
(generator (srfi 121))
(generator-count (srfi 121))
(generator-every (srfi 121))
(generator-find (srfi 121))
(generator-fold (srfi 121))
(generator-for-each (srfi 121))
(generator->list (srfi 121))
(generator->reverse-list (srfi 121))
(generator->string (srfi 121))
(generator-unfold (srfi 121))
(generator->vector! (srfi 121))
(generator->vector (srfi 121))
(gensym (scheme cyclone util))
(get-environment-variable (scheme process-context))
(get-environment-variables (scheme process-context))
(get-macros (scheme cyclone transforms))
(get-output-bytevector (scheme base))
(get-output-string (scheme base))
(gfilter (srfi 121))
(gindex (srfi 121))
(global-vars (scheme cyclone transforms))
(gremove (srfi 121))
(gselect (srfi 121))
(gtake (srfi 121))
(gtake-while (srfi 121))
(guard (scheme base))
(->heap (srfi 18))
(has-global? (scheme cyclone transforms))
(hash (srfi 69))
(hash-bound (srfi 128))
(hash-by-identity (srfi 69))
(hash-salt (srfi 128))
(hash-table->alist (srfi 69))
(hash-table? (srfi 69))
(hash-table-copy (srfi 69))
(hash-table-delete! (srfi 69))
(hash-table-equivalence-function (srfi 69))
(hash-table-exists? (srfi 69))
(hash-table-fold (srfi 69))
(hash-table-hash-function (srfi 69))
(hash-table-keys (srfi 69))
(hash-table-merge! (srfi 69))
(hash-table-ref (srfi 69))
(hash-table-ref default (srfi 69))
(hash-table-set! (srfi 69))
(hash-table-size (srfi 69))
(hash-table-update! (srfi 69))
(hash-table-update! default (srfi 69))
(hash-table-values (srfi 69))
(hash-table-walk (srfi 69))
(identifier=? (scheme cyclone util))
(identifier? (scheme cyclone util))
(identifier->symbol (scheme cyclone util))
(if? (scheme cyclone util))
(if->condition (scheme cyclone util))
(if->else (scheme cyclone util))
(if-else? (scheme cyclone util))
(if->then (scheme cyclone util))
(imag-part (scheme complex))
(immutable? (cyclone concurrent))
(inexact (scheme base))
(inexact? (scheme base))
(infinite? (scheme inexact))
(input-port? (scheme base))
(input-port-open? (scheme base))
(insert (scheme cyclone transforms))
(integer? (primitives))
(integer->char (primitives))
(integer-length (srfi 60))
(integer->list (srfi 60))
(interaction-environment (scheme repl))
(iota (srfi 1))
(ip-protocol (srfi 106))
(is-mutable? (scheme cyclone transforms))
(isolate-globals (scheme cyclone transforms))
(*ipproto-ip* (srfi 106))
(*ipproto-tcp* (srfi 106))
(*ipproto-udp* (srfi 106))
(jiffies-per-second (scheme time))
(lambda? (scheme cyclone util))
(lambda->exp (scheme cyclone util))
(lambda->formals (scheme cyclone util))
(lambda-formals->list (scheme cyclone util))
(lambda-formals-type (scheme cyclone util))
(lambda-num-args (scheme cyclone transforms))
(lambda-varargs? (scheme cyclone util))
(lambda-varargs-var (scheme cyclone util))
(last (srfi 1))
(last-pair (srfi 1))
(lcm (scheme base))
(length (primitives))
(length+ (srfi 1))
(length obj (scheme cyclone util))
(let (scheme base))
(let* (scheme base))
(let? (scheme cyclone transforms))
(let->args (scheme cyclone transforms))
(let->bindings (scheme cyclone transforms))
(let->bound-vars (scheme cyclone transforms))
(let->exp (scheme cyclone transforms))
(let=>lambda (scheme cyclone transforms))
(letrec (scheme base))
(letrec* (scheme base))
(letrec? (scheme cyclone transforms))
(letrec->args (scheme cyclone transforms))
(letrec->bindings (scheme cyclone transforms))
(letrec->bound-vars (scheme cyclone transforms))
(letrec->exp (scheme cyclone transforms))
(let*-values (scheme base))
(let-values (scheme base))
(lib:body (scheme cyclone libraries))
(lib:exports (scheme cyclone libraries))
(lib:get-all (scheme cyclone libraries))
(lib:get-all-import-deps (scheme cyclone libraries))
(lib:get-dep-list (scheme cyclone libraries))
(lib:idb:ids (scheme cyclone libraries))
(lib:import->export-list (scheme cyclone libraries))
(lib:import->filename (scheme cyclone libraries))
(lib:import->metalist (scheme cyclone libraries))
(lib:import->path (scheme cyclone libraries))
(lib:imports (scheme cyclone libraries))
(lib:imports->idb (scheme cyclone libraries))
(lib:include-c-headers (scheme cyclone libraries))
(lib:includes (scheme cyclone libraries))
(lib:list->import-set (scheme cyclone libraries))
(lib:name (scheme cyclone libraries))
(lib:name->string (scheme cyclone libraries))
(lib:name->symbol (scheme cyclone libraries))
(lib:name->unique-string (scheme cyclone libraries))
(library? (scheme cyclone libraries))
(library-exists? (scheme cyclone libraries))
(lib:read-imports (scheme cyclone libraries))
(lib:rename-exports (scheme cyclone libraries))
(lib:resolve-meta (scheme cyclone libraries))
(lib:result (scheme cyclone libraries))
(list (scheme base))
(list? (scheme base))
(list= (srfi 1))
(list->bag (srfi 113))
(list->bag! (srfi 113))
(list-copy (scheme base))
(list-copy (srfi 1))
(list-delete-neighbor-dups (srfi 132))
(list-delete-neighbor-dups! (srfi 132))
(list->generator (srfi 121))
(list-index2 (scheme cyclone util))
(list-index (scheme cyclone transforms))
(list-index (srfi 1))
(list-insert-at! (scheme cyclone util))
(list->integer (srfi 60))
(list->lambda-formals (scheme cyclone transforms))
(list-merge (srfi 132))
(list-merge! (srfi 132))
(list->pair (scheme cyclone transforms))
(list-prefix? (scheme cyclone util))
(list-queue-add-back! (srfi 117))
(list-queue-add-front! (srfi 117))
(list-queue (srfi 117))
(list-queue? (srfi 117))
(list-queue-append (srfi 117))
(list-queue-append! (srfi 117))
(list-queue-back (srfi 117))
(list-queue-concatenate (srfi 117))
(list-queue-copy (srfi 117))
(list-queue-empty? (srfi 117))
(list-queue-first-last (srfi 117))
(list-queue-for-each (srfi 117))
(list-queue-front (srfi 117))
(list-queue-list (srfi 117))
(list-queue-map (srfi 117))
(list-queue-map! (srfi 117))
(list-queue-remove-all! (srfi 117))
(list-queue-remove-back! (srfi 117))
(list-queue-remove-front! (srfi 117))
(list-queue-set-list! (srfi 117))
(list-queue-unfold (srfi 117))
(list-queue-unfold-right (srfi 117))
(list-ref (scheme base))
(list-set! (scheme base))
(list->set (srfi 113))
(list->set! (srfi 113))
(list-sort (srfi 132))
(list-sort! (srfi 132))
(list-sorted? (srfi 132))
(list-stable-sort! (srfi 132))
(list-stable-sort (srfi 132))
(list->string (primitives))
(list-tabulate (srfi 1))
(list-tail (scheme base))
(list->vector (primitives))
(load (scheme load))
(log2-binary-factors (srfi 60))
(logand (srfi 60))
(log (scheme inexact))
(logbit? (srfi 60))
(logcount (srfi 60))
(logior (srfi 60))
(lognot (srfi 60))
(logtest (srfi 60))
(logxor (srfi 60))
(lset-adjoin (srfi 1))
(lset<= (srfi 1))
(lset= (srfi 1))
(lset-difference (srfi 1))
(lset-difference! (srfi 1))
(lset-diff+intersection (srfi 1))
(lset-diff+intersection! (srfi 1))
(lset-intersection (srfi 1))
(lset-intersection! (srfi 1))
(lset-union! (srfi 1))
(lset-union (srfi 1))
(lset-xor (srfi 1))
(lset-xor! (srfi 1))
(magnitude (scheme complex))
(make-atom (cyclone concurrent))
(make-bytevector (primitives))
(make-client-socket (srfi 106))
(make-comparator (srfi 128))
(make-condition-variable (srfi 18))
(make-constructor (scheme base))
(make-coroutine-generator (srfi 121))
(make-default-comparator (srfi 128))
(make-eq-comparator (srfi 128))
(make-equal-comparator (srfi 128))
(make-eqv-comparator (srfi 128))
(make-for-each-generator (srfi 121))
(make-getter (scheme base))
(make-hash-table (srfi 69))
(make-iota-generator (srfi 121))
(make-list (scheme base))
(make-list (srfi 1))
(make-list-comparator (srfi 128))
(make-list-queue (srfi 117))
(make-mutex (srfi 18))
(make-opaque (cyclone foreign))
(make-pair-comparator (srfi 128))
(make-parameter (scheme base))
(make-polar (scheme complex))
(make-promise (scheme lazy))
(make-random-source (srfi 27))
(make-range-generator (srfi 121))
(make-rectangular (scheme complex))
(make-server-socket (srfi 106))
(make-setter (scheme base))
(make-shared-delay (cyclone concurrent))
(make-shared-promise (cyclone concurrent))
(make-shared-queue (cyclone concurrent))
(make-string (scheme base))
(make-thread (srfi 18))
(make-thread-pool (cyclone concurrent))
(make-type-predicate (scheme base))
(make-unfold-generator (srfi 121))
(make-vector (primitives))
(make-vector-comparator (srfi 128))
(mangle (scheme cyclone util))
(mangle-global (scheme cyclone util))
(map (scheme base))
(map! (srfi 1))
(map-in-order (srfi 1))
(mark-mutable (scheme cyclone transforms))
(match (cyclone match))
(match-lambda (cyclone match))
(match-lambda* (cyclone match))
(match-let (cyclone match))
(match-let* (cyclone match))
(match-letrec (cyclone match))
(max (scheme base))
(member (scheme base))
(memq (scheme base))
(memv (scheme base))
(message-type (srfi 106))
(min (scheme base))
(modulo (scheme base))
(mta:code-gen (scheme cyclone cgen))
(mutex? (srfi 18))
(mutex-lock! (srfi 18))
(mutex-unlock! (srfi 18))
(*msg-oob* (srfi 106))
(*msg-peek* (srfi 106))
(*msg-waitall* (srfi 106))
(nan? (scheme inexact))
(negative? (scheme base))
(newline (scheme base))
(ninth (srfi 1))
(not (scheme base))
(not-pair? (srfi 1))
(null? (primitives))
(null-list? (srfi 1))
(number? (primitives))
(number-hash (srfi 128))
(number->string (primitives))
(numerator (scheme base))
(odd? (scheme base))
(one-instance-of-new-mutable-obj? (scheme cyclone cps-optimizations))
(opaque? (cyclone foreign))
(opaque-null? (cyclone foreign))
(open-input-bytevector (scheme base))
(open-input-file (primitives))
(open-input-string (scheme base))
(open-output-bytevector (scheme base))
(open-output-file (primitives))
(open-output-string (scheme base))
(opt:contract (scheme cyclone cps-optimizations))
(optimize-cps (scheme cyclone cps-optimizations))
(opt:inline-prims (scheme cyclone cps-optimizations))
(or (scheme base))
(output-port? (scheme base))
(output-port-open? (scheme base))
(pack-lambda-arguments (scheme cyclone util))
(pair? (primitives))
(pair-fold (srfi 1))
(pair-fold-right (srfi 1))
(pair-for-each (srfi 1))
(pair->list (scheme cyclone util))
(parameterize (scheme base))
(partition (srfi 1))
(partition! (srfi 1))
(peek-char (primitives))
(port? (primitives))
(pos-in-list (scheme cyclone transforms))
(positive? (scheme base))
(precompute-prim-app? (scheme cyclone transforms))
(pretty-print (scheme cyclone pretty-print))
(prim:allocates-object? (scheme cyclone primitives))
(prim? (scheme cyclone primitives))
(prim:arg-count? (scheme cyclone primitives))
(prim-call? (scheme cyclone primitives))
(prim->c-func (scheme cyclone primitives))
(prim:check-arg-count (scheme cyclone primitives))
(prim:cont? (scheme cyclone primitives))
(prim:cont no-args? (scheme cyclone primitives))
(prim cvar? (scheme cyclone primitives))
(prim c-var-assign (scheme cyclone primitives))
(prim data-arg? (scheme cyclone primitives))
(prim:mutates? (scheme cyclone primitives))
(procedure? (primitives))
(promise? (scheme lazy))
(proper-list? (srfi 1))
(*primitives* (scheme cyclone transforms))
(quasiquote (scheme base))
(quote? (scheme cyclone util))
(quotient (scheme base))
(raise (scheme base))
(raise-continuable (scheme base))
(random-integer (srfi 27))
(random-real (srfi 27))
(random-source? (srfi 27))
(random-source-make-integers (srfi 27))
(random-source-make-reals (srfi 27))
(random-source-pseudo-randomize! (srfi 27))
(random-source-randomize! (srfi 27))
(random-source-state-ref (srfi 27))
(random-source-state-set! (srfi 27))
(rational? (scheme base))
(read-all (scheme read))
(read (scheme read))
(read-char (primitives))
(read-line (scheme base))
(read-string (scheme base))
(real? (primitives))
(realized? (cyclone concurrent))
(real-part (scheme complex))
(receive (scheme base))
(record? (scheme base))
(reduce (scheme cyclone transforms))
(reduce (srfi 1))
(reduce-right (srfi 1))
(ref? (scheme cyclone util))
(remainder (scheme base))
(remove (scheme cyclone transforms))
(remove (srfi 1))
(remove! (srfi 1))
(repl (scheme repl))
(reverse (scheme base))
(reverse! (srfi 1))
(reverse-list->vector (srfi 133))
(reverse-vector->generator (srfi 121))
(reverse-vector->list (srfi 133))
(rotate-bit-field (srfi 60))
(round (scheme base))
(*shut-rd* (srfi 106))
(*shut-rdwr* (srfi 106))
(*shut-wr* (srfi 106))
(*sock-dgram* (srfi 106))
(*sock-stream* (srfi 106))
(second (srfi 1))
(set-adjoin (srfi 113))
(set-adjoin! (srfi 113))
(set-any? (srfi 113))
(set!? (scheme cyclone util))
(set (srfi 113))
(set? (srfi 113))
(set=? (srfi 113))
(set<? (srfi 113))
(set>? (srfi 113))
(set<=? (srfi 113))
(set>=? (srfi 113))
(set->bag (srfi 113))
(set->bag! (srfi 113))
(set-box! (srfi 111))
(set-car! (primitives))
(set-cdr! (primitives))
(set-cell!? (scheme cyclone transforms))
(set-cell!->cell (scheme cyclone transforms))
(set-cell!->value (scheme cyclone transforms))
(set-comparator (srfi 113))
(set-contains? (srfi 113))
(set-copy (srfi 113))
(set-count (srfi 113))
(set-delete-all (srfi 113))
(set-delete-all! (srfi 113))
(set-delete (srfi 113))
(set-delete! (srfi 113))
(set-difference (srfi 113))
(set-difference! (srfi 113))
(set-disjoint? (srfi 113))
(set-element-comparator (srfi 113))
(set-empty? (srfi 113))
(set-every? (srfi 113))
(set!->exp (scheme cyclone util))
(set-filter (srfi 113))
(set-filter! (srfi 113))
(set-find (srfi 113))
(set-fold (srfi 113))
(set-for-each (srfi 113))
(set-intersection (srfi 113))
(set-intersection! (srfi 113))
(set->list (srfi 113))
(set-map (srfi 113))
(set-member (srfi 113))
(set-partition (srfi 113))
(set-partition! (srfi 113))
(set-remove (srfi 113))
(set-remove! (srfi 113))
(set-replace (srfi 113))
(set-replace! (srfi 113))
(set-search! (srfi 113))
(set-size (srfi 113))
(set-unfold (srfi 113))
(set-union (srfi 113))
(set-union! (srfi 113))
(setup-environment (scheme eval))
(set!->var (scheme cyclone util))
(set-xor (srfi 113))
(set-xor! (srfi 113))
(seventh (srfi 1))
(shared-delay? (cyclone concurrent))
(shared-delay (cyclone concurrent))
(shared-promise? (cyclone concurrent))
(shared-queue-add! (cyclone concurrent))
(shared-queue? (cyclone concurrent))
(shared-queue (cyclone concurrent))
(shared-queue-capacity (cyclone concurrent))
(shared-queue-clear! (cyclone concurrent))
(shared-queue-empty? (cyclone concurrent))
(shared-queue-remove! (cyclone concurrent))
(shared-queue-size (cyclone concurrent))
(shared-queue-wait-count (cyclone concurrent))
(shutdown-method (srfi 106))
(simple-lambda? (scheme cyclone cps-optimizations))
(sin (scheme inexact))
(sixth (srfi 1))
(slot-set! (scheme base))
(socket-accept (srfi 106))
(socket? (srfi 106))
(socket-close (srfi 106))
(socket-domain (srfi 106))
(socket-input-port (srfi 106))
(socket-merge-flags (srfi 106))
(socket-output-port (srfi 106))
(socket-purge-flags (srfi 106))
(socket-recv (srfi 106))
(socket-send (srfi 106))
(socket-shutdown (srfi 106))
(span (srfi 1))
(span! (srfi 1))
(split-at (srfi 1))
(split-at! (srfi 1))
(sqrt (scheme inexact))
(square (scheme base))
(string? (primitives))
(string (scheme base))
(string<=? (scheme base))
(string<? (scheme base))
(string=? (scheme base))
(string>=? (scheme base))
(string>? (scheme base))
(string-append (primitives))
(string-ci<=? (scheme char))
(string-ci<? (scheme char))
(string-ci=? (scheme char))
(string-ci>=? (scheme char))
(string-ci>? (scheme char))
(string-ci-hash (srfi 128))
(string-ci-hash (srfi 69))
(string-cmp (primitives))
(string-copy (scheme base))
(string-copy! (scheme base))
(string-downcase (scheme char))
(string-fill! (scheme base))
(string-foldcase (scheme char))
(string-for-each (scheme base))
(string->generator (srfi 121))
(string-hash (srfi 128))
(string-hash (srfi 69))
(string-join (scheme cyclone util))
(string-length (primitives))
(string->list (scheme base))
(string-map (scheme base))
(string->number (primitives))
(string-ref (primitives))
(string-replace-all (scheme cyclone util))
(string-set! (primitives))
(string-split (scheme cyclone util))
(string->symbol (primitives))
(string-upcase (scheme char))
(string->utf8 (scheme base))
(string->vector (scheme base))
(substring (primitives))
(swap! (cyclone concurrent))
(symbol? (primitives))
(symbol=? (scheme base))
(symbol<? (scheme cyclone transforms))
(symbol-hash (srfi 128))
(symbol->string (primitives))
(syntax-error (scheme base))
(system (primitives))
(*trace-level* (scheme cyclone transforms))
(tagged-list? (scheme cyclone util))
(take (scheme cyclone util))
(take (srfi 1))
(take! (srfi 1))
(take-right (srfi 1))
(take-while (srfi 1))
(take-while! (srfi 1))
(tan (scheme inexact))
(tenth (srfi 1))
(test (cyclone test))
(test-assert (cyclone test))
(test-begin (cyclone test))
(test-end (cyclone test))
(test-equal (cyclone test))
(test-error (cyclone test))
(test-exit (cyclone test))
(test-failure-count (cyclone test))
(test-group (cyclone test))
(test-not (cyclone test))
(test-propagate-info (cyclone test))
(test-run (cyclone test))
(test-values (cyclone test))
(third (srfi 1))
(thread? (srfi 18))
(thread-join! (srfi 18))
(thread-name (srfi 18))
(thread-pool? (cyclone concurrent))
(thread-pool-idling? (cyclone concurrent))
(thread-pool-idling-count (cyclone concurrent))
(thread-pool-push-task! (cyclone concurrent))
(thread-pool-release! (cyclone concurrent))
(thread-pool-size (cyclone concurrent))
(thread-sleep! (srfi 18))
(thread-specific (srfi 18))
(thread-specific-set! (srfi 18))
(thread-start! (srfi 18))
(thread-terminate! (srfi 18))
(thread-yield! (srfi 18))
(trace (scheme cyclone transforms))
(trace:debug (scheme cyclone transforms))
(trace:error (scheme cyclone transforms))
(trace:info (scheme cyclone transforms))
(trace:warn (scheme cyclone transforms))
(truncate (scheme base))
(truncate (scheme base))
(truncate-quotient (scheme base))
(truncate-remainder (scheme base))
(type-slot-offset (scheme base))
(unbox (srfi 111))
(unfold (srfi 1))
(unfold-right (srfi 1))
(union (scheme cyclone transforms))
(unless (scheme base))
(unzip1 (srfi 1))
(unzip2 (srfi 1))
(unzip3 (srfi 1))
(unzip4 (srfi 1))
(unzip5 (srfi 1))
(utf8->string (scheme base))
(*version* (scheme cyclone common))
(*version-banner* (scheme cyclone common))
(*version-name* (scheme cyclone common))
(*version-number* (scheme cyclone common))
(values (scheme base))
(vector-any (srfi 133))
(vector? (primitives))
(vector (scheme base))
(vector= (srfi 133))
(vector-append (scheme base))
(vector-append-subvectors (srfi 133))
(vector-binary-search (srfi 133))
(vector-concatenate (srfi 133))
(vector-copy (scheme base))
(vector-copy! (scheme base))
(vector-count (srfi 133))
(vector-cumulate (srfi 133))
(vector-delete-neighbor-dups (srfi 132))
(vector-delete-neighbor-dups! (srfi 132))
(vector-empty? (srfi 133))
(vector-every (srfi 133))
(vector-fill! (scheme base))
(vector-find-median (srfi 132))
(vector-find-median! (srfi 132))
(vector-fold (srfi 133))
(vector-fold-right (srfi 133))
(vector-for-each (scheme base))
(vector->generator (srfi 121))
(vector-index (srfi 133))
(vector-index-right (srfi 133))
(vector-length (primitives))
(vector->list (scheme base))
(vector-map (scheme base))
(vector-map! (srfi 133))
(vector-merge (srfi 132))
(vector-merge! (srfi 132))
(vector-partition (srfi 133))
(vector-ref (primitives))
(vector-reverse! (srfi 133))
(vector-reverse-copy! (srfi 133))
(vector-reverse-copy (srfi 133))
(vector-select! (srfi 132))
(vector-separate! (srfi 132))
(vector-set! (primitives))
(vector-skip (srfi 133))
(vector-skip-right (srfi 133))
(vector-sort (srfi 132))
(vector-sort! (srfi 132))
(vector-sorted? (srfi 132))
(vector-stable-sort! (srfi 132))
(vector-stable-sort (srfi 132))
(vector->string (scheme base))
(vector-swap! (srfi 133))
(vector-unfold! (srfi 133))
(vector-unfold (srfi 133))
(vector-unfold-right! (srfi 133))
(vector-unfold-right (srfi 133))
(when (scheme base))
(with-exception-handler (scheme base))
(with-handler (scheme base))
(with-input-from-file (scheme file))
(with-output-to-file (scheme file))
(wrap-mutables (scheme cyclone transforms))
(write (scheme write))
(write-char (scheme base))
(write-shared (scheme write))
(write-simple (scheme write))
(write-string (scheme base))
(xcons (srfi 1))
(zero? (scheme base))
(zip (srfi 1)))