
                            SECDR-SchemeˤĤ

                                                      ʿ5ǯ620

          Copyright (C) 1990, 1991, 1992, 1993  Shoichi Hayashi ( Ͱ)

ǤR4RS[2]ФƳĥƤΤޤޤνϤϡ
#v (void) äƤޤäǤʤ¤ꡢʲ˼procedure#v
֤ޤ

------------------------------------------------------------------------------

()                                                                special form
        ()  () 
nil                                                                   variable
        nil  () 
t                                                                     variable
        t  #t 

[ɤȥѥ]
(load <filename>)                                                    procedure
(load <filename> <noisily-flg>)                                      procedure
(load <filename> <noisily-flg> <error-flg>)                          procedure
        <filename>SchemeץΥե̾stringǤ٤
        롣
        <noisily-flg>, <error-flg>ϻꤵʤ#fꤵ줿
        Ʊͤ˿񤦡
        <noisily-flg>#f()ǤСɾ̤ϲɽʤ
        #f()ǤʤʤСɤ줿η̤ɸϤɽ롣
        <error-flg>#f()ǤСɤ֤ͤ#vǤ롣
        ⤷ꤵ줿ե뤬Ĥʤϥ顼Ȥʤ롣
        #f()ǤʤʤС˥ɤԤ줿ˤ#t֤⤷
        ꤵ줿ե뤬Ĥʤˤ#f֤顼ȤϤʤʤ

(bin-load <filename>)                                                procedure
(bin-load <filename> <noisily-flg>)                                  procedure
(bin-load <filename> <noisily-flg> <error-flg>)                      procedure
        <filename>SchemeץΥѥ뤵줿ե̾string
        ٤Ǥ롣
        <noisily-flg>, <error-flg>ϻꤵʤ#fꤵ줿
        Ʊͤ˿񤦡
        <noisily-flg>#f()ǤСɾ̤ϲɽʤ
        #f()ǤʤʤСɤ줿η̤ɸϤɽ롣
        <error-flg>#f()ǤСɤ֤ͤ#vǤ롣
        ⤷ꤵ줿ե뤬Ĥʤϥ顼Ȥʤ롣
        #f()ǤʤʤС˥ɤԤ줿ˤ#t֤⤷
        ꤵ줿ե뤬Ĥʤˤ#f֤顼ȤϤʤʤ

(ex-load <filename>)                                                 procedure
(ex-load <filename> <noisily-flg>)                                   procedure
(ex-load <filename> <noisily-flg> <error-flg>)                       procedure
        <filename>SchemeץΥޤϥѥ뤵줿ե̾
        stringǤ٤Ǥ롣
        <noisily-flg>, <error-flg>ϻꤵʤ#fꤵ줿
        Ʊͤ˿񤦡
        <noisily-flg>#f()ǤСɾ̤ϲɽʤ
        #f()ǤʤʤСɤ줿η̤ɸϤɽ롣
        <error-flg>#f()ǤСɤ֤ͤ#vǤ롣
        ⤷ꤵ줿ե뤬Ĥʤϥ顼Ȥʤ롣
        #f()ǤʤʤС˥ɤԤ줿ˤ#t֤⤷
        ꤵ줿ե뤬Ĥʤˤ#f֤顼ȤϤʤʤ
        <filename>stringκǸ夬 ".scm" ǤХǤȲᤷ".bin"
        ǤХѥ뤵줿ΤǤȲ᤹롣ʳξϥ
        ΤȽǤɤԤ⤷⤽Υե뤬Ĥʤä
        ˤϡĥҤά줿ΤȽǤ<filename>stringκǸ 
        ".bin" 뤤 ".scm"äեɤ롣
        ξ¸ߤϡ ".bin" ͥ褷򤵤롣
        ä ".bin" ĥҤʤѥѤߤΥեɤ
        ϡɬbin-loadѤʤФʤʤ

-*-compile-*-                                                         variable
        ȥåץ٥READ-EVAL-PRINT(ºݤˤREAD-COMPILE-EXEC-PRINT)롼פ
        ɤǻȤɸΥѥ³ꤹ롣֤Ǥϰʲcompile
        ꤵƤ롣

(compile <expr>)                                                     procedure
(compile <expr> <mode>)                                              procedure
        <expr>򥳥ѥ뤷ɤ֤<mode>()ʳꤵ줿ˤ
        ޥŸԤä̤֤

(macro-expand <expr>)                                                procedure
        <expr>ΥޥŸ̤֤(compile <expr> #t)ƱǤ롣

(disassemble <code>)                                                 procedure
        <code>ǥ֥뤷̤ɽ롣
        ä<code>ϥѥ뤵줿SECDRޥΥɤǤ٤Ǥ롣

(compile-file <sourcefile1> ... <outfile>)                           procedure
        <sourcefile1> ... ϡƴ¸ߤSchemeץΥե
        ̾stringǤ٤Ǥ롣Υե򥳥ѥ뤷̤
        <outfile>stringǻꤵ줿ե˽Ϥ롣

(%current-dump%)                                                     procedure
        ƤӽФ줿ǤD쥸(DUMP)֤ͤ
        ̾桼ϤprocedureƤӽФ٤ǤϤʤ

[Х塼]

-*-eval-hook-*-                                                       variable
-*-exec-hook-*-                                                       variable
        ơȥåץ٥READ-EVAL-PRINT롼פʤɤǻȤɸɾ,¹
        ³ꤹ롣֤Ǥϰʲeval, execꤵƤ롣
        㤨ХޥŸǽĥmacro:evalʬʤɤϡ
        ꤹ뤳Ȥˤäơȥåץ٥ˤƤmacro:eval
        Ѥ뤳ȤǤ롣

(eval <expr>)                                                        procedure
        <expr>ȥåץ٥δĶɾ֤ͤ
        (exec (compile <expr>))Ǥ롣

(exec <compiled-expr>)                                               procedure
        <compiled-expr>ȥåץ٥δĶǼ¹Ԥ֤ͤ

[顼]
-*-error-hook-*-                                                      variable
        顼䥤󥿥ץȤȯˤͤμ³ư롣

(error <msg> <irritant1> ...)                                        procedure

        <msg>stringǤ٤Ǥ롣顼Ǥ뤳Ȥȡ<msg>,<irritant>
        ɽ-*-error-hook-*-ꤵƤ³ư롣

)νϤǤϲŪʥޥ󤬣(Master, Slave)ѰդƤ롣
   ̾ưƤMasterΥޥϤθƤӽФߤҤνSlave
   äƹԤ

[ޥ]
(%master->list%)                                                     procedure
        MasterSECDRޥΣĤΥ쥸ƤꥹȤˤ֤

(%list->master% <list>)                                              procedure
        <list>ƤMasterSECDRޥγƥ쥸ꤹ롣
        ä<list>ĹΥꥹȤǤ٤Ǥ롣

(%reset-master%)                                                     procedure
        SlaveΥޥ󤬤ɾȡMasterΥޥƤΥ쥸
        ꥢ롣ʤ (%list->master% '(()()()()())) Ʊη̤
        ⤿餹MasterΥޥ󤬤ɾϲԤ
        ʤ̵뤹롣

[ޥ]
(macro <keyword> <transformer>)                             macro special form
        ޥڥեΥɤȤ<keyword>롣
        <transformer>ϡޥڥեΤäơ
        Ÿ֤٤֤μ³Ǥ٤Ǥ롣


extend-syntax                                               macro special form
        extend.exampleե򻲾ȤΤȡ

        <>
         jafferslib˴ޤޤޥѤ(fluidlet.scm, yasos.scm, 
         collect.scm)ǤϡޥϷޤäȤƤʤΤǡ
         extend-syntaxѤơΤǽ񤭴SECDR-SchemeΥ
         Ǽ¹ԤǤ롣ηޤäȤȤϡ

             (define-syntax INSTANCE-DISPATCHER
               (syntax-rules () ((instance-dispatcher inst) (cdr inst))))

         Ȥä褦ˡ

             (define-syntax <NAME>
               (syntax-rules () <BODY>))

         η֤򤷤ƤΤǡ

             (extend-syntax (<NAME>)
               <BODY>)

         Τ褦˽񤭴롣

         㤨о

             (extend-syntax (INSTANCE-DISPATCHER)
               ((instance-dispatcher inst) (cdr inst)))

         Ȥɤ

syntax-match?                                                        procedure
        extend-syntaxѤprocedureǤ롣

[ѿ]
global-define                                                     special form
        defineƱͤǤ뤬˥ȥåץ٥ɾ줿Ʊ̤ġ

[٥쥯]
(gc)                                                                 procedure
        Ū˥٥쥯¹Ԥ롣
(gc-verbose-off)                                                     procedure
(gc-verbose-on)                                                      procedure
        ٥쥯μ¹ԤɸϤɽ뤫ݤλ򤹤롣

[ܥ]
(gensym)                                                             procedure
(make-temp-symbol)                                                   procedure
(gensym <string>)                                                    procedure
(make-temp-symbol <string>)                                          procedure
        ܥ֤
        <string>λ̵ͭˤäƼΤ褦ˤʤ롣
                (gensym)        -->     G123
                (gensym "temp") -->     temp123

[°ꥹ]
(get <symbol> <attribute>)                                           procedure
(put <symbol> <attribute> <value>)                                   procedure
        <symbol>°ꥹȤФԤʤ
        put#v֤getϻꤵ줿°֤ͤ

[ƥط]
(quit)                                                               procedure
        SECDR-Schemeμ¹Ԥλ롣

(new-segment <n>)                                                    procedure
        ҡΰ򹭤롣<n>ϹȤοǡǤ
        ٤Ǥ롣ʣȤ礭ϥƥˤ롣
        ºݤ˳ĥǤȿåϤ롣
        #v֤

(system <string>)                                                    procedure
        <string>ƤۥȴĶϤޥɥץå˼¹Ԥ롣
        η̤֤ͤ

(pwd)                                                                procedure
        ȥǥ쥯ȥΥեѥ̾stringȤ֤

(cd)                                                                 procedure
(cd <pathname>)                                                      procedure
        <pathname>άȡȥǥ쥯ȥۡǥ쥯ȥ
        ꤹ롣
        <pathname>stringǤ٤Ǥ롣
        ꤵ줿ѥإȥǥ쥯ȥѹ롣
        #tԤʤ#f֤

(chdir <pathname>)                                                   procedure
        <pathname>stringǤ٤Ǥ롣
        ꤵ줿ѥإȥǥ쥯ȥѹ롣
        #tԤʤ#f֤

(getenv <name>)                                                      procedure
        <name>stringǤ٤Ǥ롣
        ̾<name>ƥδĶѿͤstringȤ֤
        ⤷⤽Τ褦ʴĶѿƤʤ#f֤

(software-type)                                                      procedure
        ¹ԤƤĶunixǤunix, MacintoshǤmacos, 
        MS-DOSǤmsdos֤

(ls)                                                                 procedure
(ls <string>)                                                        procedure
        shell ls <string> ¹Ԥ롣

(rm <filename>)                                                      procedure
        shell rm <filename> ¹Ԥ롣

(ed)                                                                 procedure
(ed <filename>)                                                      procedure
        ǥư롣

my-ls                                                                 variable
my-rm                                                                 variable
my-editor                                                             variable
        ls, rm, ed Ǽ¹ԤƥΥޥ̾ʡܥץˤ
        ʸȤƤѿ롣ǽ

[TIME]
(get-internal-time-units)                                            procedure
        CLOCK_PER_SECͤintegerȤ֤

(get-internal-run-time)                                              procedure
        ¹Ի֤CLOCKñ̤ͤintegerȤ֤

[ȥ졼]
(trace <sym1> <sym2> ...)                                            procedure
(untrace <sym1> <sym2> ...)                                          procedure
        <sym1>, <sym2>, ... Фȥ졼ꡢ뤤ϲԤʤ

set-trace                                                            procedure
        traceѤprocedureǤ롣

[]
(sequence <expr>)                                           macro special form
        ʲΤ褦Ƥ롣
                (macro sequence (lambda (expr)
                  `((lambda () ,@(cdr expr))) ))
        դ٤ȤϡbeginȤϰۤʤꡢ<expr>defineʸ̰
        ʤȤȤǤ롣

while                                                       macro special form
when                                                        macro special form
unless                                                      macro special form
        ơʲΤ褦Ƥ롣
                (macro while (lambda (while-macro)
                  (apply 
                    (lambda (pred . body)
                      (let ((while-loop (gensym))
                            (while-res (gensym)))
                        `(letrec ((,while-loop
                                   (lambda (,while-res)
                                     (if ,pred (,while-loop (begin ,@body))
                                         ,while-res))))
                           (,while-loop #f))))
                    (cdr while-macro))))

                (macro when
                  (lambda (args)
                    `(if ,(cadr args)
                         (begin ,@(cddr args))
                         #f)))

                (macro unless
                  (lambda (args)
                    `(if ,(cadr args)
                         #t
                         (begin ,@(cddr args)))))

(rec <var> <expr>)                                          macro special form
        (letrec ((<var> <expr>)) <var>)Ǥ롣recϰʲ˼
        褦ˡself-recursive procedureǤ롣

                ((rec loop
                   (lambda (n l)
                     (if (zero? n)
                         l
                         (loop (- n 1)(cons n l)))))
                 6 '())          --> (1 2 3 4 5 6)

        ʲΤ褦Ƥ롣
                (macro rec (lambda (rec-macro)
                  (apply (lambda (proc body)
                    `(letrec ((,proc ,body)) ,proc))
                  (cdr rec-macro))))

andmap                                                               procedure
        ʲΤ褦Ƥ롣
                (define (andmap p . args)
                  ;; use "first-finish" rule
                  (let andmap ((args args) (value #t))
                    (if (let any-at-end? ((ls args))
                          (and (pair? ls)
                               (or (not (pair? (car ls)))
                                   (any-at-end? (cdr ls)))))
                        value
                        (let ((value (apply p (map car args))))
                          (and value (andmap (map cdr args) value))))))

[Ҹ]
(file-exists? <file-name>)                                           procedure
        <file-name>stringǤ٤Ǥ롣<file-name>˻ꤵ줿̾
        פե뤬¸ߤƤ#t򡢤Ǥʤ#f֤

some?                                                                procedure
every?                                                               procedure
        ơʲΤ褦Ƥ롣
                (define (some? proc plist)
                  (cond
                    ((null? plist) #f)
                    ((proc (car plist)) #t)
                    (else (some? proc (cdr plist)))))

                (define (every? proc plist)
                  (cond
                    ((null? plist) #t)
                    ((proc (car plist)) (every? proc (cdr plist)))
                    (else #f)))

(atom? <obj>)                                                        procedure
(closure? <obj>)                                                     procedure
(continuation? <obj>)                                                procedure
(primitive-procedure? <obj>)                                         procedure
(proper-rational? <obj>)                                             procedure
(proper-real? <obj>)                                                 procedure
(promise? <obj>)                                                     procedure
        <obj>ơtypeǤȤ#tǤʤ#f֤

(set-promise <obj>)                                                  procedure
        (promise? <obj>)#t֤褦ˤ롣delayѤƤ롣

[Ѵ]
char->string                                                         procedure
        ʲΤ褦Ƥ롣
                (define (char->string c)
                  (string-set! "@" 0 c))


[ܥå]
(box)                                                                procedure
(box <object>)                                                       procedure
        <object>box֤
        ܥåκƥޥʸɸѰդƤ롣#&ǡ
        (box <object>)#&(<object>)ȵҤƤɤ

(unbox <box-object>)                                                 procedure
        <box-object>boxǤʤФʤʤ<box-object>object
        Ф֤

(box? <object>)                                                      procedure
        <object>boxǤȤ#tǤʤȤ#f֤

(set-box! <box-object> <object>)                                     procedure
        <box-object>boxǤʤФʤʤ<box-object><object>
        ֤롣

[ȥ꡼]
cons-stream                                                 macro special form
head                                                                 procedure
tail                                                                 procedure
        ơʲΤ褦Ƥ롣
                (macro cons-stream (lambda (l)
                    `(cons ,(cadr l) (delay ,(caddr l)))))

                (define (head stream) (car stream))

                (define (tail stream) (force (cdr stream)))

[]
(spaces <num> <outport>)                                             procedure
        <num>ǻꤵ줿Υڡ<outport>˽Ϥ롣

(print-list <mode> <list> <outport>)                                 procedure
        <list><outport>˽Ϥ롣<mode>0ꤵȡ
        <list>γǤdisplayǽϤ줿褦ˤʤꡢ
        ¾ͤꤵȡǤwriteǽϤ줿褦ˤʤ롣

pretty-print                                                         procedure
        ʰpretty-print

prompt-read                                                          procedure
        ʲΤ褦Ƥ롣
        (define (prompt-read prompt) (display prompt) (read))

printf                                                               procedure
        Cprintf˻

%format%                                                             procedure
        ʰformat

(uniq-print <term>)                                                  procedure
        <term>˽۴listޤvectorޤޤϡ˥٥Ĥ
        pretty-printɽ롣

(uniq-write <term>)                                                  procedure
        <term>˽۴listޤvectorޤޤϡ˥٥Ĥ
        ɽ롣

(uniq-read)                                                          procedure
        ۴listޤvectorΥ٥ˤɽɤߤȤ롣

(u-conv <term>)                                                      procedure
        <term>˽۴listޤvectorޤޤϡ<term>٥ˤ
        ɽ˲ŪѴ֤ͤ
        (: ᤹ͤˤϤ֤ͤɬȤäƤɬפ롣
             ʤ֤ͤ<term>ϰۤʤ롣)

(uu-conv <term>)                                                     procedure
        ۴listޤvectorΥ٥ˤɽޤ<term>򸵤ξ֤
        ˲Ūᤷ֤ͤ
        (: <term>Ȥ򸵤᤹ͤˤϡ֤ͤɬꤷľ
             ɬפ롣)

) ­ʤ(uu-conv (u-conv <term>))Ϥ<term>򸵤᤹

[R^2RS]
-1+                                                                  procedure
1+                                                                   procedure

[¾]
simplest-rational                                                    procedure
        rationalizeѤprocedureǤ롣

(list-width <obj>)                                                   procedure
        <obj>ΰʸ(byte)ˤʤ뤫֤

(qsort <seq> <pre>)                                                  procedure
        <pre>ӤΤνҸ졢<seq>listޤvectorǤ٤Ǥ롣
        åȤˤä¤ٴ֤ͤ

(qsort! <seq> <pre>)                                                 procedure
        <pre>ӤΤνҸ졢<seq>vectorǤ٤Ǥ롣
        åȤˤä<seq>Ϳ줿vectorǤ¤ٴ롣
        Ƥ֤ͤ(ѤԤѤ롣)

------------------------------------------------------------------------------

<ʸ>

[1] Harold Abelson, Gerald Jay Sussman:
    Structure and Interpretation of Computer Programs,
    McGrawHill, 1985.

[2] William Clinger, Jonathan Rees.(Editors):
    Revised^4 Report on the Algorithmic Language Scheme,
    2 November, 1991.
