|
|
Info Catalog
(r5rs.info.gz) Bibliography
(r5rs.info.gz) Top
Alphabetic index of definitions of concepts, keywords, and procedures ********************************************************************* The principal entry for each term, procedure, or keyword is listed first, separated from the other entries by a semicolon. Concepts ======== [index ]
* ' Literal expressions. (line 9)
* , Quasiquotation. (line 13)
* ,@ Quasiquotation. (line 17)
* ; Whitespace and comments.
(line 16)
* => Conditional. (line 20)
* ` Quasiquotation. (line 53)
* backquote Quasiquotation. (line 8)
* binding Variables; syntactic keywords; and regions.
(line 11)
* binding construct Variables; syntactic keywords; and regions.
(line 23)
* bound Variables; syntactic keywords; and regions.
(line 44)
* call Procedure calls. (line 11)
* call by need Delayed evaluation. (line 8)
* combination Procedure calls. (line 31)
* comma Quasiquotation. (line 11)
* comment <1> Lexical structure. (line 28)
* comment Whitespace and comments.
(line 16)
* constant Storage model. (line 27)
* continuation Control features. (line 251)
* define Definitions. (line 15)
* define-syntax Syntax definitions. (line 8)
* definition Definitions. (line 15)
* do Iteration. (line 10)
* dotted pair Pairs and lists. (line 6)
* else Conditional. (line 20)
* empty list <1> Pairs and lists. (line 13)
* empty list <2> Booleans. (line 20)
* empty list Disjointness of types.
(line 20)
* equivalence predicate Equivalence predicates.
(line 7)
* error Error situations and unspecified behavior.
(line 6)
* escape procedure Control features. (line 191)
* exact Equivalence predicates.
(line 53)
* exactness Exactness. (line 6)
* false <1> Booleans. (line 9)
* false Disjointness of types.
(line 24)
* hygienic Macros. (line 41)
* identifier <1> Lexical structure. (line 22)
* identifier <2> Symbols. (line 9)
* identifier <3> Variables; syntactic keywords; and regions.
(line 6)
* identifier Identifiers. (line 6)
* immutable Storage model. (line 31)
* implementation restriction <1> Implementation restrictions.
(line 6)
* implementation restriction Error situations and unspecified behavior.
(line 26)
* improper list Pairs and lists. (line 57)
* inexact Equivalence predicates.
(line 53)
* initial environment Standard procedures. (line 15)
* internal definition Internal definitions.
(line 10)
* keyword <1> Lexical structure. (line 44)
* keyword Macros. (line 19)
* lazy evaluation Delayed evaluation. (line 8)
* library Primitive; library; and optional features.
(line 15)
* library procedure Standard procedures. (line 15)
* location Storage model. (line 7)
* macro Macros. (line 12)
* macro keyword Macros. (line 19)
* macro transformer Macros. (line 24)
* macro use Macros. (line 22)
* mutable Storage model. (line 30)
* number Numbers. (line 15)
* numerical types Numerical types. (line 6)
* object Semantics. (line 16)
* optional Primitive; library; and optional features.
(line 7)
* pair Pairs and lists. (line 6)
* port Ports. (line 8)
* predicate Equivalence predicates.
(line 6)
* procedure call Procedure calls. (line 11)
* promise <1> Control features. (line 79)
* promise Delayed evaluation. (line 10)
* proper tail recursion Proper tail recursion.
(line 6)
* referentially transparent Macros. (line 41)
* region <1> Iteration. (line 34)
* region <2> Binding constructs. (line 8)
* region <3> Assignments. (line 9)
* region Variables; syntactic keywords; and regions.
(line 34)
* simplest rational Numerical operations.
(line 255)
* syntactic keyword <1> Lexical structure. (line 44)
* syntactic keyword <2> Macros. (line 19)
* syntactic keyword <3> Variables; syntactic keywords; and regions.
(line 8)
* syntactic keyword Identifiers. (line 41)
* syntax definition Syntax definitions. (line 8)
* tail call Proper tail recursion.
(line 42)
* token Lexical structure. (line 6)
* top level environment <1> Standard procedures. (line 15)
* top level environment Variables; syntactic keywords; and regions.
(line 44)
* true <1> Booleans. (line 9)
* true <2> Conditional. (line 22)
* true <3> Conditionals. (line 12)
* true Disjointness of types.
(line 24)
* type Disjointness of types.
(line 20)
* unbound <1> Top level definitions.
(line 19)
* unbound <2> Variable references. (line 11)
* unbound Variables; syntactic keywords; and regions.
(line 44)
* unspecified Error situations and unspecified behavior.
(line 35)
* valid indexes <1> Vectors. (line 13)
* valid indexes Strings. (line 22)
* variable <1> Lexical structure. (line 52)
* variable <2> Variable references. (line 7)
* variable <3> Variables; syntactic keywords; and regions.
(line 10)
* variable Identifiers. (line 41)
* Whitespace Whitespace and comments.
(line 6)
Procedures
==========
[index ]
* Menu
* ' Literal expressions. (line 8)
* * Numerical operations.
(line 115)
* + Numerical operations.
(line 114)
* - Numerical operations.
(line 125)
* / Numerical operations.
(line 128)
* < Numerical operations.
(line 68)
* <= Numerical operations.
(line 70)
* <constant> Literal expressions. (line 9)
* <operator> Procedure calls. (line 7)
* <variable> Variable references. (line 7)
* = Numerical operations.
(line 67)
* > Numerical operations.
(line 69)
* >= Numerical operations.
(line 71)
* ` Quasiquotation. (line 8)
* abs Numerical operations.
(line 143)
* acos Numerical operations.
(line 275)
* and Conditional. (line 88)
* angle Numerical operations.
(line 324)
* append Pairs and lists. (line 197)
* apply Control features. (line 24)
* asin Numerical operations.
(line 274)
* assoc Pairs and lists. (line 268)
* assq Pairs and lists. (line 266)
* assv Pairs and lists. (line 267)
* atan Numerical operations.
(line 276)
* begin Sequencing. (line 7)
* boolean? Booleans. (line 44)
* caar Pairs and lists. (line 152)
* cadr Pairs and lists. (line 153)
* call-with-current-continuation Control features. (line 188)
* call-with-input-file Ports. (line 11)
* call-with-output-file Ports. (line 12)
* call-with-values Control features. (line 297)
* car Pairs and lists. (line 118)
* case Conditional. (line 51)
* cdddar Pairs and lists. (line 155)
* cddddr Pairs and lists. (line 156)
* cdr Pairs and lists. (line 128)
* ceiling Numerical operations.
(line 220)
* char->integer Characters. (line 106)
* char-alphabetic? Characters. (line 92)
* char-ci<=? Characters. (line 83)
* char-ci<? Characters. (line 81)
* char-ci=? Characters. (line 80)
* char-ci>=? Characters. (line 84)
* char-ci>? Characters. (line 82)
* char-downcase Characters. (line 128)
* char-lower-case? Characters. (line 96)
* char-numeric? Characters. (line 93)
* char-ready? Input. (line 69)
* char-upcase Characters. (line 127)
* char-upper-case? Characters. (line 95)
* char-whitespace? Characters. (line 94)
* char<=? Characters. (line 55)
* char<? Characters. (line 53)
* char=? Characters. (line 52)
* char>=? Characters. (line 56)
* char>? Characters. (line 54)
* char? Characters. (line 48)
* close-input-port Ports. (line 76)
* close-output-port Ports. (line 77)
* complex? Numerical operations.
(line 20)
* cond Conditional. (line 7)
* cons Pairs and lists. (line 106)
* cos Numerical operations.
(line 272)
* current-input-port Ports. (line 41)
* current-output-port Ports. (line 42)
* delay Delayed evaluation. (line 7)
* denominator Numerical operations.
(line 207)
* display Output. (line 25)
* do Iteration. (line 10)
* dynamic-wind Control features. (line 310)
* eof-object? Input. (line 62)
* eq? Equivalence predicates.
(line 165)
* equal? Equivalence predicates.
(line 206)
* eqv? Equivalence predicates.
(line 14)
* eval Eval. (line 7)
* even? Numerical operations.
(line 92)
* exact->inexact Numerical operations.
(line 349)
* exact? Numerical operations.
(line 60)
* exp Numerical operations.
(line 269)
* expt Numerical operations.
(line 312)
* floor Numerical operations.
(line 219)
* for-each Control features. (line 64)
* force Control features. (line 78)
* gcd Numerical operations.
(line 194)
* if Conditionals. (line 7)
* imag-part Numerical operations.
(line 322)
* inexact->exact Numerical operations.
(line 350)
* inexact? Numerical operations.
(line 61)
* input-port? Ports. (line 35)
* integer->char Characters. (line 107)
* integer? Numerical operations.
(line 23)
* interaction-environment Eval. (line 50)
* lambda Procedures. (line 7)
* lcm Numerical operations.
(line 195)
* length Pairs and lists. (line 189)
* let <1> Iteration. (line 54)
* let Binding constructs. (line 17)
* let* Binding constructs. (line 45)
* let-syntax Binding constructs for syntactic keywords.
(line 12)
* letrec Binding constructs. (line 65)
* letrec-syntax Binding constructs for syntactic keywords.
(line 43)
* list Pairs and lists. (line 182)
* list->string Strings. (line 116)
* list->vector Vectors. (line 85)
* list-ref Pairs and lists. (line 235)
* list-tail Pairs and lists. (line 223)
* list? Pairs and lists. (line 170)
* load System interface. (line 11)
* log Numerical operations.
(line 270)
* magnitude Numerical operations.
(line 323)
* make-polar Numerical operations.
(line 320)
* make-rectangular Numerical operations.
(line 319)
* make-string Strings. (line 40)
* make-vector <1> Vectors. (line 38)
* make-vector Entry format. (line 56)
* map Control features. (line 39)
* max Numerical operations.
(line 97)
* member Pairs and lists. (line 248)
* memq Pairs and lists. (line 246)
* memv Pairs and lists. (line 247)
* min Numerical operations.
(line 98)
* modulo Numerical operations.
(line 151)
* negative? Numerical operations.
(line 90)
* newline Output. (line 42)
* not Booleans. (line 32)
* null-environment Eval. (line 28)
* null? Pairs and lists. (line 166)
* number->string Numerical input and output.
(line 10)
* number? Numerical operations.
(line 19)
* numerator Numerical operations.
(line 206)
* odd? Numerical operations.
(line 91)
* open-input-file Ports. (line 63)
* open-output-file Ports. (line 69)
* or Conditional. (line 102)
* output-port? Ports. (line 36)
* pair? Pairs and lists. (line 97)
* peek-char Input. (line 44)
* positive? Numerical operations.
(line 89)
* procedure? Control features. (line 11)
* quasiquote Quasiquotation. (line 7)
* quote Literal expressions. (line 7)
* quotient Numerical operations.
(line 149)
* rational? Numerical operations.
(line 22)
* rationalize Numerical operations.
(line 253)
* read Input. (line 13)
* read-char Input. (line 35)
* real-part Numerical operations.
(line 321)
* real? Numerical operations.
(line 21)
* remainder Numerical operations.
(line 150)
* reverse Pairs and lists. (line 214)
* round Numerical operations.
(line 222)
* scheme-report-environment Eval. (line 27)
* set! Assignments. (line 7)
* set-car! Pairs and lists. (line 137)
* set-cdr! Pairs and lists. (line 147)
* sin Numerical operations.
(line 271)
* sqrt Numerical operations.
(line 307)
* string Strings. (line 47)
* string->list Strings. (line 115)
* string->number Numerical input and output.
(line 48)
* string->symbol Symbols. (line 72)
* string-append Strings. (line 110)
* string-ci<=? Strings. (line 86)
* string-ci<? Strings. (line 84)
* string-ci=? Strings. (line 72)
* string-ci>=? Strings. (line 87)
* string-ci>? Strings. (line 85)
* string-copy Strings. (line 124)
* string-fill! Strings. (line 128)
* string-length Strings. (line 51)
* string-ref Strings. (line 54)
* string-set! Strings. (line 58)
* string<=? Strings. (line 82)
* string<? Strings. (line 80)
* string=? Strings. (line 71)
* string>=? Strings. (line 83)
* string>? Strings. (line 81)
* string? Strings. (line 37)
* substring Strings. (line 100)
* symbol->string Symbols. (line 48)
* symbol? Symbols. (line 37)
* syntax-rules Pattern language. (line 9)
* tan Numerical operations.
(line 273)
* TEMPLATE Entry format. (line 15)
* transcript-off System interface. (line 26)
* transcript-on System interface. (line 25)
* truncate Numerical operations.
(line 221)
* values Control features. (line 286)
* vector Vectors. (line 45)
* vector->list Vectors. (line 84)
* vector-fill! Vectors. (line 96)
* vector-length Vectors. (line 52)
* vector-ref <1> Vectors. (line 55)
* vector-ref Entry format. (line 48)
* vector-set! Vectors. (line 70)
* vector? Vectors. (line 35)
* with-input-from-file Ports. (line 46)
* with-output-to-file Ports. (line 47)
* write Output. (line 14)
* write-char Output. (line 50)
* zero? Numerical operations.
(line 88)
* ... Pairs and lists. (line 154)
References
==========
[index ]
* Menu
* Bawden88 Bibliography. (line 10)
* CLtL Bibliography. (line 114)
* howtoprint Bibliography. (line 14)
* howtoread Bibliography. (line 24)
* hygienic Bibliography. (line 65)
* IEEE Bibliography. (line 55)
* IEEEScheme Bibliography. (line 58)
* Kohlbecker86 Bibliography. (line 61)
* Landin65 Bibliography. (line 70)
* macrosthatwork Bibliography. (line 33)
* MITScheme Bibliography. (line 74)
* Naur63 Bibliography. (line 77)
* Penfield81 Bibliography. (line 81)
* Pitman83 Bibliography. (line 86)
* propertailrecursion Bibliography. (line 37)
* R3RS Bibliography. (line 99)
* R4RS Bibliography. (line 29)
* Rabbit Bibliography. (line 111)
* Rees82 Bibliography. (line 90)
* Rees84 Bibliography. (line 95)
* Reynolds72 Bibliography. (line 103)
* RRRS Bibliography. (line 19)
* Scheme311 Bibliography. (line 46)
* Scheme75 Bibliography. (line 117)
* Scheme78 Bibliography. (line 107)
* Scheme84 Bibliography. (line 51)
* SICP Bibliography. (line 6)
* Stoy77 Bibliography. (line 121)
* syntacticabstraction Bibliography. (line 42)
* TImanual85 Bibliography. (line 125)
Info Catalog
(r5rs.info.gz) Bibliography
(r5rs.info.gz) Top