Alphabetic Index (Revised7.0 Report on the Algorithmic Language Scheme (Unofficial))

Previous: References, Up: Revised^7.0 Report on the Algorithmic Language Scheme (Unofficial) [Contents][Index]

Alphabetic Index of Definitions of Concepts, Keywords, and Procedures ¶

Jump to:	_ - , ! ? . ' * / ` + < = > A B C D E F G H I J L M N O P Q R S T U V W X Z

_
	Index Entry	Section

	`_`	Pattern language

-
	`-`	Numerical operations
	`-`	Numerical operations
	`->`	Naming conventions

,
	`,`	Quasiquotation
	`,@`	Quasiquotation

!
	`!`	Naming conventions

?
	`?`	Naming conventions

.
	`...`	Pattern language

'
	`'`	Literal expressions

*
	`*`	Numerical operations

/
	`/`	Numerical operations
	`/`	Numerical operations

`
	`	Quasiquotation

+
	`+`	Numerical operations

<
	`<`	Numerical operations
	`<=`	Numerical operations

=
	`=`	Numerical operations
	`=>`	Derived Conditionals

>
	`>`	Numerical operations
	`>=`	Numerical operations

A
	`abs`	Numerical operations
	`acos`	Numerical operations
	active tail call	Proper tail recursion
	alist, See association list
	“an error”	Error situations and unspecified behavior
	“an error is signaled”	Error situations and unspecified behavior
	“an error that satisfies `predicate`”	Error situations and unspecified behavior
	`and`	Derived Conditionals
	`angle`	Numerical operations
	angle brackets	Entry format
	`append`	Pairs and lists
	`apply`	Control features
	argument evaluation	Semantics
	argument passing	Semantics
	arithmetic
	exact, See exact arithmetic
	inexact, See inexact arithmetic
	`asin`	Numerical operations
	assignment	Assignments
	`assoc`	Pairs and lists
	`assoc`	Pairs and lists
	association list	Pairs and lists
	`assq`	Pairs and lists
	`assv`	Pairs and lists
	`atan`	Numerical operations
	`atan`	Numerical operations
	atmosphere	Lexical structure
	comments, See comments
	directives, See directives
	whitespace, See whitespace
	auxiliary syntax	Entry format

B
	#b	Syntax of numerical constants
	base library	Base and optional features
	`begin`	Library syntax
	`begin`	Sequencing
	`begin`	Sequencing
	`binary-port?`	Ports
	block comment	Whitespace and comments
	block structure	Variables syntactic keywords and regions
	`boolean?`	Booleans
	`boolean=?`	Booleans
	bound identifier	Variables syntactic keywords and regions
	`bytevector`	Bytevectors
	`bytevector-append`	Bytevectors
	`bytevector-copy`	Bytevectors
	`bytevector-copy`	Bytevectors
	`bytevector-copy`	Bytevectors
	`bytevector-copy!`	Bytevectors
	`bytevector-copy!`	Bytevectors
	`bytevector-copy!`	Bytevectors
	`bytevector-length`	Bytevectors
	`bytevector-u8-ref`	Bytevectors
	`bytevector-u8-set!`	Bytevectors
	`bytevector?`	Bytevectors

C
	`caaaar`	Pairs and lists
	`caaadr`	Pairs and lists
	`caaar`	Pairs and lists
	`caadar`	Pairs and lists
	`caaddr`	Pairs and lists
	`caadr`	Pairs and lists
	`caar`	Pairs and lists
	`cadaar`	Pairs and lists
	`cadadr`	Pairs and lists
	`cadar`	Pairs and lists
	`caddar`	Pairs and lists
	`cadddr`	Pairs and lists
	`caddr`	Pairs and lists
	`cadr`	Pairs and lists
	`call-with-current-continuation`	Control features
	`call-with-input-file`	Ports
	`call-with-output-file`	Ports
	`call-with-port`	Ports
	`call-with-values`	Control features
	`call/cc`	Control features
	`car`	Pairs and lists
	`case`	Derived Conditionals
	case sensitivity	Identifiers
	`case-lambda`	Case-lambda
	catching syntax errors	Signaling errors in macro transformers
	`cdaaar`	Pairs and lists
	`cdaadr`	Pairs and lists
	`cdaar`	Pairs and lists
	`cdadar`	Pairs and lists
	`cdaddr`	Pairs and lists
	`cdadr`	Pairs and lists
	`cdar`	Pairs and lists
	`cddaar`	Pairs and lists
	`cddadr`	Pairs and lists
	`cddar`	Pairs and lists
	`cdddar`	Pairs and lists
	`cddddr`	Pairs and lists
	`cdddr`	Pairs and lists
	`cddr`	Pairs and lists
	`cdr`	Pairs and lists
	`ceiling`	Numerical operations
	`char->integer`	Characters
	`char-alphabetic?`	Characters
	`char-ci<?`	Characters
	`char-ci<=?`	Characters
	`char-ci=?`	Characters
	`char-ci>?`	Characters
	`char-ci>=?`	Characters
	`char-downcase`	Characters
	`char-foldcase`	Characters
	`char-lower-case?`	Characters
	`char-numeric?`	Characters
	`char-ready?`	Input
	`char-ready?`	Input
	`char-upcase`	Characters
	`char-upper-case?`	Characters
	`char-whitespace?`	Characters
	`char?`	Characters
	`char<?`	Characters
	`char<=?`	Characters
	`char=?`	Characters
	`char>?`	Characters
	`char>=?`	Characters
	circular reference	Datum labels
	circular structure	Datum labels
	`close-input-port`	Ports
	`close-output-port`	Ports
	`close-port`	Ports
	coercion procedures	Naming conventions
	naming conventions	Naming conventions
	combination, See procedure call
	command	Naming conventions
	`command-line`	System interface
	comment	Lexical structure
	comments	Whitespace and comments
	`complex?`	Numerical operations
	conceptual locations	Storage model
	freshness, See fresh locations
	`cond`	Derived Conditionals
	`cond-expand`	Derived Conditionals
	`cond-expand`	Library syntax
	`cons`	Pairs and lists
	contagiousness of inexactness, See inexact number
	continuable exception	Exceptions
	continuations	Control features
	extents of	Semantics
	first-class status	Semantics
	`cos`	Numerical operations
	current exception handler	Exceptions
	`current-error-port`	Ports
	`current-input-port`	Ports
	`current-jiffy`	System interface
	`current-output-port`	Ports
	`current-second`	System interface

D
	#d	Syntax of numerical constants
	datum comment	Whitespace and comments
	datum label	Datum labels
	datum reference	Datum labels
	datum reference	Datum labels
	`define`	Variable definitions
	`define-library`	Library syntax
	`define-record-type`	Record-type definitions
	`define-syntax`	Syntax definitions
	`define-values`	Multiple-value definitions
	`delay`	Delayed evaluation
	`delay-force`	Delayed evaluation
	`delete-file`	System interface
	`denominator`	Numerical operations
	derived expressions	Derived expression types
	definitions	Definitions of derived expressions
	formal	Definitions of derived expressions
	`digit-value`	Characters
	directives	Identifiers
	disjointness of types	Disjointness of types
	`display`	Output
	`display`	Output
	`do`	Iteration
	dynamic types, See types
	`dynamic-wind`	Control features

E
	`else`	Derived Conditionals
	`emergency-exit`	System interface
	`emergency-exit`	System interface
	the empty list	Booleans
	empty list	Pairs and lists
	evaluation	Procedure calls
	entry format	Entry format
	environment	Variables syntactic keywords and regions
	`environment`	Environments and evaluation
	`eof-object`	Input
	`eof-object?`	Input
	`eq?`	Equivalence predicates
	`on characters`	Equivalence predicates
	`on empty bytevectors`	Equivalence predicates
	`on empty strings`	Equivalence predicates
	`on empty vectors`	Equivalence predicates
	`on numbers`	Equivalence predicates
	`on procedures`	Equivalence predicates
	`rule of thumb`	Equivalence predicates
	`vs. eqv?`	Equivalence predicates
	`equal?`	Equivalence predicates
	`on bytevectors`	Equivalence predicates
	`on circular data structures`	Equivalence predicates
	`on pairs`	Equivalence predicates
	`on strings`	Equivalence predicates
	`on vectors`	Equivalence predicates
	`rule of thumb`	Equivalence predicates
	`vs. eqv?`	Equivalence predicates
	equivalence predicates	Equivalence predicates
	coarseness	Equivalence predicates
	efficiency	Equivalence predicates
	generality	Equivalence predicates
	`eqv?`	Equivalence predicates
	`on booleans`	Equivalence predicates
	`on bytevectors`	Equivalence predicates
	`on characters`	Equivalence predicates
	`on constants`	Equivalence predicates
	`on exact numbers`	Equivalence predicates
	`on inexact numbers`	Equivalence predicates
	`on literals`	Equivalence predicates
	`on NaN`	Equivalence predicates
	`on negative zero`	Equivalence predicates
	`on numbers of mixed exactness`	Equivalence predicates
	`on objects of different types`	Equivalence predicates
	`on pairs`	Equivalence predicates
	`on procedures`	Equivalence predicates
	`on procedures with local state`	Equivalence predicates
	`on records`	Equivalence predicates
	`on strings`	Equivalence predicates
	`on symbols`	Equivalence predicates
	`on the empty list`	Equivalence predicates
	`on vectors`	Equivalence predicates
	`rule of thumb`	Equivalence predicates
	`unspecified behavior`	Equivalence predicates
	`error`	Exceptions
	error signaling	Error situations and unspecified behavior
	error situation	Error situations and unspecified behavior
	`error-object-irritants`	Exceptions
	`error-object-message`	Exceptions
	`error-object?`	Exceptions
	escape procedure	Control features
	escape sequence	Strings
	`eval`	Environments and evaluation
	`even?`	Numerical operations
	`exact`	Numerical operations
	exact arithmetic	Semantics
	exact number	Exactness
	`exact->inexact`	Numerical operations
	`exact-integer-sqrt`	Numerical operations
	`exact-integer?`	Numerical operations
	`exact?`	Numerical operations
	exception handlers	Exceptions
	`exit`	System interface
	`exit`	System interface
	`exp`	Numerical operations
	`export`	Library syntax
	expression types	Expressions
	`expt`	Numerical operations
	extended identifier characters	Identifiers
	extents	Semantics
	external representation	External representations
	uniqueness of	External representations

F
	“false”	Disjointness of types
	`features`	System interface
	fields	Record-type definitions
	`file-error?`	Exceptions
	`file-exists?`	System interface
	`finite?`	Numerical operations
	`floor`	Numerical operations
	`floor-quotient`	Numerical operations
	`floor-remainder`	Numerical operations
	`floor/`	Numerical operations
	`flush-output-port`	Output
	`flush-output-port`	Output
	`for-each`	Control features
	`force`	Delayed evaluation
	formal parameter syntax	Procedures
	fresh locations	Standard procedures

G
	`gcd`	Numerical operations
	`get-environment-variable`	System interface
	`get-environment-variables`	System interface
	`get-output-bytevector`	Ports
	`get-output-string`	Ports
	`guard`	Exception handling

H
	hygienic macro	Macros

I
	identifier	Lexical structure
	identifier escape	Lexical structure
	identifier syntax	Incompatibilities with R6RS
	IEEE-754	Implementation restrictions
	IEEE-754-2008	Implementation restrictions
	`if`	Primitive conditionals
	`if`	Primitive conditionals
	`imag-part`	Numerical operations
	immutable objects	Storage model
	implementation restrictions	Error situations and unspecified behavior
	`import`	Import declarations
	`import`	Library syntax
	`include`	Inclusion
	`include`	Library syntax
	include	Inclusion
	include path	Inclusion
	`include-ci`	Inclusion
	`include-ci`	Library syntax
	`include-library-declarations`	Library syntax
	`inexact`	Numerical operations
	inexact arithmetic	Semantics
	inexact number	Exactness
	`inexact->exact`	Numerical operations
	`inexact?`	Numerical operations
	`infinite?`	Numerical operations
	infinity	Implementation extensions
	initial bindings	Programs
	initial environment	Programs
	`input-port-open?`	Ports
	`input-port?`	Ports
	`integer->char`	Characters
	`integer?`	Numerical operations
	`interaction-environment`	Environments and evaluation
	intertoken space	Lexical structure
	iteration	Semantics

J
	`jiffies-per-second`	System interface
	jiffy	System interface

L
	`lambda`	Procedures
	`lcm`	Numerical operations
	`length`	Pairs and lists
	`let`	Binding constructs
	`let`	Iteration
	`let-syntax`	Binding constructs for syntactic keywords
	`let-values`	Binding constructs
	`let*`	Binding constructs
	`let*-values`	Binding constructs
	`letrec`	Binding constructs
	`letrec-syntax`	Binding constructs for syntactic keywords
	`letrec*`	Binding constructs
	lexical decomposition	Syntax
	lexical scope	Semantics
	libraries	Base and optional features
	libraries	Libraries
	library naming	Library syntax
	line comment	Whitespace and comments
	`list`	Pairs and lists
	definition	Pairs and lists
	`list->string`	Strings
	`list->vector`	Vectors
	`list-copy`	Pairs and lists
	`list-ref`	Pairs and lists
	`list-set!`	Pairs and lists
	`list-tail`	Pairs and lists
	`list?`	Pairs and lists
	literal expression	Literal expressions
	`load`	System interface
	`load`	System interface
	location tags	Storage model
	comparison via `eq?`	Equivalence predicates
	comparison via `eqv?`	Equivalence predicates
	creation via `lambda` expression	Procedures
	`log`	Numerical operations
	`log`	Numerical operations

M
	macro	Macros
	definition facility	Macros
	namespace	Macros
	transformer	Macros
	use	Macros
	`magnitude`	Numerical operations
	`make-bytevector`	Bytevectors
	`make-bytevector`	Bytevectors
	`make-list`	Pairs and lists
	`make-list`	Pairs and lists
	`make-parameter`	Dynamic bindings
	`make-parameter`	Dynamic bindings
	`make-polar`	Numerical operations
	`make-promise`	Delayed evaluation
	`make-rectangular`	Numerical operations
	`make-string`	Strings
	`make-string`	Strings
	`make-vector`	Vectors
	`make-vector`	Vectors
	mantissa widths	Incompatibilities with R6RS
	`map`	Control features
	`max`	Numerical operations
	“may”, See RFC 2119
	“may report a violation of an implementation restriction”	Error situations and unspecified behavior
	`member`	Pairs and lists
	`member`	Pairs and lists
	`memq`	Pairs and lists
	`memv`	Pairs and lists
	`min`	Numerical operations
	`modulo`	Numerical operations
	“must”, See RFC 2119
	“must not”, See RFC 2119
	mutable objects	Storage model
	mutation procedures
	naming conventions	Naming conventions

N
	NaN	Implementation extensions
	`nan?`	Numerical operations
	negative infinity	Implementation extensions
	negative zero	Implementation extensions
	`negative?`	Numerical operations
	nested comment	Whitespace and comments
	`newline`	Output
	`newline`	Output
	newly allocated storage	Storage model
	freshness, See fresh locations
	non-continuable exception	Error situations and unspecified behavior
	non-local exits	Control features
	via `guard`, See non-local exits
	`not`	Booleans
	not a number, See NaN
	`null-environment`	Environments and evaluation
	`null?`	Pairs and lists
	`number->string`	Numerical input and output
	`number->string`	Numerical input and output
	`number?`	Numerical operations
	numbers	Numbers
	exactness	Exactness
	inexactness	Exactness
	types	Numerical types
	`numerator`	Numerical operations

O
	#o	Syntax of numerical constants
	objects
	external representations	External representations
	immutability	Storage model
	mutability	Storage model
	newly allocated	Storage model
	storage	Storage model
	storage locations of	Storage model
	types of	Disjointness of types
	`odd?`	Numerical operations
	`open-binary-input-file`	Ports
	`open-binary-output-file`	Ports
	`open-input-bytevector`	Ports
	`open-input-file`	Ports
	`open-input-string`	Ports
	`open-output-bytevector`	Ports
	`open-output-file`	Ports
	`open-output-string`	Ports
	“optional”, See RFC 2119
	`or`	Derived Conditionals
	order of evaluation
	procedure call	Procedure calls
	`output-port-open?`	Ports
	`output-port?`	Ports

P
	`pair?`	Pairs and lists
	parameter naming conventions	Entry format
	`parameterize`	Dynamic bindings
	parsing as data	Syntax
	pass by value	Semantics
	peculiar identifier	Lexical structure
	`peek-char`	Input
	`peek-char`	Input
	`peek-u8`	Input
	`peek-u8`	Input
	Polish notation	Syntax
	`port?`	Ports
	ports	Ports
	`positive?`	Numerical operations
	predicates	Equivalence predicates
	naming conventions	Naming conventions
	prefix notation	Syntax
	procedure call	Procedure calls
	procedure object	Procedures
	`procedure?`	Control features
	procedures
	as objects	Semantics
	programs as data	Syntax
	`promise?`	Delayed evaluation
	proper tail recursion	Proper tail recursion
	history	Proper tail recursion
	implementation requirement	Semantics

Q
	`quasiquote`	Quasiquotation
	`quote`	Literal expressions
	`quotient`	Numerical operations

R
	radix prefix	Syntax of numerical constants
	`raise`	Exceptions
	`raise-continuable`	Exceptions
	`rational?`	Numerical operations
	`rationalize`	Numerical operations
	`read`	Input
	`read`	Input
	`read-bytevector`	Input
	`read-bytevector`	Input
	`read-bytevector!`	Input
	`read-bytevector!`	Input
	`read-bytevector!`	Input
	`read-bytevector!`	Input
	`read-char`	Input
	`read-char`	Input
	`read-error?`	Exceptions
	read-eval-print loop	The REPL
	`read-line`	Input
	`read-line`	Input
	`read-string`	Input
	`read-string`	Input
	`read-u8`	Input
	`read-u8`	Input
	`real-part`	Numerical operations
	`real?`	Numerical operations
	“recommended”, See RFC 2119
	record type	Record-type definitions
	uniqueness	Record-type definitions
	referentially transparent macro	Macros
	region	Variables syntactic keywords and regions
	region of a binding	Variables syntactic keywords and regions
	`remainder`	Numerical operations
	`rename`	Library syntax
	REPL	The REPL
	initial environment	The REPL
	versus program	The REPL
	“required”, See RFC 2119
	`reverse`	Pairs and lists
	RFC 2119	Error situations and unspecified behavior
	`round`	Numerical operations

S
	sameness, See equivalence predicates
	`scheme-report-environment`	Environments and evaluation
	scope	Semantics
	`set-car!`	Pairs and lists
	`set-cdr!`	Pairs and lists
	`set!`	Assignments
	“shall”, See RFC 2119
	“shall not”, See RFC 2119
	shared structure	Datum labels
	“should”, See RFC 2119
	“should not”, See RFC 2119
	signaling an error	Error situations and unspecified behavior
	simplest rational	Numerical operations
	`sin`	Numerical operations
	`sqrt`	Numerical operations
	`square`	Numerical operations
	standard libraries	Standard Libraries
	static scope	Semantics
	storage
	actual arguments	Procedures
	freshness, See fresh locations
	of objects	Storage model
	`string`	Strings
	`string->list`	Strings
	`string->list`	Strings
	`string->list`	Strings
	`string->number`	Numerical input and output
	`string->number`	Numerical input and output
	`string->symbol`	Symbols
	`string->utf8`	Bytevectors
	`string->utf8`	Bytevectors
	`string->utf8`	Bytevectors
	`string->vector`	Vectors
	`string->vector`	Vectors
	`string->vector`	Vectors
	`string-append`	Strings
	`string-ci=?`	Strings
	`string-ci>?`	Strings
	`string-ci>=?`	Strings
	`string-ci<=?`	Strings
	`string-ci<?`	Strings
	`string-copy`	Strings
	`string-copy`	Strings
	`string-copy`	Strings
	`string-copy!`	Strings
	`string-copy!`	Strings
	`string-copy!`	Strings
	`string-downcase`	Strings
	`string-fill!`	Strings
	`string-fill!`	Strings
	`string-fill!`	Strings
	`string-foldcase`	Strings
	`string-for-each`	Control features
	`string-length`	Strings
	`string-map`	Control features
	`string-ref`	Strings
	`string-set!`	Strings
	`string-upcase`	Strings
	`string?`	Strings
	`string=?`	Strings
	`string>?`	Strings
	`string>=?`	Strings
	`string<=?`	Strings
	`string<?`	Strings
	`substring`	Strings
	`symbol->string`	Symbols
	`symbol?`	Symbols
	`symbol=?`	Symbols
	syntactic decomposition	Syntax
	syntactic keyword	Variables syntactic keywords and regions
	syntactic keyword	Macros
	syntactic recursion	Semantics
	syntactic variables	Entry format
	`syntax-error`	Signaling errors in macro transformers
	`syntax-rules`	Pattern language
	`syntax-rules`	Pattern language

T
	tail call	Proper tail recursion
	tail context	Proper tail recursion
	`tan`	Numerical operations
	`textual-port?`	Ports
	thunk	Naming conventions
	token	Lexical structure
	“true”	Disjointness of types
	“a true value”	Booleans
	“a false value”	Booleans
	`truncate`	Numerical operations
	`truncate-quotient`	Numerical operations
	`truncate-remainder`	Numerical operations
	`truncate/`	Numerical operations
	types	Semantics

U
	`u8-ready?`	Input
	`u8-ready?`	Input
	unbound identifier	Variables syntactic keywords and regions
	uninterned symbol	Symbols
	`unless`	Derived Conditionals
	`unquote`	Quasiquotation
	`unquote-splicing`	Quasiquotation
	unspecified values	Error situations and unspecified behavior
	`utf8->string`	Bytevectors
	`utf8->string`	Bytevectors
	`utf8->string`	Bytevectors

V
	valid index
	of a bytevector	Bytevectors
	of a string	Strings
	of a vector	Vectors
	`values`	Control features
	variable	Variables syntactic keywords and regions
	variable binding	Variables syntactic keywords and regions
	variable reference	Variable references
	`vector`	Vectors
	`vector->list`	Vectors
	`vector->list`	Vectors
	`vector->list`	Vectors
	`vector->string`	Vectors
	`vector->string`	Vectors
	`vector->string`	Vectors
	`vector-append`	Vectors
	`vector-copy`	Vectors
	`vector-copy`	Vectors
	`vector-copy`	Vectors
	`vector-copy!`	Vectors
	`vector-copy!`	Vectors
	`vector-copy!`	Vectors
	`vector-fill!`	Vectors
	`vector-fill!`	Vectors
	`vector-fill!`	Vectors
	`vector-for-each`	Control features
	`vector-length`	Vectors
	`vector-map`	Control features
	`vector-ref`	Vectors
	`vector-set!`	Vectors
	`vector?`	Vectors

W
	`when`	Derived Conditionals
	whitespace	Whitespace and comments
	`with-exception-handler`	Exceptions
	`with-input-from-file`	Ports
	`with-output-to-file`	Ports
	`write`	Output
	`write`	Output
	`write-bytevector`	Output
	`write-bytevector`	Output
	`write-bytevector`	Output
	`write-bytevector`	Output
	`write-char`	Output
	`write-char`	Output
	`write-shared`	Output
	`write-shared`	Output
	`write-simple`	Output
	`write-simple`	Output
	`write-string`	Output
	`write-string`	Output
	`write-string`	Output
	`write-string`	Output
	`write-u8`	Output
	`write-u8`	Output

X
	#x	Syntax of numerical constants

Z
	`zero?`	Numerical operations

Jump to:	_ - , ! ? . ' * / ` + < = > A B C D E F G H I J L M N O P Q R S T U V W X Z