Symbols

’

  macro character, 1

#

  macro character, 2

#\

  macro character, 3

"

  macrocharacter, 4

(

  macro character, 5

(setf class-name)

  function, 6

  generic function, 7

  primary method, 8

(setf documentation)

  generic function, 9

  primary method, 10, 11, 12, 13, 14, 15, 16

(setf generic-function-name)

  function, 17

(setf slot-value-using-class)

  generic function, 18

  primary method, 19, 20, 21

)

  macro character, 22

*

  function, 23

  variable, 24

**

  variable, 25

***

  variable, 26

*applyhook*

  variable, 27

*break-on-signals*

  variable, 28

*compile-file-pathname*

  variable, 29

*compile-file-truename*

  variable, 30

*compile-print*

  variable, 31

*compile-verbose*

  variable, 32

*debug-io*

  variable, 33

*debugger-hook*

  variable, 34

*default-pathname-defaults*

  variable, 35

*error-output*

  variable, 36

*evalhook*

  variable, 37

*features*

  variable, 38

*gensym-counter*

  variable, 39

*load-pathname*

  variable, 40

*load-print*

  variable, 41

*load-truename*

  variable, 42

*load-verbose*

  variable, 43

*macroexpand-hook*

  variable, 44

*package*

  variable, 45

*print-array*

  variable, 46

*print-base*

  variable, 47

*print-case*

  variable, 48

*print-circle*

  variable, 49

*print-escape*

  variable, 50

*print-gensym*

  variable, 51

*print-length*

  variable, 52

*print-level*

  variable, 53

*print-lines*

  variable, 54

*print-miser-width*

  variable, 55

*print-pprint-dispatch*

  variable, 56

*print-pretty*

  variable, 57

*print-radix*

  variable, 58

*print-readably*

  variable, 59

*print-right-margin*

  variable, 60

*query-io*

  variable, 61

*random-state*

  variable, 62

*read-base*

  variable, 63

*read-default-float-format*

  variable, 64

*read-eval*

  variable, 65

*read-suppress*

  variable, 66

*readtable*

  variable, 67

*sample-variable*

  variable, 68

*standard-input*

  variable, 69

*standard-output*

  variable, 70

*terminal-io*

  variable, 71

*trace-output*

  variable, 72

+

  function, 73

  variable, 74

++

  variable, 75

+++

  variable, 76

,

  macro character, 77

-

  function, 78

  variable, 79

/

  function, 80

  variable, 81

//

  variable, 82

///

  variable, 83

/=

  function, 84

;

  macro character, 85

;;

  macro character, 86

;;;

  macro character, 87

;;;;

  macro character, 88

<

  function, 89

<=

  function, 90

=

  function, 91

>

  function, 92

>=

  function, 93

‘

  macro character, 94

1+

  function, 95

1-

  function, 96

abort

  function, 97

abs

  function, 98

accessor-method-slot-definition

  generic function, 99, 100

  primary method, 101

acons

  function, 102

acos

  function, 103

acosh

  function, 104

add-dependent

  generic function, 105

  primary method, 106, 107, 108

add-direct-method

  generic function, 109

  primary method, 110, 111

add-direct-subclass

  generic function, 112

  primary method, 113

add-method

  generic function, 114

  generic function, 115

  primary method, 116

  primary method, 117

adjoin

  function, 118

adjust-array

  function, 119

adjustable-array-p

  function, 120

allocate-instance

  generic function, 121

  primary method, 122, 123, 124

alpha-char-p

  function, 125

alphanumericp

  function, 126

always

  loop clause, 127

and

  macro, 128

append

  function, 129

  loop clause, 130

appending

  loop clause, 131

apply

  function, 132

applyhook

  function, 133

apropos

  function, 134

apropos-list

  function, 135

aref

  function, 136

arithmetic-error

  type, 137

arithmetic-error-operands

  function, 138

arithmetic-error-operation

  function, 139

array, 140

array-dimension

  function, 141

array-dimension-limit

  constant, 142

array-dimensions

  function, 143

array-displacement

  function, 144

array-element-type

  function, 145

array-has-fill-pointer-p

  function, 146

array-in-bounds-p

  function, 147

array-rank

  function, 148

array-rank-limit

  constant, 149

array-row-major-index

  function, 150

array-total-size

  function, 151

array-total-size-limit

  constant, 152

arrayp

  function, 153

as

  loop clause, 154, 155, 156, 157, 158, 159, 160

ash

  function, 161

asin

  function, 162

asinh

  function, 163

assert

  macro, 164

assoc

  function, 165

assoc-if

  function, 166

assoc-if-not

  function, 167

atan

  function, 168

atanh

  function, 169

atom

  function, 170

augment-environment

  function, 171

bit

  function, 172

bit-and

  function, 173

bit-andc1

  function, 174

bit-andc2

  function, 175

bit-eqv

  function, 176

bit-ior

  function, 177

bit-nand

  function, 178

bit-nor

  function, 179

bit-not

  function, 180

bit-orc1

  function, 181

bit-orc2

  function, 182

bit-vector-p

  function, 183

bit-xor

  function, 184

block

  special operator, 185

boole

  function, 186

boole-1

  constant, 187

boole-2

  constant, 188

boole-and

  constant, 189

boole-andc1

  constant, 190

boole-andc2

  constant, 191

boole-c1

  constant, 192

boole-c2

  constant, 193

boole-clr

  constant, 194

boole-eqv

  constant, 195

boole-ior

  constant, 196

boole-nand

  constant, 197

boole-nor

  constant, 198

boole-orc1

  constant, 199

boole-orc2

  constant, 200

boole-set

  constant, 201

boole-xor

  constant, 202

both-case-p

  function, 203

boundp

  function, 204

break

  function, 205

broadcast-stream-streams

  function, 206

butlast

  function, 207

byte

  function, 208

byte-position

  function, 209

byte-size

  function, 210

caaaar

  function, 211

caaadr

  function, 212

caaar

  function, 213

caadar

  function, 214

caaddr

  function, 215

caadr

  function, 216

caar

  function, 217

cadaar

  function, 218

cadadr

  function, 219

cadar

  function, 220

caddar

  function, 221

cadddr

  function, 222

caddr

  function, 223

cadr

  function, 224

call-arguments-limit

  constant, 225

call-method

  macro, 226

call-next-method

  function, 227

car

  function, 228

case

  macro, 229

catch

  special operator, 230

ccase

  macro, 231

cdaaar

  function, 232

cdaadr

  function, 233

cdaar

  function, 234

cdadar

  function, 235

cdaddr

  function, 236

cdadr

  function, 237

cdar

  function, 238

cddaar

  function, 239

cddadr

  function, 240

cddar

  function, 241

cdddar

  function, 242

cddddr

  function, 243

cdddr

  function, 244

cddr

  function, 245

cdr

  function, 246

ceiling

  function, 247

cell-error

  type, 248

cell-error-name

  function, 249

cerror

  function, 250

change-class

  generic function, 251

  primary method, 252, 253

char

  function, 254

char-code

  function, 255

char-code-limit

  constant, 256

char-downcase

  function, 257

char-equal

  function, 258

char-greaterp

  function, 259

char-int

  function, 260

char-lessp

  function, 261

char-name

  function, 262

char-not-equal

  function, 263

char-not-greaterp

  function, 264

char-not-lessp

  function, 265

char-upcase

  function, 266

char/=

  function, 267

char<

  function, 268

char<=

  function, 269

char=

  function, 270

char>

  function, 271

char>=

  function, 272

character

  function, 273

characterp

  function, 274

check-type

  macro, 275

cis

  function, 276

class-default-initargs

  generic function, 277, 278

class-direct-default-initargs

  generic function, 279, 280

class-direct-slots

  generic function, 281, 282

class-direct-subclasses

  generic function, 283, 284

class-direct-superclasses

  generic function, 285, 286

class-finalized-p

  generic function, 287, 288

class-name

  generic function, 289, 290

  generic function, 291

  primary method, 292

class-of

  function, 293

class-precedence-list

  generic function, 294, 295

class-prototype

  generic function, 296, 297

class-slots

  generic function, 298

cleanup handler, 299

clear-input

  function, 300

clear-output

  function, 301

close

  function, 302

closure, 303

clrhash

  function, 304

code-char

  function, 305

coerce

  function, 306

collect

  loop clause, 307

collecting

  loop clause, 308

comments, 309

compile

  function, 310

compile-file

  function, 311

compile-file-pathname

  function, 312

compiled-function-p

  function, 313

compiler-macro-function

  function, 314

compiler-macroexpand

  function, 315

compiler-macroexpand-1

  function, 316

complement

  function, 317

complex

  function, 318

complexp

  function, 319

compute-applicable-methods

  function, 320

  generic function, 321

  primary method, 322

compute-applicable-methods-using-classes

  generic function, 323

  primary method, 324

compute-class-precedence-list

  generic function, 325

  primary method, 326

compute-default-initargs

  generic function, 327

  primary method, 328

compute-discriminating-function

  generic function, 329

  primary method, 330

compute-effective-method

  generic function, 331

  primary method, 332

compute-effective-slot-definition

  generic function, 333

  primary method, 334, 335

compute-restarts

  function, 336

compute-slots

  around method, 337, 338, 339

  generic function, 340

  primary method, 341, 342

concatenate

  function, 343

concatenated-stream-streams

  function, 344

cond

  macro, 345

condition

  type, 346

conjugate

  function, 347

cons, 348

  function, 349

consp

  function, 350

constantly

  function, 351

constantp

  function, 352

continue

  function, 353

control-error

  type, 354

copy-alist

  function, 355

copy-list

  function, 356

copy-pprint-dispatch

  function, 357

copy-readtable

  function, 358

copy-seq

  function, 359

copy-symbol

  function, 360

copy-tree

  function, 361

cos

  function, 362

cosh

  function, 363

count

  function, 364

  loop clause, 365

count-if

  function, 366

count-if-not

  function, 367

counting

  loop clause, 368

ctypecase

  macro, 369

decf

  macro, 370

declaim

  macro, 371

declaration-information

  function, 372

declare

  special operator, 373

decode-float

  function, 374

decode-universal-time

  function, 375

defclass

  macro, 376

defconstant

  macro, 377

defgeneric

  macro, 378

define-compiler-macro

  macro, 379

define-condition

  macro, 380

define-declaration

  macro, 381

define-method-combination

  macro, 382, 383

define-modify-macro

  macro, 384

define-setf-method

  macro, 385

define-symbol-macro

  macro, 386

defmacro

  macro, 387

defmethod

  macro, 388

defpackage

  macro, 389

defparameter

  macro, 390

defsetf

  macro, 391

defstruct

  macro, 392

deftype

  macro, 393

defun

  macro, 394

defvar

  macro, 395

delete

  function, 396

delete-duplicates

  function, 397

delete-file

  function, 398

delete-if

  function, 399

delete-if-not

  function, 400

delete-package

  function, 401

denominator

  function, 402

deposit-field

  function, 403

describe

  function, 404

describe-object

  generic function, 405

  primary method, 406

destructuring-bind

  macro, 407

digit-char

  function, 408

digit-char-p

  function, 409

direct-slot-definition-class

  generic function, 410

  primary method, 411, 412

directory

  function, 413

directory-namestring

  function, 414

disassemble

  function, 415

division-by-zero

  type, 416

do

  loop clause, 417

  macro, 418, 419

do*

  macro, 420, 421

do-all-symbols

  macro, 422

do-external-symbols

  macro, 423

do-symbols

  macro, 424

documentation

  generic function, 425

  primary method, 426, 427, 428, 429, 430, 431, 432

doing

  loop clause, 433

dolist

  macro, 434

dotimes

  macro, 435

double-float-epsilon

  constant, 436

double-float-negative-epsilon

  constant, 437

dpb

  function, 438

dribble

  function, 439

dynamic exit, 440

ecase

  macro, 441

echo-stream-input-stream

  function, 442

echo-stream-output-stream

  function, 443

ed

  function, 444

effective-slot-definition-class

  generic function, 445

  primary method, 446, 447

eighth

  function, 448

elt

  function, 449

enclose

  function, 450

encode-universal-time

  function, 451

end-of-file

  type, 452

endp

  function, 453

enough-namestring

  function, 454

ensure-class

  function, 455

ensure-class-using-class

  generic function, 456

  primary method, 457, 458, 459

ensure-directories-exist

  function, 460

ensure-generic-function

  function, 461, 462

ensure-generic-function-using-class

  generic function, 463

  primary method, 464, 465

eq

  function, 466

eql

  function, 467

eql-specializer-object

  function, 468

equal

  function, 469

equalp

  function, 470

error

  function, 471

  type, 472

etypecase

  macro, 473

eval

  function, 474

eval-when

  special operator, 475

evalhook

  function, 476

evenp

  function, 477

every

  function, 478

exp

  function, 479

export

  function, 480

expt

  function, 481

extract-lambda-list

  function, 482

extract-specializer-names

  function, 483

f

  generic function, 484

  primary method, 485

fboundp

  function, 486

fceiling

  function, 487

fdefinition

  function, 488

ffloor

  function, 489

fifth

  function, 490

file-author

  function, 491

file-error

  type, 492

file-error-pathname

  function, 493

file-length

  function, 494

file-namestring

  function, 495

file-position

  function, 496

file-string-length

  function, 497

file-write-date

  function, 498

fill

  function, 499

fill-pointer

  function, 500

finalize-inheritance

  generic function, 501

  primary method, 502, 503, 504

finally

  loop clause, 505, 506

find

  function, 507

find-all-symbols

  function, 508

find-class

  function, 509

find-if

  function, 510

find-if-not

  function, 511

find-method

  generic function, 512

  primary method, 513

find-method-combination

  generic function, 514

find-package

  function, 515

find-restart

  function, 516

find-symbol

  function, 517

finish-output

  function, 518

first

  function, 519

flet

  special operator, 520

float

  function, 521

float-digits

  function, 522

float-precision

  function, 523

float-radix

  function, 524

float-sign

  function, 525

floating-point-overflow

  type, 526

floating-point-underflow

  type, 527

floatp

  function, 528

floor

  function, 529

fmakunbound

  function, 530

for

  loop clause, 531, 532, 533, 534, 535, 536, 537

force-output

  function, 538

format

  function, 539

formatter

  macro, 540

fourth

  function, 541

fresh-line

  function, 542

fround

  function, 543

ftruncate

  function, 544

funcall

  function, 545

funcallable-standard-instance-access

  function, 546

function

  special operator, 547

function-information

  function, 548

function-keywords

  generic function, 549

  primary method, 550

function-lambda-expression

  function, 551

functionp

  function, 552

gcd

  function, 553

generic-function

  macro, 554

generic-function-argument-precedence-order

  generic function, 555, 556

  primary method, 557

generic-function-declarations

  generic function, 558, 559

  primary method, 560

generic-function-lambda-list

  generic function, 561, 562

  primary method, 563

generic-function-method-class

  generic function, 564

  primary method, 565

generic-function-method-combination

  generic function, 566, 567

  primary method, 568

generic-function-methods

  generic function, 569, 570

  primary method, 571

generic-function-name

  generic function, 572, 573

  primary method, 574

gensym

  function, 575

gentemp

  function, 576

get

  function, 577

get-decoded-time

  function, 578

get-dispatch-macro-character

  function, 579

get-internal-real-time

  function, 580

get-internal-run-time

  function, 581

get-macro-character

  function, 582

get-output-stream-string

  function, 583

get-properties

  function, 584

get-setf-method

  function, 585

get-setf-method-multiple-value

  function, 586

get-universal-time

  function, 587

getf

  function, 588

gethash

  function, 589

gf1

  generic function, 590

  primary method, 591

go

  special operator, 592

graphic-char-p

  function, 593

handler-bind

  macro, 594

handler-case

  macro, 595

hash-table-count

  function, 596

hash-table-p

  function, 597

hash-table-rehash-size

  function, 598

hash-table-rehash-threshold

  function, 599

hash-table-size

  function, 600

hash-table-test

  function, 601

host-namestring

  function, 602

identity

  function, 603

if

  loop clause, 604

  special operator, 605

ignore-errors

  macro, 606

imagpart

  function, 607

implicit progn, 608, 609

import

  function, 610

in-package

  macro, 611

incf

  macro, 612

initialize-instance

  generic function, 613

  primary method, 614

initially

  loop clause, 615

input-stream-p

  function, 616

inspect

  function, 617

integer, 618

integer-decode-float

  function, 619

integer-length

  function, 620

integerp

  function, 621

interactive-stream-p

  function, 622

intern

  function, 623

intern-eql-specializer

  function, 624

internal-time-units-per-second

  constant, 625

intersection

  function, 626

invalid-method-error

  function, 627

invoke-debugger

  function, 628

invoke-restart

  function, 629

invoke-restart-interactively

  function, 630

isqrt

  function, 631

iteration, 632

keywordp

  function, 633

labels

  special operator, 634

lambda

  macro, 635

lambda-expression, 636

lambda-list, 637

lambda-list-keywords

  constant, 638

lambda-parameters-limit

  constant, 639

last

  function, 640

lcm

  function, 641

ldb

  function, 642

ldb-test

  function, 643

ldiff

  function, 644

least-negative-double-float

  constant, 645

least-negative-long-float

  constant, 646

least-negative-normalized-double-float

  constant, 647

least-negative-normalized-long-float

  constant, 648

least-negative-normalized-short-float

  constant, 649

least-negative-normalized-single-float

  constant, 650

least-negative-short-float

  constant, 651

least-negative-single-float

  constant, 652

least-positive-double-float

  constant, 653

least-positive-long-float

  constant, 654

least-positive-normalized-double-float

  constant, 655

least-positive-normalized-long-float

  constant, 656

least-positive-normalized-short-float

  constant, 657

least-positive-normalized-single-float

  constant, 658

least-positive-short-float

  constant, 659

least-positive-single-float

  constant, 660

length

  function, 661

let

  special operator, 662

let*

  special operator, 663

lisp-implementation-type

  function, 664

lisp-implementation-version

  function, 665

list

  function, 666

list*

  function, 667

list-all-packages

  function, 668

list-length

  function, 669

listen

  function, 670

listp

  function, 671

load

  function, 672

load-logical-pathname-translations

  function, 673

load-time-value

  special operator, 674

locally

  special operator, 675

log

  function, 676

logand

  function, 677

logandc1

  function, 678

logandc2

  function, 679

logbitp

  function, 680

logcount

  function, 681

logeqv

  function, 682

logical-pathname

  class, 683

  function, 684

logical-pathname-translations

  function, 685

logior

  function, 686

lognand

  function, 687

lognor

  function, 688

lognot

  function, 689

logorc1

  function, 690

logorc2

  function, 691

logtest

  function, 692

logxor

  function, 693

long-float-epsilon

  constant, 694

long-float-negative-epsilon

  constant, 695

long-site-name

  function, 696

loop

  macro, 697

loop-finish

  macro, 698

lower-case-p

  function, 699

machine-instance

  function, 700

machine-type

  function, 701

machine-version

  function, 702

macro character, 703

macro-function

  function, 704

macroexpand

  function, 705

macroexpand-1

  function, 706

macrolet

  special operator, 707

make-array

  function, 708

make-broadcast-stream

  function, 709

make-concatenated-stream

  function, 710

make-condition

  function, 711

make-dispatch-macro-character

  function, 712

make-echo-stream

  function, 713

make-hash-table

  function, 714

make-instance

  generic function, 715

  generic function, 716

  primary method, 717, 718

  primary method, 719, 720

make-instances-obsolete

  generic function, 721

  primary method, 722, 723

make-list

  function, 724

make-load-form

  generic function, 725

make-load-form-saving-slots

  function, 726

make-method-lambda

  generic function, 727

  primary method, 728

make-package

  function, 729

make-pathname

  function, 730

make-random-state

  function, 731

make-sequence

  function, 732

make-string

  function, 733

make-string-input-stream

  function, 734

make-string-output-stream

  function, 735

make-symbol

  function, 736

make-synonym-stream

  function, 737

make-two-way-stream

  function, 738

makunbound

  function, 739

map

  function, 740

map-dependents

  generic function, 741

  primary method, 742, 743, 744

map-into

  function, 745

mapc

  function, 746

mapcan

  function, 747

mapcar

  function, 748

mapcon

  function, 749

maphash

  function, 750

mapl

  function, 751

maplist

  function, 752

mapping, 753

mask-field

  function, 754

max

  function, 755

maximize

  loop clause, 756

maximizing

  loop clause, 757

member

  function, 758

member-if

  function, 759

member-if-not

  function, 760

merge

  function, 761

merge-pathnames

  function, 762

method-combination-error

  function, 763

method-function

  generic function, 764, 765

  primary method, 766

method-generic-function

  generic function, 767, 768

  primary method, 769

method-lambda-list

  generic function, 770, 771

  primary method, 772

method-qualifiers

  generic function, 773, 774

  generic function, 775

  primary method, 776

  primary method, 777

method-specializers

  generic function, 778, 779

  primary method, 780

min

  function, 781

minimize

  loop clause, 782

minimizing

  loop clause, 783

minusp

  function, 784

mismatch

  function, 785

mod

  function, 786

most-negative-double-float

  constant, 787

most-negative-fixnum

  constant, 788

most-negative-long-float

  constant, 789

most-negative-short-float

  constant, 790

most-negative-single-float

  constant, 791

most-positive-double-float

  constant, 792

most-positive-fixnum

  constant, 793

most-positive-long-float

  constant, 794

most-positive-short-float

  constant, 795

most-positive-single-float

  constant, 796

muffle-warning

  function, 797

multiple values, 798

multiple-value-bind

  macro, 799

multiple-value-call

  special operator, 800

multiple-value-list

  macro, 801

multiple-value-prog1

  special operator, 802

multiple-value-setq

  macro, 803

multiple-values-limit

  constant, 804

name-char

  function, 805

named

  loop clause, 806

namestring

  function, 807

nbutlast

  function, 808

nconc

  function, 809

  loop clause, 810

nconcing

  loop clause, 811

never

  loop clause, 812

next-method-p

  function, 813

nil

  constant, 814

nintersection

  function, 815

ninth

  function, 816

no-applicable-method

  generic function, 817

  primary method, 818

no-next-method

  generic function, 819

  primary method, 820

non-local exit, 821

not

  function, 822

notany

  function, 823

notevery

  function, 824

nreconc

  function, 825

nreverse

  function, 826

nset-difference

  function, 827

nset-exclusive-or

  function, 828

nstring-capitalize

  function, 829

nstring-downcase

  function, 830

nstring-upcase

  function, 831

nsublis

  function, 832

nsubst

  function, 833

nsubst-if

  function, 834

nsubst-if-not

  function, 835

nsubstitute

  function, 836

nsubstitute-if

  function, 837

nsubstitute-if-not

  function, 838

nth

  function, 839

nth-value

  macro, 840

nthcdr

  function, 841

null

  function, 842

numberp

  function, 843

numerator

  function, 844

nunion

  function, 845

oddp

  function, 846

open

  function, 847

open-stream-p

  function, 848

or

  macro, 849

output-stream-p

  function, 850

package-error

  type, 851

package-error-package

  function, 852

package-name

  function, 853

package-nicknames

  function, 854

package-shadowing-symbols

  function, 855

package-use-list

  function, 856

package-used-by-list

  function, 857

packagep

  function, 858

pairlis

  function, 859

parse-integer

  function, 860

parse-macro

  function, 861

parse-namestring

  function, 862

parsing, 863

pathname

  function, 864

pathname-device

  function, 865

pathname-directory

  function, 866

pathname-host

  function, 867

pathname-match-p

  function, 868

pathname-name

  function, 869

pathname-type

  function, 870

pathname-version

  function, 871

pathnamep

  function, 872

peek-char

  function, 873

phase

  function, 874

pi

  constant, 875

plusp

  function, 876

pop

  macro, 877

position

  function, 878

position-if

  function, 879

position-if-not

  function, 880

pprint

  function, 881

pprint-dispatch

  function, 882

pprint-exit-if-list-exhausted

  macro, 883

pprint-fill

  function, 884

pprint-indent

  function, 885

pprint-linear

  function, 886

pprint-logical-block

  macro, 887

pprint-newline

  function, 888

pprint-pop

  macro, 889

pprint-tab

  function, 890

pprint-tabular

  function, 891

prin1

  function, 892

prin1-to-string

  function, 893

princ

  function, 894

princ-to-string

  function, 895

print

  function, 896

print name, 897

print-object

  generic function, 898

  primary method, 899

print-unreadable-object

  macro, 900

printed representation, 901, 902

printer, 903, 904

probe-file

  function, 905

proclaim

  function, 906

prog

  macro, 907

prog*

  macro, 908

prog1

  macro, 909

prog2

  macro, 910

progn

  special operator, 911

program-error

  type, 912

progv

  special operator, 913

psetf

  macro, 914

psetq

  macro, 915

push

  macro, 916

pushnew

  macro, 917

quote

  special operator, 918

random

  function, 919

random-state-p

  function, 920

rassoc

  function, 921

rassoc-if

  function, 922

rassoc-if-not

  function, 923

ratio, 924

rational, 925

  function, 926

rationalize

  function, 927

rationalp

  function, 928

read

  function, 929

read-byte

  function, 930

read-char

  function, 931

read-char-no-hang

  function, 932

read-delimited-list

  function, 933

read-from-string

  function, 934

read-line

  function, 935

read-preserving-whitespace

  function, 936

read-sequence

  function, 937

reader, 938, 939, 940

reader-method-class

  generic function, 941

  primary method, 942, 943

readtable-case

  function, 944

readtablep

  function, 945

realp

  function, 946

realpart

  function, 947

reduce

  function, 948

reinitialize-instance

  generic function, 949

  primary method, 950

rem

  function, 951

remf

  macro, 952

remhash

  function, 953

remove

  function, 954

remove-dependent

  generic function, 955

  primary method, 956, 957, 958

remove-direct-method

  generic function, 959

  primary method, 960, 961

remove-direct-subclass

  generic function, 962

  primary method, 963

remove-duplicates

  function, 964

remove-if

  function, 965

remove-if-not

  function, 966

remove-method

  generic function, 967

  generic function, 968

  primary method, 969

  primary method, 970

remprop

  function, 971

rename-file

  function, 972

rename-package

  function, 973

repeat

  loop clause, 974

replace

  function, 975

rest

  function, 976

restart

  type, 977

restart-bind

  macro, 978

restart-case

  macro, 979

restart-name

  function, 980

return

  loop clause, 981

  macro, 982

return-from

  special operator, 983

revappend

  function, 984

reverse

  function, 985

room

  function, 986

rotatef

  macro, 987

round

  function, 988

row-major-aref

  function, 989

rplaca

  function, 990

rplacd

  function, 991

sample-constant

  constant, 992

sample-function

  function, 993

sample-macro

  macro, 994

sample-special-form

  special operator, 995

sbit

  function, 996

scale-float

  function, 997

schar

  function, 998

search

  function, 999

second

  function, 1000

serious-condition

  type, 1001

set

  function, 1002

set-difference

  function, 1003

set-dispatch-macro-character

  function, 1004

set-exclusive-or

  function, 1005

set-funcallable-instance-function

  function, 1006

set-macro-character

  function, 1007

set-pprint-dispatch

  function, 1008

set-syntax-from-char

  function, 1009

setf

  macro, 1010

setq

  special operator, 1011

seventh

  function, 1012

shadow

  function, 1013

shadowing-import

  function, 1014

shared-initialize

  generic function, 1015

  primary method, 1016

shiftf

  macro, 1017

short-float-epsilon

  constant, 1018

short-float-negative-epsilon

  constant, 1019

short-site-name

  function, 1020

signal

  function, 1021

signum

  function, 1022

simple-bit-vector-p

  function, 1023

simple-condition

  type, 1024

simple-condition-format-arguments

  function, 1025

simple-condition-format-control

  function, 1026

simple-error

  type, 1027

simple-string-p

  function, 1028

simple-type-error

  type, 1029

simple-vector-p

  function, 1030

simple-warning

  type, 1031

sin

  function, 1032

single-float-epsilon

  constant, 1033

single-float-negative-epsilon

  constant, 1034

sinh

  function, 1035

sixth

  function, 1036

sleep

  function, 1037

slot-boundp

  function, 1038

slot-boundp-using-class

  generic function, 1039

  primary method, 1040, 1041, 1042

slot-definition-allocation

  generic function, 1043, 1044

  primary method, 1045

slot-definition-initargs

  generic function, 1046, 1047

  primary method, 1048

slot-definition-initform

  generic function, 1049, 1050

  primary method, 1051

slot-definition-initfunction

  generic function, 1052, 1053

  primary method, 1054

slot-definition-location

  generic function, 1055, 1056

  primary method, 1057

slot-definition-name

  generic function, 1058, 1059

  primary method, 1060

slot-definition-readers

  generic function, 1061, 1062

  primary method, 1063

slot-definition-type

  generic function, 1064, 1065

  primary method, 1066

slot-definition-writers

  generic function, 1067, 1068

  primary method, 1069

slot-exists-p

  function, 1070

slot-makunbound

  function, 1071

slot-makunbound-using-class

  generic function, 1072

  primary method, 1073, 1074, 1075

slot-missing

  generic function, 1076

  primary method, 1077

slot-unbound

  generic function, 1078

  primary method, 1079

slot-value

  function, 1080

slot-value-using-class

  generic function, 1081

  primary method, 1082, 1083, 1084

software-type

  function, 1085

software-version

  function, 1086

some

  function, 1087

sort

  function, 1088

sorting, 1089

special-operator-p

  function, 1090

specializer-direct-generic-functions

  generic function, 1091

  primary method, 1092, 1093

specializer-direct-methods

  generic function, 1094

  primary method, 1095, 1096

sqrt

  function, 1097

stable-sort

  function, 1098

standard-char-p

  function, 1099

standard-instance-access

  function, 1100

step

  macro, 1101

storage-condition

  type, 1102

store-value

  function, 1103

stream-element-type

  function, 1104

stream-error

  type, 1105

stream-error-stream

  function, 1106

stream-external-format

  function, 1107

streamp

  function, 1108

string

  function, 1109

string-capitalize

  function, 1110

string-downcase

  function, 1111

string-equal

  function, 1112

string-greaterp

  function, 1113

string-left-trim

  function, 1114

string-lessp

  function, 1115

string-not-equal

  function, 1116

string-not-greaterp

  function, 1117

string-not-lessp

  function, 1118

string-right-trim

  function, 1119

string-trim

  function, 1120

string-upcase

  function, 1121

string/=

  function, 1122

string<

  function, 1123

string<=

  function, 1124

string=

  function, 1125

string>

  function, 1126

string>=

  function, 1127

stringp

  function, 1128

sublis

  function, 1129

subseq

  function, 1130

subsetp

  function, 1131

subst

  function, 1132

subst-if

  function, 1133

subst-if-not

  function, 1134

substitute

  function, 1135

substitute-if

  function, 1136

substitute-if-not

  function, 1137

substitution, 1138

subtypep

  function, 1139

sum

  loop clause, 1140

summing

  loop clause, 1141

svref

  function, 1142

sxhash

  function, 1143

symbol-function

  function, 1144

symbol-macrolet

  special operator, 1145

symbol-name

  function, 1146

symbol-package

  function, 1147

symbol-plist

  function, 1148

symbol-value

  function, 1149

symbolp

  function, 1150

synonym-stream-symbol

  function, 1151

t

  constant, 1152

tagbody

  special operator, 1153

tailp

  function, 1154

tan

  function, 1155

tanh

  function, 1156

tenth

  function, 1157

terpri

  function, 1158

the

  special operator, 1159

thereis

  loop clause, 1160

third

  function, 1161

throw

  special operator, 1162

time

  macro, 1163

trace

  macro, 1164

translate-logical-pathname

  function, 1165

translate-pathname

  function, 1166

tree-equal

  function, 1167

truename

  function, 1168

truncate

  function, 1169

two-way-stream-input-stream

  function, 1170

two-way-stream-output-stream

  function, 1171

type-error

  type, 1172

type-error-datum

  function, 1173

type-error-expected-type

  function, 1174

type-of

  function, 1175

typecase

  macro, 1176

typep

  function, 1177

unbound-variable

  type, 1178

undefined-function

  type, 1179

unexport

  function, 1180

unintern

  function, 1181

union

  function, 1182

unless

  loop clause, 1183

  macro, 1184

unread-char

  function, 1185

until

  loop clause, 1186

untrace

  macro, 1187

unuse-package

  function, 1188

unwind protection, 1189

unwind-protect

  special operator, 1190

update-dependent

  generic function, 1191

update-instance-for-different-class

  generic function, 1192

  primary method, 1193

update-instance-for-redefined-class

  generic function, 1194

  primary method, 1195

upgraded-array-element-type

  function, 1196

upgraded-complex-part-type

  function, 1197

upper-case-p

  function, 1198

use-package

  function, 1199

use-value

  function, 1200

user-homedir-pathname

  function, 1201

validate-superclass

  generic function, 1202

  primary method, 1203

values

  function, 1204

values-list

  function, 1205

variable-information

  function, 1206

vector

  function, 1207

vector-pop

  function, 1208

vector-push

  function, 1209

vector-push-extend

  function, 1210

vectorp

  function, 1211

warn

  function, 1212

warning

  type, 1213

when

  loop clause, 1214

  macro, 1215

while

  loop clause, 1216

wild-pathname-p

  function, 1217

with

  loop clause, 1218

with-accessors

  macro, 1219

with-compilation-unit

  macro, 1220

with-condition-restarts

  macro, 1221

with-hash-table-iterator

  macro, 1222

with-input-from-string

  macro, 1223

with-open-file

  macro, 1224

with-open-stream

  macro, 1225

with-output-to-string

  macro, 1226

with-package-iterator

  macro, 1227

with-simple-restart

  macro, 1228

with-slots

  macro, 1229

with-standard-io-syntax

  macro, 1230

write

  function, 1231

write-byte

  function, 1232

write-char

  function, 1233

write-line

  function, 1234

write-sequence

  function, 1235

write-string

  function, 1236

write-to-string

  function, 1237

writer-method-class

  generic function, 1238

  primary method, 1239, 1240

y-or-n-p

  function, 1241

yes-or-no-p

  function, 1242

zerop

  function, 1243