[Next] [Previous] [Top] [Contents]

Dylan Reference Manual

Index



[Symbols]

~ 
| 
:= 
!, function name convention 
*, variable name convention 
., slot reference syntax [1] [2]
= 
== 
> 
>= 
\ 
~ 
~= 
~== 
^ 
"..."
'...' 
#"..." 
#-word 
#f 
#t 
$, constant name convention 
& 
+ 
- 
/ 
/*...*/ 
// 
?, predicate name convention 
<...>, class name convention 
<= 
< 
<abort>
<array>
<boolean>
<byte-string>
<character>
<class>
<collection>
<complex>
<condition>
<deque>
<double-float>
<empty-list>
<error>
<explicit-key-collection>
<extended-float>
<float>
<function>
<generic-function>
<integer>
<list>
<method>
<mutable-collection>
<mutable-explicit-key-collection>
<mutable-sequence>
<number>
<object>
<object-table>
<pair>
<range>
<rational>
<real>
<restart>
<sealed-object-error>
<sequence>
<serious-condition>
<simple-error>
<simple-object-vector>
<simple-restart>
<simple-vector>
<simple-warning>
<single-float>
<singleton>
<stretchy-collection> 
<stretchy-vector>
<string>
<symbol>
<table>
<type>
<type-error>
<unicode-string>
<vector>
<warning>


[A]
abort 
abs 
abstract class 
accept a variable number of arguments 
accept all keyword arguments 
accept keyword arguments 
accessible bindings 
add 
add! 
add-method 
add-new 
add-new! 
all-superclasses 
alphabetic character 
altering a collection 
always 
ambiguous methods 
any? 
applicable-method? 
apply 
aref 
aref-setter 
as 
as-lowercase 
as-lowercase! 
as-uppercase 
as-uppercase! 
ash 

[B]
backward-iteration-protocol 
base type 
binary operator call 
binding 
body 
break 
built-in defining macro 
built-in statement macro 

[C]
case 
ceiling 
ceiling/ 
cerror 
character literal 
check-type 
choose 
choose-by 
class precedence list 
closed over 
closure 
code body 
collection alignment 
collection keys 
comment 
complement 
compose 
concatenate 
concatenate-as 
concrete class 
condition 
condition handler establishing 
condition-format-arguments 
condition-format-string 
congruent parameter lists 
conjoin 
constant 
constituent 
copy-sequence 
curry 

[D]
default-handler 
defaulted initialization arguments 
define class 
define constant 
define generic 
define inert domain 
define library 
define macro 
define method 
define module 
define variable 
definition 
delimited comment 
destructively modify 
dimension 
dimensions 
direct instance 
direct subclass 
direct superclass 
direct-subclasses 
direct-superclasses 
disjoin 
disjoint 
do 
do-handlers 

[E]
element 
element reference 
element type 
element-setter 
elements 
empty? 
equivalence class 
equivalence predicate 
equivalent types 
error 
even? 
every? 
exit 
explicit definition 
explicit key collection 
explicitly known 
exported bindings 
expression 

[F]
file header 
fill! 
find-key 
find-method 
first 
first-setter 
floor 
floor/ 
for 
format arguments 
format directives 
format strings 
forward-iteration-protocol 
free class 
freshly allocated collection 
function call 
function-arguments 
function-return-values 
function-specializers 

[G]
gcd 
general subclass 
general superclass 
generic-function-mandatory-keywords 
generic-function-methods 
getter 
getter method 
graphic character 

[H]
handler 
hash codes 
hash function 
hash id 
hash state 
head 
head-setter 
hygienic 

[I]
identity 
if 
implicit definition 
imported bindings 
indirect subclass 
init expression 
init function 
init specification 
init value 
initialization argument 
initialization protocol 
initialize 
inside stack 
instance? 
instantiable class 
integral? 
interchange format 
intersection 
iteration protocol 

[K]
key test 
key-sequence 
key-test 
keys of collections 
keyword 
keyword initializable 
keyword parameters 

[L]
last 
last-setter 
lcm 
let 
let handler 
libraries 
limited 
list 
literal constant 
local 
local declaration 
local method bindings 
local precedence order 
Local precedence order constraint 
local value bindings 
logand 
logbit? 
logior 
lognot 
logxor 

[M]
macro [1] [2]
make 
mandatory keywords 
map 
map-as 
map-into 
max 
member? 
merge-hash-codes 
method 
method dispatch 
middle stack 
min 
module 
modulo 
monotonicity constraint 
more specific method 
multiple values 

[N]
name 
name character 
named value reference 
natural order 
negative 
negative? 
next-method 
next-method parameter 
not, logical 
number 
numeric character 

[O]
object-class 
object-hash 
odd? 
open class 
operand 
operator 
outside stack 
owned module binding 

[P]
pair 
parameter list [1] [2]
parenthesized expression 
permit keywords 
pop 
pop-last 
positive? 
precede in a class precedence list 
primary class 
program 
proper subtype 
pseudosubtype 
punctuation 
push 
push-last 

[R]
range 
rank 
rcurry 
recognize keywords 
recovery 
recovery protocol 
reduce 
reduce1 
remainder 
remove 
remove! 
remove-duplicates 
remove-duplicates! 
remove-key! 
remove-method 
replace-elements! 
replace-subsequence! 
require a fixed number of arguments 
required parameters 
required value declaration 
reserved word 
rest parameters 
rest value declaration 
restart-query 
restarting 
return type declarations 
return-allowed 
return-description 
return-query 
reverse 
reverse! 
round 
round/ 
row-major-index 

[S]
sealed class 
sealing 
sealing directives 
second 
second-setter 
select 
sequence 
setter 
setter method 
shallow-copy 
signal 
signaler 
signaling unit 
single-line comment 
singleton 
singleton specializers 
size 
size-setter 
slot reference 
slot-initialized? 
slots 
sort 
sort! 
sorted-applicable-methods 
source record 
special definition 
specialize 
specialized 
stable under iteration 
statement 
statement macro 
string literal [1] [2]
subsequence-position 
subtype? 
supplied initialization arguments 
symbol literal 

[T]
table-protocol 
tail 
tail-setter 
third 
third-setter 
token 
top level 
truncate 
truncate/ 
type-error-expected-type 
type-error-value 
type-for-copy 

[U]
unary operator call 
uninstantiable  class 
union 
unique string 
unless 
unstable under iteration 
until 
user-defined defining macro 
user-defined statement macro 
using a module 

[V]
value type 
values 
variable 
vector 
visibly modified 

[W]
while 
whitespace 

[Z]
zero? 


Dylan Reference Manual - 17 OCT 1995
[Next] [Previous] [Top] [Contents]

Generated with Harlequin WebMaker