scheme-complete.el

Scheme跨平台编译器

    (test-expect-fail (syntax (specifier)))
    (test-runner? (lambda (obj)))
    (test-runner-current (lambda (:optional runner)))
    (test-runner-get (lambda ()))
    (test-runner-simple (lambda ()))
    (test-runner-null (lambda ()))
    (test-runner-create (lambda ()))
    (test-runner-factory (lambda (:optional factory)))
    (test-apply (syntax (runner specifier \.\.\.)))
    (test-with-runner (syntax (runner decl-or-expr \.\.\.)))
    (test-result-kind (lambda (:optional runner)))
    (test-passed? (lambda (:optional runner)))
    (test-result-ref (lambda (runner prop-name (:optional default))))
    (test-result-set! (lambda (runner prop-name value)))
    (test-result-remove (lambda (runner prop-name)))
    (test-result-clear (lambda (runner)))
    (test-result-alist (lambda (runner)))
    (test-runner-on-test-begin (lambda (runner :optional proc)))
    (test-runner-on-test-begin! (lambda (runner :optional proc)))
    (test-runner-on-test-end (lambda (runner :optional proc)))
    (test-runner-on-test-end! (lambda (runner :optional proc)))
    (test-runner-on-group-begin (lambda (runner :optional proc)))
    (test-runner-on-group-begin! (lambda (runner :optional proc)))
    (test-runner-on-group-end (lambda (runner :optional proc)))
    (test-runner-on-group-end! (lambda (runner :optional proc)))
    (test-runner-on-bad-count (lambda (runner :optional proc)))
    (test-runner-on-bad-count! (lambda (runner :optional proc)))
    (test-runner-on-bad-end-name (lambda (runner :optional proc)))
    (test-runner-on-bad-end-name! (lambda (runner :optional proc)))
    (test-runner-on-final (lambda (runner :optional proc)))
    (test-runner-on-final! (lambda (runner :optional proc)))
    (test-runner-pass-count (lambda (runner)))
    (test-runner-fail-count (lambda (runner)))
    (test-runner-xpass-count (lambda (runner)))
    (test-runner-skip-count (lambda (runner)))
    (test-runner-test-name (lambda (runner)))
    (test-runner-group-path (lambda (runner)))
    (test-runner-group-stack (lambda (runner)))
    (test-runner-aux-value (lambda (runner)))
    (test-runner-aux-value! (lambda (runner)))
    (test-runner-reset (lambda (runner)))
    )

   ()

   ;; SRFI 66
   ("Octet Vectors"
    (make-u8vector (lambda (len n)))
    (u8vector (lambda (n \.\.\.)))
    (u8vector->list (lambda (u8vector)))
    (list->u8vector (lambda (octet-list)))
    (u8vector-length u8vector)
    (u8vector-ref (lambda (u8vector k)))
    (u8vector-set! (lambda (u8vector k n)))
    (u8vector=? (lambda (u8vector-1 u8vector-2)))
    (u8vector-compare (lambda (u8vector-1 u8vector-2)))
    (u8vector-copy! (lambda (source source-start target target-start n)))
    (u8vector-copy (lambda (u8vector)))
    )

   ;; SRFI 67
   ("Compare Procedures"
    )

   ()

   ;; SRFI 69
   ("Basic hash tables"
    )

   ;; SRFI 70
   ("Numbers"
    )

   ;; SRFI 71
   ("LET-syntax for multiple values"
    )

   ;; SRFI 72
   ("Simple hygienic macros"
    )

   ()

   ;; SRFI 74
   ("Octet-Addressed Binary Blocks"
    )

   ])

(defvar *scheme-chicken-modules*
  '((extras
     (->string (lambda (obj) str))
     (alist->hash-table (lambda (alist) hash-table))
     (alist-ref (lambda (alist key :optional eq-fn default)))
     (alist-update! (lambda (key value alist :optional eq-fn) undefined))
     (atom? (lambda (obj) bool))
     (binary-search (lambda (vec proc)))
     (butlast (lambda (list) list) "drops the last element of list")
     (call-with-input-string (lambda (string proc)))
     (call-with-output-string (lambda (proc) str))
     (chop (lambda (list k) list))
     (complement (lambda (f) f2))
     (compose (lambda (f1 f2 \.\.\.) f))
     (compress (lambda (boolean-list list)))
     (conc (lambda (obj \.\.\.)))
     (conjoin (lambda (pred \.\.\.) pred))
     (constantly (lambda (obj \.\.\.) f))
     (disjoin (lambda (pred \.\.\.) pred))
     (each (lambda (proc \.\.\.) proc))
     (flatten (lambda (list1 \.\.\.) list))
     (flip (lambda (proc) proc))
     (format (lambda (format-string arg \.\.\.)))
     (fprintf (lambda (port format-string arg \.\.\.)))
     (hash (lambda (obj :optional n) int))
     (hash-by-identity (lambda (obj :optional n) int))
     (hash-table->alist (lambda (hash-table) alist))
     (hash-table-copy (lambda (hash-table) hash-table))
     (hash-table-delete! (lambda (hash-table key) undefined))
     (hash-table-equivalence-function (lambda (hash-table) pred))
     (hash-table-exists? (lambda (hash-table key) bool))
     (hash-table-fold (lambda (hash-table f init-value)))
     (hash-table-hash-function (lambda (hash-table) f))
     (hash-table-keys (lambda (hash-table) list))
     (hash-table-merge! (lambda (hash-table1 hash-table2) undefined))
     (hash-table-ref (lambda (hash-table key :optional thunk)))
     (hash-table-ref/default (lambda (hash-table key default)))
     (hash-table-remove! (lambda (hash-table proc) undefined))
     (hash-table-set! (lambda (hash-table key value) undefined))
     (hash-table-size (lambda (hash-table) n))
     (hash-table-update! (lambda (hash-table key proc :optional thunk) undefined))
     (hash-table-update!/default (lambda (hash-table key proc default) undefined))
     (hash-table-values (lambda (hash-table) list))
     (hash-table-walk (lambda (hash-table proc) undefined))
     (hash-table? (lambda (obj) bool))
     (identity (lambda (obj)))
     (intersperse (lambda (list obj) list))
     (join (lambda (list-of-lists :optional list) list))
     (list->queue (lambda (list) queue))
     (list-of (lambda (pred)))
     (make-hash-table (lambda (:optional eq-fn hash-fn size) hash-table))
     (make-input-port (lambda (read-proc ready?-pred close-proc :optional peek-proc) input-port))
     (make-output-port (lambda (write-proc close-proc :optional flush-proc) output-port))
     (make-queue (lambda () queue))
     (merge (lambda (list1 list2 less-fn) list))
     (merge! (lambda (list1 list2 less-fn) list))
     (noop (lambda (obj \.\.\.) undefined))
     (pp (lambda (obj :optional output-port) undefined))
     (pretty-print (lambda (obj :optional output-port) undefined))
     (pretty-print-width (lambda (:optional new-width) n))
     (printf (lambda (format-string arg \.\.\.) undefined))
     (project (lambda (n) proc))
     (queue->list (lambda (queue) list))
     (queue-add! (lambda (queue obj) undefined))
     (queue-empty? (lambda (queue) bool))
     (queue-first (lambda (queue)))
     (queue-last (lambda (queue)))
     (queue-push-back! (lambda (queue obj) undefined))
     (queue-push-back-list! (lambda (queue list) undefined))
     (queue-remove! (lambda (queue) undefined))
     (queue? (lambda (obj) bool))
     (random (lambda (n) n))
     (randomize (lambda (:optional x1) undefined))
     (rassoc (lambda (key list :optional eq-fn)))
     (read-file (lambda (:optional file-or-port reader-fn max-count) str))
     (read-line (lambda (:optional port limit) str))
     (read-lines (lambda (:optional port max) list))
     (read-string (lambda (:optional n port) str))
     (read-string! (lambda (n dest :optional port start) undefined))
     (read-token (lambda (predicate :optional port) str))
     (shuffle (lambda (list) list))
     (sort (lambda (sequence less-fn) sequence))
     (sort! (lambda (sequence less-fn) sequence))
     (sorted? (lambda (sequence less-fn) bool))
     (sprintf (lambda (format-string arg \.\.\.) str))
     (string-chomp (lambda (str :optional suffix-str) str))
     (string-chop (lambda (str length) list))
     (string-ci-hash (lambda (str :optional n) n))
     (string-compare3 (lambda (str1 str2) n))
     (string-compare3-ci (lambda (str1 str2) n))
     (string-hash (lambda (str1 :optional n) n))
     (string-intersperse (lambda (list :optional seperator-string) str))
     (string-split (lambda (str :optional delimiter-str keep-empty?) list))
     (string-translate (lambda (str from-str :optional to-str) str))
     (string-translate* (lambda (str list) str))
     (substring-ci=? (lambda (str1 str2 :optional start1 start2 length) str))
     (substring-index (lambda (which-str where-str :optional start) i))
     (substring-index-ci (lambda (which-str where-str :optional start) i))
     (substring=? (lambda (str1 str2 :optional start1 start2 length) bool))
     (tail? (lambda (obj list) bool))
     (with-error-output-to-port (lambda (output-port thunk)))
     (with-input-from-port (lambda (port thunk)))
     (with-input-from-string (lambda (str thunk)))
     (with-output-to-port (lambda (port thunk)))
     (with-output-to-string (lambda (thunk) str))
     (write-line (lambda (str :optional port) undefined))
     (write-string (lambda (str :optional num port) undefined))
     )
    (lolevel
     (address->pointer (lambda (n) ptr))
     (align-to-word (lambda (ptr-or-int) ptr))
     (allocate (lambda (size) block))
     (block-ref (lambda (block index) int))
     (block-set! (lambda (block index obj) undefined))
     (byte-vector (lambda (n \.\.\.) byte-vector))
     (byte-vector->list (lambda (byte-vector) list))
     (byte-vector->string (lambda (byte-vector) string))
     (byte-vector-fill! (lambda (byte-vector n) undefined))
     (byte-vector-length (lambda (byte-vector) n))
     (byte-vector-ref (lambda (byte-vector i) int))
     (byte-vector-set! (lambda (byte-vector i n) undefined))
     (byte-vector? (lambda (obj) bool))
     (extend-procedure (lambda (proc x1) proc))
     (extended-procedure? (lambda (proc) bool))
     (free (lambda (pointer) undefined))
     (global-bound? (lambda (sym) bool))
     (global-make-unbound! (lambda (sym) undefined))
     (global-ref (lambda (sym)))
     (global-set! (lambda (sym val) undefined))
     (list->byte-vector (lambda (list) byte-vector))
     (locative->object (lambda (locative) obj))
     (locative-ref (lambda (locative)))
     (locative-set! (lambda (locative val) undefined))
     (locative? (lambda (obj) bool))
     (make-byte-vector (lambda (size :optional init-n) byte-vector))
     (make-locative (lambda (obj :optional index) locative))
     (make-record-instance (lambda (sym arg \.\.\.)))
     (make-static-byte-vector (lambda (size :optional init-n)))
     (make-weak-locative (lambda (obj :optional index) locative))
     (move-memory! (lambda (from to :optional bytes from-offset to-offset) undefined))
     (mutate-procedure (lambda (proc proc) proc))
     (null-pointer (lambda () pointer))
     (null-pointer? (lambda (pointer) bool))
     (number-of-bytes (lambda (block) int))
     (number-of-slots (lambda (block) int))
     (object->pointer (lambda (obj) ptr))
     (object-become! (lambda (alist) undefined))
     (object-copy (lambda (obj)))
     (object-evict (lambda (obj :optional allocator-proc)))
     (object-evict-to-location (lambda (obj ptr :optional limit)))
     (object-evicted? (lambda (obj) bool))
     (object-release (lambda (obj :optional releaser-proc)))
     (object-size (lambda (obj) int))
     (object-unevict (lambda (obj :optional full)))
     (pointer->address (lambda (ptr) n))
     (pointer->object (lambda (ptr)))
     (pointer-f32-ref (lambda (ptr) real))
     (pointer-f32-set! (lambda (ptr x1) undefined))
     (pointer-f64-ref (lambda (ptr) real))
     (pointer-f64-set! (lambda (ptr x1) undefined))
     (pointer-offset (lambda (ptr n) n))
     (pointer-s16-ref (lambda (ptr) int))
     (pointer-s16-set! (lambda (ptr n) undefined))
     (pointer-s32-ref (lambda (ptr) int))
     (pointer-s32-set! (lambda (ptr n) undefined))
     (pointer-s8-ref (lambda (ptr) int))
     (pointer-s8-set! (lambda (ptr n) undefined))
     (pointer-tag (lambda (ptr) tag))
     (pointer-u16-ref (lambda (ptr) int))
     (pointer-u16-set! (lambda (ptr n) undefined))
     (pointer-u32-ref (lambda (ptr) int))
     (pointer-u32-set! (lambda (ptr n) undefined))
     (pointer-u8-ref (lambda (ptr) int))
     (pointer-u8-set! (lambda (ptr n) undefined))
     (pointer=? (lambda (ptr1 ptr2) bool))
     (pointer? (lambda (obj) bool))
     (procedure-data (lambda (proc)))
     (record->vector (lambda (block) vector))
     (record-instance? (lambda (obj) bool))
     (set-invalid-procedure-call-handler! (lambda (proc) undefined))
     (set-procedure-data! (lambda (proc obj) undefined))
     (static-byte-vector->pointer (lambda (byte-vector) pointer))
     (string->byte-vector (lambda (str) byte-vector))
     (tag-pointer (lambda (ptr tag)))
     (tagged-pointer? (lambda (obj tag) bool))
     (unbound-variable-value (lambda (:optional value)))
     )
    (posix
     (_exit (lambda (:optional n) undefined))
     (call-with-input-pipe (lambda (cmdline-string proc :optional mode)))
     (call-with-output-pipe (lambda (cmdline-string proc :optional mode)))
     (change-directory (lambda (dir)))
     (change-file-mode (lambda (filename mode)))
     (change-file-owner (lambda (filename user-n group-n)))
     (close-input-pipe (lambda (input-port)))
     (close-output-pipe (lambda (output-port)))
     (create-directory (lambda (filename)))
     (create-fifo (lambda (filename :optional mode)))
     (create-pipe (lambda ()))
     (create-session (lambda ()))
     (create-symbolic-link (lambda (old-filename new-filename)))
     (current-directory (lambda (:optional new-dir)))
     (current-effective-group-id (lambda () int))
     (current-effective-user-id (lambda () int))
     (current-environment (lambda ()))
     (current-group-id (lambda ()))
     (current-process-id (lambda ()))
     (current-user-id (lambda ()))
     (delete-directory (lambda (dir)))
     (directory (lambda (:optional dir show-dotfiles?) list))
     (directory? (lambda (filename) bool))
     (duplicate-fileno (lambda (old-