Index

A note on the digital index

A link in an index entry is displayed as the section title in which that entry appears. Because some sections have multiple index markers, it is not unusual for an entry to have several links to the same section. Clicking on any link will take you directly to the place in the text in which the marker appears.

Symbols

#S prefix, for structures, Working with Structures, Working with Structures
# ewline, Starting with print and read, Starting with print and read
#space, Starting with print and read, Starting with print and read
# ab, Starting with print and read, Starting with print and read
&body keyword, How Macros Are Transformed, How Macros Are Transformed
() parentheses, The Guess-My-Number Game, An Alternative Global Variable Definition Function, An Alternative Global Variable Definition Function, Basic Lisp Etiquette, Defining the start-over Function, The Building Blocks of Lisp Syntax, Making Decisions with Conditions
empty lists, Basic Lisp Etiquette, Making Decisions with Conditions
symmetry of nil and, Making Decisions with Conditions
for calling commands and functions, The Guess-My-Number Game, An Alternative Global Variable Definition Function
for list of declared variables in let, Defining the start-over Function
for organizing code into lists, The Building Blocks of Lisp Syntax
*board-scale* variable, Drawing a Tile, Drawing a Tile
*dice-scale* variable, Drawing the Game Board Using the SVG Format, Drawing the Game Board Using the SVG Format
*from-tile* variable, Handling the Human Player, Handling the Human Player
*num-players* variable, Increasing the Number of Players, Increasing the Number of Players
*print-circle* variable, Circular Lists, Circular Lists
*standard-output* variable, Building a More Complicated SVG Example, Building a More Complicated SVG Example
*top-offset* variable, Drawing the Game Board Using the SVG Format, Drawing the Game Board Using the SVG Format
404 error page, Building a Dynamic Website
:@ flag, for columns in tables, Justifying Output
:if-exists keyword parameter, Working with Files, Working with Files
:initial-value keyword parameter, Sequence Functions for Iterating Across a Sequence, Sequence Functions for Iterating Across a Sequence
:junk-allowed parameter, Decoding the Values of Request Parameters, Decoding the Values of Request Parameters
:pretty parameter, Converting Node Identifiers, Converting Node Identifiers
:radix parameter, Decoding the Values of Request Parameters, Decoding the Values of Request Parameters
:test keyword parameter, The edges-to-alist Function, The edges-to-alist Function, Growing Plants in Our World, Growing Plants in Our World
to use equal, Growing Plants in Our World, Growing Plants in Our World
˜$ control sequence, The Control String Parameter, Control Sequences for Formatting Floating-Point Numbers
˜% control sequence, Printing Multiple Lines of Output
˜& control sequence, Printing Multiple Lines of Output
˜:; control sequence, Iterating Through Lists Using Control Sequences
˜< control sequence, Justifying Output
˜> control sequence, Justifying Output
˜a control sequence, The Control String Parameter, The Control String Parameter
˜b control sequence, Control Sequences for Formatting Numbers, Control Sequences for Formatting Numbers
˜d control sequence, Control Sequences for Formatting Numbers, Control Sequences for Formatting Numbers
˜f control sequence, Control Sequences for Formatting Floating-Point Numbers, Control Sequences for Formatting Floating-Point Numbers
˜t control sequence, Printing Multiple Lines of Output, Printing Multiple Lines of Output
˜x control sequence, Control Sequences for Formatting Numbers, Control Sequences for Formatting Numbers
˜{ control sequence, Justifying Output
˜} control sequence, Justifying Output

A

ab-get-ratings-max function, Alpha Beta Pruning
ab-get-ratings-min function, Alpha Beta Pruning
ab-rate-position function, Alpha Beta Pruning
academic research, Where Did Lisp Come From?
accum function, Brevity Guild Micro Fighter
accumulator, Tail Call Optimization
across in loop macro, Using Multiple for Clauses, Determining the Winner
add function, predicates in, Creating Your Own Generic Functions with Type Predicates
add-cops function, Building the Final Edges for Congestion City, The edges-to-alist Function
add-new-dice function, Finding the Neighbors, Tail Call Optimization, Improving the Dice of Doom Reinforcement Rules
add-passing-move function, Generating a Game Tree, Mapping and Searching Across Lazy Lists
add-plants function, Growing Plants in Our World, Handling Animal Reproduction
add-two function, Code Composition with Imperative Code
add-widget function, Anatomy of a Program Written in the Functional Style, Anatomy of a Program Written in the Functional Style
AI (artificial intelligence), Where Did Lisp Come From?
alists. See association lists (alists), ANSI Common Lisp
Allegro Common Lisp, Getting Started with CLISP
alpha beta pruning, Winning by a Lot vs. Winning by a Little, Updating the AI
and chance nodes, Updating the AI
alphanumericp function, Converting Node Identifiers
always in loop macro, Using Multiple for Clauses
Amazon S3, Returning Multiple Values
anaphoric macros, A Macro for Splitting Lists
and in loop macro, Using Multiple for Clauses
and operator, Branching with case
announce-winner function, Determining the Winner
ANSI Common Lisp (CL), Getting Started with Lisp, A Tale of Two Lisps
append function, Converting the Edges to Descriptions, Converting the Edges to Descriptions, Building the Nodes for Congestion City
append in loop macro, Using Multiple for Clauses
apply function, Converting the Edges to Descriptions
apt-get install clisp, Installing CLISP
ARC assembly, Where Did Lisp Come From?
Arc Lisp dialect, A Tale of Two Lisps, Creating the tag Macro, How It Kills Bugs
aref function, Working with Arrays, Using a Generic Setter
and performance, Using a Generic Setter
arrayp function, Sequence Functions for Iterating Across a Sequence
arrays, Advanced Datatypes and Generic Programming, Using a Generic Setter, When to Use Structures, Sequence Functions for Iterating Across a Sequence, Global Variables for the Player and Monsters
for monsters, Global Variables for the Player and Monsters
sequence functions for, When to Use Structures
sum function for, Sequence Functions for Iterating Across a Sequence
vs. lists, Using a Generic Setter
artificial intelligence (AI), Where Did Lisp Come From?
as in loop macro, Using Multiple for Clauses
ASCII code, Decoding the Values of Request Parameters, Representing the Game Board
code-char function to convert, Representing the Game Board
ash (arithmetic shift) function, Basic Lisp Etiquette
assemblers, Where Did Lisp Come From?
assembly languages, Where Did Lisp Come From?
assoc function, Describing the Scenery with an Association List, Picking Up Objects, Association Lists
association lists (alists), Basic Requirements, Circular Lists, The edges-to-alist Function, The add-cops Function, The add-cops Function, Drawing a City from Partial Knowledge, Working with Files, Decoding Lists of Request Parameters, Creating the tag Macro
attributes for print-tag, Creating the tag Macro
for nodes in city, The add-cops Function
for scenery description, Basic Requirements
nested, The add-cops Function
of known nodes, Drawing a City from Partial Knowledge
web request parameters in, Decoding Lists of Request Parameters
writing to file, Working with Files
* (asterisk), in variable names, The Guess-My-Number Game
asterisk (*), in variable names, The Guess-My-Number Game
@ (at), in control sequence parameters, The Control String Parameter
at (@), in control sequence parameters, The Control String Parameter
at-loc-p function, Listing Visible Objects
Attack of the Robots! game, A Crazy Formatting Trick for Creating Pretty Tables of Data
attacking-moves function, Calculating Passing Moves, Dice of Doom, Version 2, Building Chance Nodes
Autocode, Where Did Lisp Come From?

B

` (backquote), Describing the Paths, How Macros Are Transformed
for enabling switching from data to code mode, Describing the Paths
backquote (`), Describing the Paths, How Macros Are Transformed
for enabling switching from data to code mode, Describing the Paths
(backslash), for escaped characters, Numbers
backslash (), for escaped characters, Numbers
below in loop macro, The loop Macro
bidirectional stream, Sending a Message over a Socket
bigger function, Defining the guess-my-number Function
binary search, The Guess-My-Number Game, Defining the guess-my-number Function
binary, number display as, Control Sequences for Formatting Numbers
blocking operation, Sending a Message over a Socket
board-array function, Representing the Game Board
board-attack function, Finding the Neighbors
board-attack-fail function, Building Chance Nodes
Boolean values, manipulating, Branching with case
branching, The Command That Does It All: cond, The Command That Does It All: cond
with case form, The Command That Does It All: cond
breaking out of loop, Breaking out of a Loop Early
brevity of code, Brevity Guild Micro Fighter
brightness function, Using the tag Macro to Generate HTML
bug fighters, Epilogue, Synopsis, Synopsis, Synopsis, Synopsis, Synopsis, CLOS Guild Battleship, Synopsis, Multicore Guild Formation Fighters, Multicore Guild Formation Fighters, Lisp Dialect
Clojure Lisp, Multicore Guild Formation Fighters
comic book, Epilogue
Common Lisp Object System (CLOS), CLOS Guild Battleship
continuations, Synopsis
domain-specific language, Synopsis
exception handling, Synopsis
functional programming, Synopsis
generic setters, Synopsis
lazy evaluation, Lisp Dialect
macros, Synopsis
bugs, functional programming to reduce, Why Functional Programming Is Crazy
by in loop macro, Using Multiple for Clauses

C

C++ language, Where Did Lisp Come From?, Where Does Lisp Get Its Power?, Syntax and Semantics, The Magic of Lisp Macros
#define directive, The Magic of Lisp Macros
cache misses, performance impact, Returning Multiple Values
cached results, clearing, Alpha Beta Pruning
cadadar function, Nested Lists
cadadr function, Nested Lists
cadr function, The cons Function
calc-pt function, Drawing the Game Board Using the SVG Format
capitalized text, converting all caps to, Writing a game-print Function
capturing console output, Capturing the Console Output
car function, The cons Function, Converting the Edges to Descriptions
case form, branching with, The Command That Does It All: cond
case of text, adjusting, Writing a game-print Function
case-insensitivity, of symbols, The Building Blocks of Lisp Syntax
case-sensitive symbols, Starting with print and read
cdr function, The cons Function, Building the Nodes for Congestion City
cells, retrieving item from first slot, The cons Function
centered columns, Justifying Output
chain of cons cells, The cons Function, Exotic Lists
chance nodes, in game tree, Increasing the Number of Players
char-downcase function, Writing a game-print Function
char-equal function, Comparing Stuff: eq, equal, and More
char-upcase function, Writing a game-print Function
characterp function, Sequence Functions for Iterating Across a Sequence
characters, Comparing Stuff: eq, equal, and More, Comparing Stuff: eq, equal, and More, Starting with print and read, Control Sequences for Formatting Numbers
comparison, Comparing Stuff: eq, equal, and More
for padding numbers, Control Sequences for Formatting Numbers
literal, Starting with print and read
charge function, Let's Hunt Some Wumpus!
chosen-tile parameter, Drawing the Board
Church, Alonzo, What Is Functional Programming?
circle function, Creating SVG-Specific Macros and Functions
circular lists, Pairs
CISC (complex instruction set computer), Where Did Lisp Come From?
city.dot.png picture, Initializing a New Game of Grand Theft Wumpus
CL (Common Lisp), Getting Started with Lisp, A Tale of Two Lisps, Tail Call Optimization, Functional Guild Cruiser
basics, Functional Guild Cruiser
tail call optimization support, Tail Call Optimization
cl-sockets, Working with Sockets
client, for socket connection, Socket Connections
CLISP, ANSI Common Lisp, Getting Started with CLISP, Starting Up CLISP, Starting Up CLISP, Circular Lists
installing, ANSI Common Lisp
printing of circular lists, Circular Lists
shutting down, Starting Up CLISP
starting, Starting Up CLISP
Clojure Lisp, A Tale of Two Lisps, Adding Lazy Evaluation to Lisp, Creating a Lazy Lists Library, Multicore Guild Formation Fighters, Lisp Dialect
and lazy evaluation, Adding Lazy Evaluation to Lisp, Lisp Dialect
lazy sequences, Creating a Lazy Lists Library
CLOS (Common Lisp Object System), When to Use Structures, CLOS Guild Battleship
closing tag in XML, Creating XML and HTML with the tag Macro
closingp predicate, Creating XML and HTML with the tag Macro
closures, Closures, Creating the lazy and force Commands
Clozure CL, Getting Started with CLISP
clusters, finding in Dice of Doom, Improving the Dice of Doom Reinforcement Rules
cmd variable, Writing a Custom read Function
CMUCL, Getting Started with CLISP
COBOL, Where Did Lisp Come From?
code, Numbers, Reading and Printing Stuff the Way Humans Like It, Brevity Guild Micro Fighter, Brevity Guild Micro Fighter
brevity, Brevity Guild Micro Fighter
symmetry between data and, Reading and Printing Stuff the Way Humans Like It
vs. data, Numbers
code composition, Higher-Order Programming
code mode, How Lisp Distinguishes Between Code and Data, Code Mode, Describing the Paths
backquote (`) for enabling switching to, Describing the Paths
code-char function, Decoding the Values of Request Parameters, Representing the Game Board
coerce function, Writing a game-print Function, Decoding the Values of Request Parameters
collect clause in loop, Looping with the loop Command, Breaking out of a Loop Early
: (colon), for keyword parameters, Walking Around in Our World, Understanding Keyword Parameters
colon (:), for keyword parameters, Walking Around in Our World, Understanding Keyword Parameters
color, Using the tag Macro to Generate HTML, Drawing the Board, Drawing the Board
for dice, Drawing the Board
manipulating, Using the tag Macro to Generate HTML
columns in table, centered, Justifying Output
comic book, If Lisp Is So Great, Why Don't More People Use It?, Epilogue
bug fighters, Epilogue
command-line interface, Interacting with the World: Reading and Printing in Lisp, Printing and Reading Text
printing to screen, Printing and Reading Text
commands, adding to permitted list, A Command for Welding
Common Lisp (CL), Getting Started with Lisp, A Tale of Two Lisps, Tail Call Optimization, Functional Guild Cruiser
basics, Functional Guild Cruiser
tail call optimization support, Tail Call Optimization
Common Lisp HyperSpec, Two More Important Sequence Functions, A Crazy Formatting Trick for Creating Pretty Tables of Data
on control sequences, A Crazy Formatting Trick for Creating Pretty Tables of Data
Common Lisp Object System (CLOS), When to Use Structures, CLOS Guild Battleship
communication, with other network computers, Working with Sockets
comparison, Using Functions That Return More than Just the Truth, Comparing Stuff: eq, equal, and More, Comparing Stuff: eq, equal, and More
eql for numbers and characters, Comparing Stuff: eq, equal, and More
of symbols, Comparing Stuff: eq, equal, and More
compiler, Where Did Lisp Come From?, Creating Your Own Generic Functions with Type Predicates
versions of function for, Creating Your Own Generic Functions with Type Predicates
complex instruction set computer (CISC), Where Did Lisp Come From?
computation, delayed, Creating a Picture of Our Graph
computer, as game opponent, Trying Out the Human vs. Human Version of Dice of Doom
concatenate command, Writing a Custom read Function
cond command, The Command That Does It All: cond, Handling Animal Motion
conditions, tricks with, Branching with case
Congestion City, The Grand Theft Wumpus Game, The Grand Theft Wumpus Game, The Grand Theft Wumpus Game, Looping with the loop Command, Preventing Islands, The add-cops Function, Initializing a New Game of Grand Theft Wumpus, Drawing a City from Partial Knowledge, Drawing Only the Known Parts of the City
building final edges, Preventing Islands
defining edges, The Grand Theft Wumpus Game
drawing map, Initializing a New Game of Grand Theft Wumpus, Drawing a City from Partial Knowledge
from partial knowledge, Drawing a City from Partial Knowledge
nodes for, The add-cops Function
preventing islands, Looping with the loop Command
walking around town, Drawing Only the Known Parts of the City
connect-all-islands function, Preventing Islands
connect-edge-list function, Building the Final Edges for Congestion City
connect-with-bridges function, Preventing Islands
Conrad’s Rule of Thumb for Comparing Stuff, Comparing Stuff: eq, equal, and More
cons cells, Lists in Lisp, Cons Cells, Nested Lists, Exotic Lists
in nested lists, Nested Lists
cons function, Cons Cells
conses, eq for comparing, Comparing Stuff: eq, equal, and More
consing, The cons Function
console output, capturing, Capturing the Console Output
console streams, Working with Streams
consp function, Sequence Functions for Iterating Across a Sequence
constants, for game board dimensions, Drawing the Game Board Using the SVG Format
continuations, Synopsis
control sequences, Anatomy of the format Function, Control Sequences for Formatting Numbers, Printing Multiple Lines of Output, Justifying Output, A Crazy Formatting Trick for Creating Pretty Tables of Data
Common Lisp HyperSpec on, A Crazy Formatting Trick for Creating Pretty Tables of Data
for formatting numbers, Control Sequences for Formatting Numbers
for new lines, Printing Multiple Lines of Output
iterating through lists with, Justifying Output
control string parameter, for format function, Anatomy of the format Function
copy-list function, Handling Animal Reproduction
copy-structure function, problems from, Handling Animal Reproduction
count function, Working with Sequences
count in loop macro, Using Multiple for Clauses
counting from starting point to ending point, Counting from a Starting Point to an Ending Point
currencies, formatting, Control Sequences for Formatting Floating-Point Numbers

D

data, Numbers, Numbers, Reading and Printing Stuff the Way Humans Like It, Visualizing Tree-like Data, When to Use Structures
generic process for handling, When to Use Structures
symmetry between code and, Reading and Printing Stuff the Way Humans Like It
tree-like, Visualizing Tree-like Data
vs. code, Numbers
data mode, How Lisp Distinguishes Between Code and Data, Data Mode, Describing the Paths
backquote (`) for enabling switching to, Describing the Paths
data structures, self-referential, Circular Lists
dead animals, in evolving environment, Handling Animal Reproduction
dead monsters, checking for, Monster Management Functions
Debian-based Linux machine, CLISP on, ANSI Common Lisp
debugging, Working with Long Strings, Functional Guild Cruiser, Functional Guild Cruiser
in functional programming, Functional Guild Cruiser
string streams and, Working with Long Strings
decf function, The Monsters
decimal number, value displayed as, Control Sequences for Formatting Numbers
decimal point, and number type, Symbols
declaration, of function, Defining Local Functions in Lisp
decode-param function, Request Parameters
default, code mode as, Code Mode
define-condition function, Error Handling in Common Lisp
defmacro command, A Simple Lisp Macro, Macro Expansion
defmethod command, Creating Your Own Generic Functions with Type Predicates, The Monsters
defparameter command, The Guess-My-Number Game, An Alternative Global Variable Definition Function, The Grand Theft Wumpus Game
defstruct command, A Faster Grand Theft Wumpus Using Hash Tables, Working with Structures, Creating Your Own Generic Functions with Type Predicates, Global Variables for the Player and Monsters, The Monsters, The Generic Monster, The Malicious Hydra, The Slimy Slime Mold, The Slimy Slime Mold, Handling Animal Motion
for brigand, The Slimy Slime Mold
for hydra, The Malicious Hydra
for slime mold, The Slimy Slime Mold
to include monster type fields, The Generic Monster
defun command, Basic Lisp Etiquette, Defining the guess-my-number Function
defvar command, An Alternative Global Variable Definition Function
delayed computation, Creating a Picture of Our Graph
deprecated function, Converting Node Identifiers
depth-first search, Alpha Beta Pruning
describe-location function, Describing the Scenery with an Association List
describe-obj function, Listing Visible Objects
describe-objects function, Listing Visible Objects
describe-path function, Describing the Paths
describe-paths function, Describing the Paths, Converting the Edges to Descriptions, Joining the Descriptions
destination parameter, for format function, Anatomy of the format Function
Dewdney, A.K., “Simulated evolution; wherein bugs learn to hunt bacteria”, Everything You Ever Wanted to Know About loop
Dice of Doom game, Dice of Doom, a Game Written in the Functional Style, The Rules of Dice of Doom, The Rules of Dice of Doom, A Sample Game of Dice of Doom, Defining Some Global Variables, Representing the Game Board, Representing the Game Board, Generating a Game Tree, Generating a Game Tree, Calculating Passing Moves, Calculating Attacking Moves, Finding the Neighbors, Reinforcements, Reinforcements, Trying Out Our New game-tree Function, Trying Out Our New game-tree Function, The Main Loop, Giving Information About the State of the Game, Giving Information About the State of the Game, Trying Out the Human vs. Human Version of Dice of Doom, The Minimax Algorithm, The Minimax Algorithm, Turning Minimax into Actual Code, Creating a Game Loop with an AI Player, Making Dice of Doom Faster, Tail Call Optimization, Tail Call Optimization in Dice of Doom, Mapping and Searching Across Lazy Lists, Mapping and Searching Across Lazy Lists, Dice of Doom, Version 2, Trimming the Game Tree, Winning by a Lot vs. Winning by a Little, Winning by a Lot vs. Winning by a Little, Alpha Beta Pruning, Creating a Graphical, Web-Based Version of Dice of Doom, Drawing the Game Board Using the SVG Format, Drawing the Game Board Using the SVG Format, Drawing the Game Board Using the SVG Format, Drawing a Die, Drawing the Board, Drawing the Board, Limitations of Our Game Web Server, Limitations of Our Game Web Server, Limitations of Our Game Web Server, Handling the Computer Player, Handling the Computer Player, Drawing the SVG Game Board from Within the HTML, Making Dice of Doom More Fun, Increasing the Number of Players, Building Chance Nodes, Building Chance Nodes, Updating the AI, Updating the AI
attacking, Finding the Neighbors
calculating attacking moves, Calculating Passing Moves
calculating passing moves, Generating a Game Tree
computer opponent, Trying Out the Human vs. Human Version of Dice of Doom, The Minimax Algorithm, The Minimax Algorithm, Turning Minimax into Actual Code
game loop with AI player, Turning Minimax into Actual Code
minimax algorithm, The Minimax Algorithm
minimax algorithm code, The Minimax Algorithm
decoupling rules from rest of game, Representing the Game Board
finding neighbors, Calculating Attacking Moves
game board, Representing the Game Board, Tail Call Optimization in Dice of Doom, Alpha Beta Pruning, Drawing the Game Board Using the SVG Format, Drawing the Game Board Using the SVG Format
3-by-3 sample game, Tail Call Optimization in Dice of Doom
5-by-5, Alpha Beta Pruning
constants for dimensions, Drawing the Game Board Using the SVG Format
using SVG format, Drawing the Game Board Using the SVG Format
generating game tree, Generating a Game Tree
new game-tree function, Reinforcements
performance improvement, Making Dice of Doom Faster
playing against another human, Trying Out Our New game-tree Function, Trying Out Our New game-tree Function, The Main Loop, Giving Information About the State of the Game, Giving Information About the State of the Game
input from human players, Giving Information About the State of the Game
main loop, The Main Loop
state of game information, Trying Out Our New game-tree Function
winner determination, Giving Information About the State of the Game
playing first human vs. computer game, Creating a Game Loop with an AI Player
reinforcements, Reinforcements
rules, The Rules of Dice of Doom
sample game, The Rules of Dice of Doom
tail call optimization, Tail Call Optimization
version 1, A Sample Game of Dice of Doom, Defining Some Global Variables
global variables, Defining Some Global Variables
version 2, Mapping and Searching Across Lazy Lists, Mapping and Searching Across Lazy Lists, Dice of Doom, Version 2, Trimming the Game Tree, Winning by a Lot vs. Winning by a Little, Winning by a Lot vs. Winning by a Little
alpha beta pruning, Winning by a Lot vs. Winning by a Little
lazy lists for game tree, Mapping and Searching Across Lazy Lists
score-board function, Winning by a Lot vs. Winning by a Little
starting game on 4-by-4 board, Dice of Doom, Version 2
winning by a lot vs. winning by a little, Trimming the Game Tree
version 3 (web-based), Creating a Graphical, Web-Based Version of Dice of Doom, Drawing the Game Board Using the SVG Format, Drawing a Die, Drawing the Board, Drawing the Board, Limitations of Our Game Web Server, Limitations of Our Game Web Server, Limitations of Our Game Web Server, Handling the Computer Player, Handling the Computer Player, Drawing the SVG Game Board from Within the HTML
announcing winner, Limitations of Our Game Web Server
drawing die, Drawing the Game Board Using the SVG Format
drawing tile, Drawing a Die
game board, Drawing the Board
game board in HTML, Handling the Computer Player
handling computer player, Handling the Computer Player
handling human player, Limitations of Our Game Web Server
initializing new game, Limitations of Our Game Web Server
playing, Drawing the SVG Game Board from Within the HTML
web server interface, Drawing the Board
version 4, Making Dice of Doom More Fun, Increasing the Number of Players, Building Chance Nodes, Building Chance Nodes, Updating the AI, Updating the AI
calling dice rolling code from game engine, Building Chance Nodes
improving reinforcement rules, Updating the AI
increasing number of players, Making Dice of Doom More Fun
rolling dice, Increasing the Number of Players
updaing AI, Updating the AI
dice_of_doom.v2.lisp file, Drawing the Game Board Using the SVG Format
digit-char-p function, Converting Node Identifiers
digraph command (Graphviz), Creating a Graph
direct-edges function, Preventing Islands
directed graph, Creating Undirected Graphs
dirty code, What Is Functional Programming?, Anatomy of a Program Written in the Functional Style
dividing by zero, One Thing at a Time with if
division function, Numbers
do token, Counting from a Starting Point to an Ending Point
DOCTYPE declaration, How a Web Server Works
dod-request-handler function, Drawing the Board
domain of function, Ramping Lisp Up a Notch with Functional Programming
domain, explained, Domain-Specific Languages
domain-specific language (DSL), Justifying Output, Domain-Specific Languages, DSL Guild Hot Rods
. (dot), for representing cons cells, The cons Function
dot (.), for representing cons cells, The cons Function
DOT information generation, Creating a Graph, Converting Node Identifiers, Converting Node Identifiers, Adding Labels to Graph Nodes, Converting Edges into DOT Format, Generating All the DOT Data
edges conversion, Converting Edges into DOT Format
for nodes, Adding Labels to Graph Nodes
labels for graph nodes, Converting Node Identifiers
node identifiers conversion, Converting Node Identifiers
turning DOT file into picture, Generating All the DOT Data
dot->png function, Capturing the Console Output
dot-name function, Converting Node Identifiers
dotimes function, Hash Table Performance, Main Game Functions
dotted lists, Exotic Lists
" (double quotes), for strings, Numbers
double quotes ("), for strings, Numbers
downfrom in loop macro, Using Multiple for Clauses
downto in loop macro, Using Multiple for Clauses
draw-board function, Representing the Game Board
draw-board-svg function, Drawing the Board
draw-city function, Initializing a New Game of Grand Theft Wumpus
draw-die-svg function, Drawing the Game Board Using the SVG Format
draw-dod-page function, Writing Our Web Request Handler, Handling the Computer Player
draw-known-city function, Known Edges, Walking Around Town
draw-tile-svg function, Drawing a Die
draw-world function, Handling Animal Reproduction
DSL (domain-specific language), Justifying Output, Domain-Specific Languages, DSL Guild Hot Rods
dunk function, A Command for Welding, The game-action Macro
dynamic variable, An Alternative Global Variable Definition Function
dynamic website, Our Grand Finale: The serve Function!, Our Grand Finale: The serve Function!
testing request handler, Our Grand Finale: The serve Function!

E

earmuffs, Defining the small and big Variables
eat function, Handling Animal Turning
edge-pair function, Generating Random Edges, Preventing Islands
edges, Describing the Paths, Describing Multiple Paths at Once, Converting Edges into DOT Format, Creating Undirected Graphs, Defining the Edges of Congestion City, A Faster Grand Theft Wumpus Using Hash Tables
converting to descriptions, Describing Multiple Paths at Once
converting to DOT format, Converting Edges into DOT Format
erasing duplicate, Creating Undirected Graphs
of Congestion City, Defining the Edges of Congestion City
replacing list with hash table, A Faster Grand Theft Wumpus Using Hash Tables
edges->dot function, Converting Edges into DOT Format
edges-to-alist function, Preventing Islands, The edges-to-alist Function
EDSAC Initial Orders, Where Did Lisp Come From?
else in loop macro, Using Multiple for Clauses
Emacs Lisp, Lisp Dialects Used for Scripting
empty lists (), The cons Function, Empty Equals False, Empty Equals False
as false value, Empty Equals False
other expressions as disguises for, Empty Equals False
end in loop macro, Using Multiple for Clauses
energy, in plants, Using loop to Evolve!
eq function, The Building Blocks of Lisp Syntax, The Command That Does It All: cond, Comparing Stuff: eq, equal, and More
eql function, Comparing Stuff: eq, equal, and More, Memoizing the rate-position Function
equal function, Comparing Stuff: eq, equal, and More, Memoizing the rate-position Function
= (equal sign) function, Comparing Stuff: eq, equal, and More, Comparing Stuff: eq, equal, and More
equalp function, Comparing Stuff: eq, equal, and More, Memoizing the neighbors Function
error command, Error Handling in Common Lisp
escaped characters, in strings, Numbers
eval command, The Symmetry Between Code and Data in Lisp, Writing a game-eval Function, The Dangers of read and eval
danger of, The Dangers of read and eval
improving, Writing a game-eval Function
every function, Working with Sequences, Monster Management Functions
evolution function, Drawing Our World
evolving environment game, Everything You Ever Wanted to Know About loop, Using loop to Evolve!, Using loop to Evolve!, Growing Plants in Our World, Creating Animals, Creating Animals, Anatomy of an Animal, Anatomy of an Animal, Anatomy of an Animal, Anatomy of an Animal, Anatomy of an Animal, Handling Animal Motion, Handling Animal Turning, Handling Animal Reproduction, Handling Animal Reproduction, Handling Animal Reproduction, Drawing Our World, Creating a User Interface, Let's Watch Some Evolution!
animals, Creating Animals, Creating Animals, Anatomy of an Animal, Anatomy of an Animal, Anatomy of an Animal, Anatomy of an Animal, Anatomy of an Animal, Handling Animal Motion, Handling Animal Turning, Handling Animal Reproduction
anatomy, Creating Animals
eating process, Handling Animal Turning
energy, Anatomy of an Animal
motion, Anatomy of an Animal
properties, Anatomy of an Animal
reproduction, Handling Animal Reproduction
starting point, Anatomy of an Animal
tracking genes, Anatomy of an Animal
turn function, Handling Animal Motion
bimodal distribution in, Let's Watch Some Evolution!
drawing world, Handling Animal Reproduction
plants, Using loop to Evolve!, Using loop to Evolve!, Growing Plants in Our World
energy, Using loop to Evolve!
growth, Growing Plants in Our World
simulating day, Handling Animal Reproduction
starting simulation, Creating a User Interface
user interface, Drawing Our World
exception handling, Writing a Custom read Function, Let's Create a Web Server!, Error Handling in Common Lisp, Error Handling in Common Lisp, Creating Custom Conditions, Creating Custom Conditions, Our Grand Finale: The serve Function!, Synopsis
custom conditions, Error Handling in Common Lisp
for web server, Our Grand Finale: The serve Function!
intercepting conditions, Creating Custom Conditions
resources protected against unexpected conditions, Creating Custom Conditions
signaling condition, Error Handling in Common Lisp
exponent, Code Mode
expressive language, Where Does Lisp Get Its Power?
expt function, Symbols, Code Mode

F

false value, empty list () as, Empty Equals False
file streams, Working with Streams
files, Using Thunks, Input Streams, Working with Files
streams to write and read, Input Streams
writing information to, Using Thunks
find-empty-node function, Building the Nodes for Congestion City
find-if function, Using Functions That Return More than Just the Truth, Working with Sequences
find-island function, Preventing Islands
find-islands function, Preventing Islands
Firefox 3.7 alpha, for SVG support, Drawing the Game Board Using the SVG Format
Firefox, for Dice of Doom game, Drawing the SVG Game Board from Within the HTML
first-class values, functions as, What lambda Does
flet function, Defining Local Functions in Lisp, Writing a Custom read Function
for local function definition, Writing a Custom read Function
floating-point numbers, Numbers, Control Sequences for Formatting Floating-Point Numbers
control sequences for formatting, Control Sequences for Formatting Floating-Point Numbers
for in loop macro, The loop Macro, Using Multiple for Clauses
force command, Creating the lazy and force Commands
format function, loop and format: The Seedy Underbelly of Lisp, Printing Text with the format Function, Anatomy of the format Function, Anatomy of the format Function, Printing Multiple Lines of Output
anatomy, Printing Text with the format Function
and text justification, Printing Multiple Lines of Output
control string parameter, Anatomy of the format Function
destination parameter, Anatomy of the format Function
formatting numbers, control sequences for, Control Sequences for Formatting Numbers
forms, Code Mode, Code Mode
nested, Code Mode
FORTRAN, Where Did Lisp Come From?
freeing of variables, Closures
fresh-line command, Printing Multiple Lines of Output
from in loop macro, Using Multiple for Clauses
funcall function, Helper Functions for Player Attacks, Closures
#' (function) operator, Converting the Edges to Descriptions
function operator, shorthand for, Converting the Edges to Descriptions
function pipeline, Decoupling Dice of Doom's Rules from the Rest of the Game
functional programming, One Thing at a Time with if, Describing the Location, Why lambda Is So Important, Ramping Lisp Up a Notch with Functional Programming, What Is Functional Programming?, What Is Functional Programming?, Using the Functional Style, Why Functional Programming Is Crazy, Why Functional Programming Is Fantastic, Finding the Neighbors, A Recursion Macro, Lazy Programming, Functional Guild Cruiser
anatomy of program, What Is Functional Programming?
and loops, Finding the Neighbors
benefits, Why Functional Programming Is Fantastic
higher-order, Why lambda Is So Important
problems from, Lazy Programming
reduce function, A Recursion Macro
side effects, What Is Functional Programming?, Why Functional Programming Is Crazy
using, Using the Functional Style
what it is, Ramping Lisp Up a Notch with Functional Programming
functionp function, Sequence Functions for Iterating Across a Sequence
functions, The Guess-My-Number Game, The Guess-My-Number Game, The Guess-My-Number Game, Defining Local Functions in Lisp, Defining Local Functions in Lisp, Converting the Edges to Descriptions, Converting the Edges to Descriptions, lambda: A Function So Important It Deserves Its Own Chapter, Converting Node Identifiers, Converting Node Identifiers, Using Thunks, Two More Important Sequence Functions, Tidying Up After Ourselves
call to itself, Defining Local Functions in Lisp
calling in Lisp, The Guess-My-Number Game
comprehensive list of sequence, Two More Important Sequence Functions
creating with lambda, lambda: A Function So Important It Deserves Its Own Chapter
deprecated, Converting Node Identifiers
generic, Converting Node Identifiers
higher-order, Converting the Edges to Descriptions
names available in defined functions, Defining Local Functions in Lisp
namespaces for, Converting the Edges to Descriptions
nullary, Using Thunks
parentheses for, The Guess-My-Number Game
sending string streams to, Tidying Up After Ourselves

G

game board, Defining Some Global Variables, Tail Call Optimization in Dice of Doom, Making Our AI Work on Larger Game Boards, Making Our AI Work on Larger Game Boards, Alpha Beta Pruning, Drawing the Game Board Using the SVG Format, Drawing the Game Board Using the SVG Format
AI adjustments for larger, Making Our AI Work on Larger Game Boards
for Dice of Doom, Defining Some Global Variables, Tail Call Optimization in Dice of Doom, Alpha Beta Pruning, Drawing the Game Board Using the SVG Format, Drawing the Game Board Using the SVG Format
3-by-3 sample game, Tail Call Optimization in Dice of Doom
5-by-5, Alpha Beta Pruning
constants for dimensions, Drawing the Game Board Using the SVG Format
using SVG format, Drawing the Game Board Using the SVG Format
game tree, Generating a Game Tree, Memoizing the neighbors Function, Lazy Programming, Lazy Programming, Trimming the Game Tree, Increasing the Number of Players
branches hidden in clouds, Lazy Programming
chance nodes in, Increasing the Number of Players
generating, Generating a Game Tree
memoizing, Memoizing the neighbors Function
trimming, Trimming the Game Tree
game-action macro, A Command for Dunking
game-eval function, Writing a game-eval Function, The Dangers of read and eval, The Dangers of read and eval
approved list of commands for, The Dangers of read and eval
limiting commands called, Writing a game-eval Function
game-loop function, Global Variables for the Player and Monsters
game-print function, Writing a game-eval Function
game-read function, Setting Up a Custom REPL
game-repl function, Setting Up a Custom REPL, Creating Custom Game Commands for Wizard's Adventure Game
game-tree function, Generating a Game Tree, Reinforcements
games. See also Dice of Doom game; evolving environment game; Grand Theft Wumpus game; Orc Battle game; Wizard’s Adventure Game, The Guess-My-Number Game, A Crazy Formatting Trick for Creating Pretty Tables of Data, A Crazy Formatting Trick for Creating Pretty Tables of Data, Creating Custom Game Commands for Wizard's Adventure Game, Trimming the Game Tree
Attack of the Robots! game, A Crazy Formatting Trick for Creating Pretty Tables of Data
Guess-My-Number, The Guess-My-Number Game
loading code from REPL, Creating Custom Game Commands for Wizard's Adventure Game
winning by a lot vs. winning by a little, Trimming the Game Tree
garbage collection, Where Did Lisp Come From?, Closures
Garret, Ron, How a Web Server Works
gen-board function, Representing the Game Board
generalized reference, Using a Generic Setter
generic functions, Converting Node Identifiers, Sequence Functions for Iterating Across a Sequence
creating with type predicates, Sequence Functions for Iterating Across a Sequence
generic setters, Using a Generic Setter, Synopsis
gensym function, Avoiding Variable Capture
GET request, How a Web Server Works, Request Parameters
request parameters for, Request Parameters
get-connected function, Preventing Islands, Hash Table Performance, A Faster Grand Theft Wumpus Using Hash Tables, Improving the Dice of Doom Reinforcement Rules, Improving the Dice of Doom Reinforcement Rules
get-connected-hash function, A Faster Grand Theft Wumpus Using Hash Tables
get-content-params function, Testing get-header with a String Stream
get-header function, Parsing the Request Header, Parsing the Request Header
testing, with string stream, Parsing the Request Header
get-ratings function, Turning Minimax into Actual Code, Winning by a Lot vs. Winning by a Little, Alpha Beta Pruning, Updating the AI
new versions, Alpha Beta Pruning
gethash function, Using a Generic Setter, Working with Hash Tables, Returning Multiple Values, A Faster Grand Theft Wumpus Using Hash Tables
global functions, defining, Basic Lisp Etiquette
global variables, The Guess-My-Number Game, Defining the guess-my-number Function, Defining the guess-my-number Function, One Thing at a Time with if, Describing It All, Global Variables for the Player and Monsters, The game-action Macro
changing value, Defining the guess-my-number Function
defining, The Guess-My-Number Game
for player and monsters, Global Variables for the Player and Monsters
in look function, Describing It All
macros and, The game-action Macro
setting inside conditional branch, One Thing at a Time with if
Google BigTable, Returning Multiple Values
Graham, Paul, A Tale of Two Lisps, Creating the tag Macro
Arc Lisp dialect, Creating the tag Macro
Grand Theft Wumpus game. See also Congestion City, The Grand Theft Wumpus Game, The Grand Theft Wumpus Game, Building the Final Edges for Congestion City, Building the Nodes for Congestion City, Building the Nodes for Congestion City, Initializing a New Game of Grand Theft Wumpus, Drawing a City from Partial Knowledge, Walking Around Town, A Faster Grand Theft Wumpus Using Hash Tables
basics, The Grand Theft Wumpus Game
clues, Building the Nodes for Congestion City
drawing map, Initializing a New Game of Grand Theft Wumpus, Drawing a City from Partial Knowledge
from partial knowledge, Drawing a City from Partial Knowledge
initializing new game, Building the Nodes for Congestion City
playing game, Walking Around Town
police roadblocks, Building the Final Edges for Congestion City
with hash tables, A Faster Grand Theft Wumpus Using Hash Tables
graph utilities, loading, The Grand Theft Wumpus Game
graph->dot function, Creating a Picture of Our Graph
graph-util.lisp file, Creating Undirected Graphs
graphs, Visualizing Tree-like Data, Visualizing Tree-like Data, Visualizing Graphs, Converting Node Identifiers, Capturing the Console Output, Creating a Picture of Our Graph, Creating Undirected Graphs
creating, Visualizing Tree-like Data
creating picture of, Capturing the Console Output
directed, Creating Undirected Graphs
labels for nodes, Converting Node Identifiers
undirected, Creating a Picture of Our Graph
visualizing, Visualizing Tree-like Data
Graphviz, Creating a Graph
Graphviz DOT file, Creating a Graph, Converting Node Identifiers, Converting Node Identifiers, Adding Labels to Graph Nodes, Converting Edges into DOT Format, Converting Edges into DOT Format, Generating All the DOT Data
edges conversion, Converting Edges into DOT Format
for graph drawing library, Creating a Graph
for nodes, Adding Labels to Graph Nodes
labels for graph nodes, Converting Node Identifiers
node identifiers conversion, Converting Node Identifiers
turning DOT file into picture, Generating All the DOT Data
guess-my-number function, Basic Lisp Etiquette
Guess-My-Number game, The Guess-My-Number Game
Guile Scheme, Lisp Dialects Used for Scripting

H

hackers, The Dangers of read and eval, The Dangers of read and eval, Parsing the Request Header
and dangerous commands, The Dangers of read and eval
and read command, Parsing the Request Header
handle-computer function, Turning Minimax into Actual Code, Trimming the Game Tree, Alpha Beta Pruning, Handling the Computer Player, Calling the Dice Rolling Code from Our Game Engine
handle-direction function, Drawing Only the Known Parts of the City
handle-human function, Giving Information About the State of the Game, Dice of Doom, Version 2, Calling the Dice Rolling Code from Our Game Engine
handle-new-place function, Walking Around Town
handler-case function, Error Handling in Common Lisp
hash collisions, Hash Table Performance
# (hash mark), for array, Working with Arrays
hash mark (#), for array, Working with Arrays
hash tables, Using a Generic Setter, Hash Tables, Returning Multiple Values, Returning Multiple Values, Returning Multiple Values, Hash Table Performance, Growing Plants in Our World
for plants, Growing Plants in Our World
Grand Theft Wumpus game with, Hash Table Performance
inefficiency for small tables, Returning Multiple Values
performance, Returning Multiple Values
returning multiple values, Returning Multiple Values
hash-edges function, A Faster Grand Theft Wumpus Using Hash Tables
hash-table-p function, Sequence Functions for Iterating Across a Sequence
Haskell, A Tale of Two Lisps, Anatomy of a Program Written in the Functional Style, Adding Lazy Evaluation to Lisp
and lazy evaluation, Adding Lazy Evaluation to Lisp
have function, A Command for Welding
health meter, for monsters, The Monsters
hello-request-handler function, Our Grand Finale: The serve Function!
heuristics, Applying Heuristics
hexadecimal, number display as, Control Sequences for Formatting Numbers
Hickey, Rich, A Tale of Two Lisps
hidden state, Code Composition with Imperative Code
hierarchical data, Visualizing Tree-like Data
higher-order functions, Converting the Edges to Descriptions
higher-order programming, What lambda Does, Higher-Order Programming
homoiconic programming code, Reading and Printing Stuff the Way Humans Like It
HTML code, Writing a game-print Function, Our Grand Finale: The serve Function!, Creating the tag Macro, Drawing the Game Board Using the SVG Format
embedding SVG pictures, Drawing the Game Board Using the SVG Format
page skeleton, Our Grand Finale: The serve Function!
tag macro to generate, Creating the tag Macro
html tags, How a Web Server Works
HTML5 standard, Drawing the Game Board Using the SVG Format
HTTP (Hypertext Transfer Protocol), Protecting Resources Against Unexpected Conditions
HTTP escape codes, Decoding the Values of Request Parameters
http-char function, Decoding the Values of Request Parameters
http.lisp file, How a Web Server Works
Hughes, John, “Why Functional Programming Matters”, Decoupling Dice of Doom's Rules from the Rest of the Game
Hunt the Wumpus, This Ain't Your Daddy's Wumpus
hyperlinks, in SVG image, Using the tag Macro to Generate HTML
Hypertext Transfer Protocol (HTTP), Protecting Resources Against Unexpected Conditions

I

if command, Empty Equals False, The Four Disguises of ()
if in loop macro, Using Multiple for Clauses
imperative code, What Is Functional Programming?, Anatomy of a Program Written in the Functional Style
code composition with, Anatomy of a Program Written in the Functional Style
imperative game engine, Decoupling Dice of Doom's Rules from the Rest of the Game
implicit progn, Going Beyond if: The when and unless Alternatives
in in loop macro, Using Multiple for Clauses
incf function, Monster Management Functions
indentation of code, Defining the start-over Function
infinite loop, Setting Up a Custom REPL, Setting Up a Custom REPL, Circular Lists
getting out of, Setting Up a Custom REPL
preventing, Circular Lists
infinity, positive and negative, Alpha Beta Pruning
Information Processing Language, Where Did Lisp Come From?
init-monsters function, Helper Functions for Player Attacks
input streams, Streams by Direction, Input Streams
input-stream-p command, Output Streams
installing CLISP, ANSI Common Lisp
instruction set of processor, Where Did Lisp Come From?
integers, Numbers, Control Sequences for Formatting Numbers
control sequences for formatting, Control Sequences for Formatting Numbers
intern command, Parsing the Request Header
interpreter, Where Did Lisp Come From?, Creating Your Own Generic Functions with Type Predicates
versions of function for, Creating Your Own Generic Functions with Type Predicates
intersection function, The edges-to-alist Function
into in loop macro, Using Multiple for Clauses
inventory function, Checking Our Inventory
IP address, in socket address, Working with Sockets
islands, preventing, Looping with the loop Command
isomorphic item, Comparing Stuff: eq, equal, and More
iterating, Working with Sequences, Working with Sequences, Counting from a Starting Point to an Ending Point, Justifying Output
across sequence, Working with Sequences
through list values, Counting from a Starting Point to an Ending Point
through lists, with format control sequences, Justifying Output

J

Java language, Where Does Lisp Get Its Power?
Jones, Simon Peyton, Using the Functional Style
justified text, Printing Multiple Lines of Output

K

key/value pair, Association Lists, Association Lists, Hash Table Performance
returning for alist, Association Lists
storage, Hash Table Performance
keyword parameter, Walking Around in Our World, Converting Node Identifiers, Understanding Keyword Parameters
for find function, Walking Around in Our World
known-city-edges function, Drawing a City from Partial Knowledge
known-city-nodes function, Drawing a City from Partial Knowledge
known-city.dot-png file, Drawing Only the Known Parts of the City

L

labels function, Defining Local Functions in Lisp, Listing Visible Objects, Writing a Custom read Function
for local function definition, Writing a Custom read Function
labels, for graph nodes, Converting Node Identifiers
lambda calculus, Where Did Lisp Come From?, Why lambda Is So Important, What Is Functional Programming?
lambda function, lambda: A Function So Important It Deserves Its Own Chapter, What lambda Does, Helper Functions for Player Attacks, Monster Management Functions, Creating Custom Conditions, Calculating Attacking Moves, Making Dice of Doom Faster
and closures, Making Dice of Doom Faster
importance, What lambda Does
purpose, lambda: A Function So Important It Deserves Its Own Chapter
largest-cluster-size function, Improving the Dice of Doom Reinforcement Rules
launching website, Testing the Request Handler
lazy command, Creating the lazy and force Commands
lazy evaluation, Lazy Programming, Improving the Dice of Doom Reinforcement Rules, Lisp Dialect
lazy game tree, Decoupling Dice of Doom's Rules from the Rest of the Game
lazy lists, Creating a Lazy Lists Library, Creating a Lazy Lists Library, Converting Between Regular Lists and Lazy Lists, Mapping and Searching Across Lazy Lists, Mapping and Searching Across Lazy Lists, Making Our AI Work on Larger Game Boards, Making Our AI Work on Larger Game Boards
adjusting AI functions to use, Making Our AI Work on Larger Game Boards
converting between regular lists and, Creating a Lazy Lists Library
converting to regular lists, Converting Between Regular Lists and Lazy Lists
for Dice of Doom game tree, Mapping and Searching Across Lazy Lists
library for, Creating a Lazy Lists Library
mapping and searching, Mapping and Searching Across Lazy Lists
lazy-car command, Creating the lazy and force Commands
lazy-cdr command, Creating the lazy and force Commands
lazy-cons command, Creating the lazy and force Commands
lazy-find-if function, Mapping and Searching Across Lazy Lists
lazy-mapcan function, Mapping and Searching Across Lazy Lists, Dice of Doom, Version 2
lazy-mapcar function, Mapping and Searching Across Lazy Lists
lazy-nil function, Creating a Lazy Lists Library, Dice of Doom, Version 2
lazy-nth function, Mapping and Searching Across Lazy Lists
lazy-null function, Creating a Lazy Lists Library
legal-tiles parameter, Drawing the Board
legality of game move, Drawing Only the Known Parts of the City
length function, When to Use Structures
< (less-than) function, with sort, Sequence Functions for Iterating Across a Sequence
less-than (<) function, with sort, Sequence Functions for Iterating Across a Sequence
let command, Defining the start-over Function, Capturing the Console Output, Building the Final Edges for Congestion City, Closures, The Magic of Lisp Macros, How Macros Are Transformed
progn command and, How Macros Are Transformed
let* command, Building the Final Edges for Congestion City
lexical variable, Capturing the Console Output, Closures
library, for lazy lists, Creating the lazy and force Commands
limit-tree-depth function, Trimming the Game Tree, Alpha Beta Pruning, Updating the AI
line breaks, Defining Local Variables in Lisp
linking data pieces, cons function for, Cons Cells
Lisp. See also Common Lisp (CL), What Makes Lisp So Cool and Unusual?, What Makes Lisp So Cool and Unusual?, If Lisp Is So Great, Why Don't More People Use It?, Where Does Lisp Get Its Power?, Lisp Dialects, A Tale of Two Lisps, Lisp Dialects Used for Scripting, The Guess-My-Number Game, An Alternative Global Variable Definition Function, An Alternative Global Variable Definition Function, Epilogue
basic etiquette, An Alternative Global Variable Definition Function
dialects, Lisp Dialects, Lisp Dialects Used for Scripting
for scripting, Lisp Dialects Used for Scripting
features, What Makes Lisp So Cool and Unusual?
Guess-My-Number game, The Guess-My-Number Game
origins, If Lisp Is So Great, Why Don't More People Use It?
source of power, Where Does Lisp Get Its Power?
technologies supporting, comic book, Epilogue
up-and-coming dialects, A Tale of Two Lisps
valid expression example, What Makes Lisp So Cool and Unusual?
LispWorks, Getting Started with CLISP
list function, The car and cdr Functions, Creating the tag Macro
list-length function, Working with Sequences
listp function, Sequence Functions for Iterating Across a Sequence, Output Streams
lists, The Building Blocks of Lisp Syntax, Data Mode, List Functions, The cons Function, Nested Lists, Empty Equals False, Empty Equals False, Empty Equals False, Using the Stealth Conditionals and and or, Describing the Scenery with an Association List, Converting the Edges to Descriptions, Joining the Descriptions, Exotic Lists, Pairs, Pairs, Circular Lists, Using a Generic Setter, When to Use Structures, When to Use Structures, Sequence Functions for Iterating Across a Sequence, Counting from a Starting Point to an Ending Point, Justifying Output, More Complex Macros
association, Circular Lists
benefits of using, Describing the Scenery with an Association List
calculating length, Empty Equals False
checking for membership, Using the Stealth Conditionals and and or
circular, Pairs
control sequences for iterating through, Justifying Output
dotted, Exotic Lists
empty, The cons Function, Empty Equals False, Empty Equals False
as false value, Empty Equals False
other expressions as disguises for, Empty Equals False
functions, List Functions
iterating through with loop, Counting from a Starting Point to an Ending Point
joining multiple into one, Converting the Edges to Descriptions
macro for splitting, More Complex Macros
nested, Nested Lists
of objects, Joining the Descriptions
pairs, Pairs
sequence functions for, When to Use Structures
sum function for, Sequence Functions for Iterating Across a Sequence
vs. arrays, Using a Generic Setter
vs. structures, When to Use Structures
lit variable, and capitalization rules, Writing a game-print Function
literal characters, Starting with print and read
load command, The Grand Theft Wumpus Game
local functions, defining, Defining Local Functions in Lisp
local variables, Defining the start-over Function, Defining Local Variables in Lisp, Saying Hello to the User
defining, Defining the start-over Function
for value returned by read function, Saying Hello to the User
log information, streams for, Tidying Up After Ourselves
long strings, Working with Long Strings
look function, Describing It All, Setting Up a Custom REPL
lookup key, of hash table, Working with Hash Tables
loop macro, Setting Up a Custom REPL, Generating Random Edges, loop and format: The Seedy Underbelly of Lisp, Looping with the loop Command, Counting from a Starting Point to an Ending Point, Counting from a Starting Point to an Ending Point, Counting from a Starting Point to an Ending Point, Counting from a Starting Point to an Ending Point, Breaking out of a Loop Early, Breaking out of a Loop Early, Breaking out of a Loop Early, Using Multiple for Clauses
breaking out, Breaking out of a Loop Early
collect clause, Breaking out of a Loop Early
counting from starting point to ending point, Counting from a Starting Point to an Ending Point
do token, Counting from a Starting Point to an Ending Point
iterating through list values, Counting from a Starting Point to an Ending Point
nested, Using Multiple for Clauses
when token, Counting from a Starting Point to an Ending Point
with multiple for clauses, Breaking out of a Loop Early
loops, Setting Up a Custom REPL, Circular Lists, Main Game Functions, Main Game Functions, Everything You Ever Wanted to Know About loop, Finding the Neighbors
and functional programming, Finding the Neighbors
for evolving environment, Everything You Ever Wanted to Know About loop
getting out of infinite, Setting Up a Custom REPL
preventing infinite, Circular Lists
with dotimes function, Main Game Functions

M

machine language, Where Did Lisp Come From?
macro expansion, A Simple Lisp Macro
macroexpand command, Using the Simple Macro, Avoiding Repeated Execution in Macros, Avoiding Variable Capture
macros, One Thing at a Time with if, Walking Around in Our World, The Dangers of read and eval, What lambda Does, The Magic of Lisp Macros, The Magic of Lisp Macros, Macro Expansion, More Complex Macros, A Macro for Splitting Lists, Avoiding Repeated Execution in Macros, Avoiding Variable Capture, A Recursion Macro, Writing a Macro Helper Function, Using the tag Macro to Generate HTML, The game-action Macro, Creating the lazy and force Commands, Synopsis
avoiding repeated execution, A Macro for Splitting Lists
avoiding variable capture, Avoiding Repeated Execution in Macros
dangers and alternatives, A Recursion Macro
for defining new function, The game-action Macro
for splitting lists, More Complex Macros
helper function, Writing a Macro Helper Function
reader, The Dangers of read and eval
recursive, Avoiding Variable Capture
simple example, The Magic of Lisp Macros
svg, Using the tag Macro to Generate HTML
to implement lazy command, Creating the lazy and force Commands
transformation, Macro Expansion
main-loop function, Anatomy of a Program Written in the Functional Style, Anatomy of a Program Written in the Functional Style
make-array command, Working with Arrays
make-city-edges function, Preventing Islands, Building the Final Edges for Congestion City
make-city-nodes function, Building the Nodes for Congestion City
make-edge-list function, Generating Random Edges, Building the Final Edges for Congestion City
make-hash-table command, Arrays vs. Lists, Hash Table Performance
make-lazy function, Creating a Lazy Lists Library
make-orc function, The Generic Monster
make-person function, Working with Structures, When to Use Structures
make-string-input-stream function, Tidying Up After Ourselves, Testing get-header with a String Stream
make-string-output-stream command, Tidying Up After Ourselves
map function, Sequence Functions for Iterating Across a Sequence
map of city, Initializing a New Game of Grand Theft Wumpus, Initializing a New Game of Grand Theft Wumpus, Drawing a City from Partial Knowledge
drawing, Initializing a New Game of Grand Theft Wumpus
showing only visited nodes, Drawing a City from Partial Knowledge
mapc function, Adding Labels to Graph Nodes, Preventing Islands, A Faster Grand Theft Wumpus Using Hash Tables
mapcan function, Drawing a City from Partial Knowledge, Known Edges, Calculating Attacking Moves, Building a More Complicated SVG Example
mapcar function, Describing Multiple Paths at Once, The edges-to-alist Function, Creating the tag Macro
maplist function, Creating Undirected Graphs
mapping lazy lists, Mapping and Searching Across Lazy Lists
mathematical functions, properties, What Is Functional Programming?
mathematical sets, hash tables for, Growing Plants in Our World
mathematical syntax, languages using, Where Did Lisp Come From?
max function, Handling Animal Reproduction
maximize in loop macro, Using Multiple for Clauses
McCarthy, John, Where Did Lisp Come From?, Where Did Lisp Come From?
“Recursive Functions of Symbolic Expressions and Their Computation by Machine”, Where Did Lisp Come From?
member function, Using the Stealth Conditionals and and or, Writing a game-eval Function
memoization, Memoization
memory, Where Did Lisp Come From?, Using a Generic Setter, Synopsis
software transactional, Synopsis
Metaobject Protocol (MOP), CLOS Guild Battleship
minimax algorithm code, game tree analysis with, Alpha Beta Pruning
minimize in loop macro, Using Multiple for Clauses
mod (remainder) function, Handling Animal Motion
monetary floating-point value, The Control String Parameter
monster-attack function, The Generic Monster, The Wicked Orc, The Slimy Slime Mold
for orcs, The Wicked Orc
for slime mold, The Slimy Slime Mold
monster-hit function, Player Management Functions, The Malicious Hydra
monster-show function, for orcs, The Wicked Orc
monsters. See Orc Battle game, The Wicked Orc
MOP (Metaobject Protocol), CLOS Guild Battleship
most-negative-fixnum, Alpha Beta Pruning
most-positive-fixnum, Alpha Beta Pruning
move function, Anatomy of an Animal
move in game, checking legality, Drawing Only the Known Parts of the City
multiparadigm language, ANSI Common Lisp
multiple dispatch, Explanation
multiple-value-bind command, Returning Multiple Values
mutations, When to Use Structures, Handling Animal Reproduction, Handling Animal Reproduction
with reproduce function, Handling Animal Reproduction
my-length function, Memoizing the rate-position Function, Using the Simple Macro, Avoiding Variable Capture
custom, Using the Simple Macro
improving, Avoiding Variable Capture

N

names of functions, available in defined functions, Defining Local Functions in Lisp
namespaces, for variables and functions, Converting the Edges to Descriptions
nconc in loop macro, Using Multiple for Clauses
neato command (Graphviz), Creating a Graph
negative infinity, Alpha Beta Pruning
neighbors function, The add-cops Function, Calculating Attacking Moves, Memoization
nested alists, The add-cops Function
nested forms, Code Mode
nested lists, The car and cdr Functions
nested loop macro, Using Multiple for Clauses
nested tags, in XML, Writing SVG Files
network computers, communication between, Working with Sockets
never in loop macro, Using Multiple for Clauses
new line, Printing to the Screen, Control Sequences for Formatting Floating-Point Numbers, Printing Multiple Lines of Output, Printing Multiple Lines of Output
before printing, Printing to the Screen
control sequences for, Printing Multiple Lines of Output
in printed output, Control Sequences for Formatting Floating-Point Numbers
new-game function, Building the Nodes for Congestion City, Known Edges
to draw known city, Known Edges
nil, Cons Cells, The cons Function, Making Decisions with Conditions, The Four Disguises of (), Exotic Lists, Dotted Lists
lists not ending with, Dotted Lists
symmetry of () and, Making Decisions with Conditions
nodes, Converting Node Identifiers, Adding Labels to Graph Nodes, The add-cops Function
for Congestion City, The add-cops Function
identifiers, converting, Converting Node Identifiers
nodes->dot function, Adding Labels to Graph Nodes, Converting Edges into DOT Format
nondeterministic programming, Synopsis
nonvisible characters, literals for, Starting with print and read
nth function, Using a Generic Setter
null function, Using Functions That Return More than Just the Truth
nullary functions, Using Thunks
numberp function, Sequence Functions for Iterating Across a Sequence
numbers, Numbers, Comparing Stuff: eq, equal, and More, Control Sequences for Formatting Numbers
comparison, Comparing Stuff: eq, equal, and More
control sequences for formatting, Control Sequences for Formatting Numbers

O

object-oriented programming (OOP) languages, Where Did Lisp Come From?, A Faster Grand Theft Wumpus Using Hash Tables, When to Use Structures, CLOS Guild Battleship
vs. Lisp, When to Use Structures
objects, Joining the Descriptions, Joining the Descriptions, Joining the Descriptions, Listing Visible Objects, Walking Around in Our World, Picking Up Objects
descriptions, Joining the Descriptions, Joining the Descriptions, Listing Visible Objects
at specific location, Joining the Descriptions
visible, Listing Visible Objects
inventory check, Picking Up Objects
picking up, Walking Around in Our World
objects-at function, Listing Visible Objects, Walking Around in Our World, Picking Up Objects
on in loop macro, Using Multiple for Clauses
OOP (object-oriented programming) languages, Where Did Lisp Come From?, A Faster Grand Theft Wumpus Using Hash Tables, When to Use Structures, CLOS Guild Battleship
vs. Lisp, When to Use Structures
optimizing functional code, Making Dice of Doom Faster, Making Dice of Doom Faster, Memoization, Tail Call Optimization
closures, Making Dice of Doom Faster
memoization, Memoization
tail call optimization, Tail Call Optimization
or operator, Branching with case
Orc Battle game, The Orc Battle Game, Global Variables for the Player and Monsters, Global Variables for the Player and Monsters, Global Variables for the Player and Monsters, Main Game Functions, Player Management Functions, Helper Functions for Player Attacks, Monster Management Functions, Monster Management Functions, The Monsters, The Generic Monster, The Malicious Hydra, The Malicious Hydra, The Slimy Slime Mold, To Battle!
global variables for player and monsters, Global Variables for the Player and Monsters
helper functions for player attacks, Player Management Functions
main game functions, Global Variables for the Player and Monsters
monster management functions, Helper Functions for Player Attacks
monsters, Global Variables for the Player and Monsters, Monster Management Functions, Monster Management Functions, The Monsters, The Generic Monster, The Malicious Hydra, The Malicious Hydra, The Slimy Slime Mold
checking for dead, Monster Management Functions
Cunning Brigand, The Slimy Slime Mold
functions for building, Global Variables for the Player and Monsters
generic, The Monsters
hydra, The Malicious Hydra
Slimy Slime Mold, The Malicious Hydra
Wicked Orc, The Generic Monster
player management functions, Main Game Functions
starting game, To Battle!
orc datatype, The Generic Monster
orc-battle function, Global Variables for the Player and Monsters, To Battle!
orthogonal issues, Making Our AI Work on Larger Game Boards
output streams, Streams by Direction, Output Streams, Input Streams
with-open-file command for, Input Streams
output-stream-p function, Output Streams

P

padded value, for format function, The Control String Parameter
padding parameter, for number width, Control Sequences for Formatting Numbers
pairs, Pairs
pairs function, A Recursion Macro, Creating the tag Macro
parallel games, web server for multiple, Limitations of Our Game Web Server
parameters, quoting, Writing a Custom read Function
parametric polymorphism, Where Did Lisp Come From?
paranoid strategy, Increasing the Number of Players
() parentheses, The Guess-My-Number Game
parentheses (), The Guess-My-Number Game, The Guess-My-Number Game, An Alternative Global Variable Definition Function, An Alternative Global Variable Definition Function, Basic Lisp Etiquette, Defining the start-over Function, The Building Blocks of Lisp Syntax, Making Decisions with Conditions
empty lists, Basic Lisp Etiquette, Making Decisions with Conditions
symmetry of nil and, Making Decisions with Conditions
for calling commands and functions, The Guess-My-Number Game, An Alternative Global Variable Definition Function
for list of declared variables in let, Defining the start-over Function
for organizing code into lists, The Building Blocks of Lisp Syntax
parse-integer function, Decoding the Values of Request Parameters
parse-params function, Decoding Lists of Request Parameters
parse-url function, Decoding Lists of Request Parameters
path descriptions, Describing the Paths, Describing the Paths, Describing the Paths
in game, Describing the Paths
multiple at once, Describing the Paths
performance, Coping with Complicated Data, Using a Generic Setter, Using a Generic Setter, Returning Multiple Values, A Faster Grand Theft Wumpus Using Hash Tables, Using the Functional Style, Making Dice of Doom Faster, Tail Call Optimization
arrays vs. lists, Using a Generic Setter
cons cells and, Coping with Complicated Data
for Dice of Doom game, Making Dice of Doom Faster
functional programming and, Using the Functional Style
hash tables and, Returning Multiple Values, A Faster Grand Theft Wumpus Using Hash Tables
tail calls and, Tail Call Optimization
permitted commands, adding to list, A Command for Welding
person-age function, Working with Structures
pi constant, Control Sequences for Formatting Floating-Point Numbers
pick-chance-branch function, Building Chance Nodes
pick-monster function, Player Management Functions
pickup function, Walking Around in Our World
picture, from DOT file, Generating All the DOT Data
play-vs-computer function, Turning Minimax into Actual Code, Trimming the Game Tree
play-vs-human function, Dice of Doom, Version 2
player function, Calculating Attacking Moves
player-attack function, Player Management Functions, Player Management Functions
police roadblocks, Building the Final Edges for Congestion City
polygon function, Creating SVG-Specific Macros and Functions
polygons, for die, Drawing the Game Board Using the SVG Format
port, Working with Sockets, Working with Sockets, Socket Connections
number in socket address, Working with Sockets
taking control of, Socket Connections
port 80, Our Grand Finale: The serve Function!
port 8080, Our Grand Finale: The serve Function!
position function, Working with Sequences, Decoding Lists of Request Parameters
positive infinity, Alpha Beta Pruning
POST request, How a Web Server Works
power, loop and format: The Seedy Underbelly of Lisp
predicates, Listing Visible Objects, Converting Node Identifiers
prin1 function, Printing to the Screen
prin1-to-string function, Writing a game-print Function, Converting Node Identifiers
princ function, Numbers, Reading and Printing Stuff the Way Humans Like It, Anatomy of the format Function, The Control String Parameter
print function, Printing and Reading Text, Saying Hello to the User
priority use, Saying Hello to the User
print-tag function, Creating XML and HTML with the tag Macro
printed representation, creating object from, Working with Structures
printing. See also format function, Printing and Reading Text, Using Thunks, Using Thunks, Control Sequences for Formatting Floating-Point Numbers, Printing Multiple Lines of Output
creating stream for functions, Using Thunks
multiple lines of output, Control Sequences for Formatting Floating-Point Numbers
text justification, Printing Multiple Lines of Output
to screen, Printing and Reading Text
problem solving, What You've Learned
progn command, One Thing at a Time with if
programming, Trimming the Game Tree, Applying Heuristics, Synopsis
heuristic techniques, Trimming the Game Tree
nondeterministic, Synopsis
programming language. See also macros, What Makes Lisp So Cool and Unusual?, Anatomy of a Program Written in the Functional Style, Higher-Order Programming
higher-order, Higher-Order Programming
learning, What Makes Lisp So Cool and Unusual?
properties in structures, A Faster Grand Theft Wumpus Using Hash Tables
push function, Walking Around in Our World, Association Lists, Preventing Islands, A Faster Grand Theft Wumpus Using Hash Tables, Output Streams
for hash table values, A Faster Grand Theft Wumpus Using Hash Tables
pushnew command, A Command for Welding, The game-action Macro
Python, Where Did Lisp Come From?

Q

quasiquoting, Describing the Paths
quit command, Starting Up CLISP
quote command, Writing a Custom read Function
quote-it function, Writing a Custom read Function
quoting, Data Mode

R

raise-price function, How It Kills Bugs
RAM, Arrays vs. Lists
random edges, The Grand Theft Wumpus Game, The Grand Theft Wumpus Game, Looping with the loop Command
and island prevention, Looping with the loop Command
generating, The Grand Theft Wumpus Game
random function, Player Management Functions, Representing the Game Board, Building a More Complicated SVG Example
random numbers, generating, Player Management Functions
random walk, Building a More Complicated SVG Example
random-monster function, Player Management Functions
random-node function, Generating Random Edges
random-plant function, Growing Plants in Our World
randval function, Player Management Functions, The Monsters
range of function, Ramping Lisp Up a Notch with Functional Programming
rate-position function, The Minimax Algorithm, Memoizing the neighbors Function, Winning by a Lot vs. Winning by a Little, Alpha Beta Pruning
new versions, Alpha Beta Pruning
rational number, function returning, Symbols
RDF (Resource Description Framework), What Makes Lisp So Cool and Unusual?
read function, Saying Hello to the User, The Dangers of read and eval, The Dangers of read and eval
danger of, The Dangers of read and eval
local variable for value returned by, Saying Hello to the User
read-char command, Input Streams
read-eval-print loop (REPL), Starting Up CLISP, The Guess-My-Number Game, Setting Up a Custom REPL, Writing a game-print Function, Creating Custom Game Commands for Wizard's Adventure Game
loading game code from, Creating Custom Game Commands for Wizard's Adventure Game
setting up custom, Setting Up a Custom REPL
testing, Writing a game-print Function
read-from-string function, Writing a Custom read Function, Limitations of Our Game Web Server
read-line function, Reading and Printing Stuff the Way Humans Like It
reader, The Building Blocks of Lisp Syntax
reader macros, The Dangers of read and eval
reading data, input streams for, Output Streams
recurse macro, Avoiding Variable Capture
recursion, Defining Local Functions in Lisp, Empty Equals False, Tail Call Optimization, Avoiding Variable Capture
in macros, Avoiding Variable Capture
reduce function, Working with Sequences, Sequence Functions for Iterating Across a Sequence
initial value for, Sequence Functions for Iterating Across a Sequence
reduced instruction set computer (RISC) hardware architecture, Where Did Lisp Come From?
reference, generalized, Using a Generic Setter
referential transparency, What Is Functional Programming?, Functional Programming Reduces Bugs
reinforcements, rules for choosing number in Dice of Doom, Improving the Dice of Doom Reinforcement Rules
remhash function, Handling Animal Turning
remove-duplicates function, The edges-to-alist Function, Determining the Winner
remove-if function, Determining the Winner
remove-if-not function, Listing Visible Objects, Preventing Islands
REPL. See read-eval-print loop (REPL), Handling Animal Reproduction
reproduce function, Handling Animal Reproduction, Handling Animal Reproduction
mutations with, Handling Animal Reproduction
request body, How a Web Server Works, Testing get-header with a String Stream
parsing, Testing get-header with a String Stream
request handler, testing, Our Grand Finale: The serve Function!
request header, How a Web Server Works, Decoding Lists of Request Parameters
parsing, Decoding Lists of Request Parameters
request parameters, How a Web Server Works, Request Parameters, Decoding the Values of Request Parameters, Decoding the Values of Request Parameters
decoding lists of, Decoding the Values of Request Parameters
decoding values for HTTP, Request Parameters
for web server, How a Web Server Works
request-handler function, Our Grand Finale: The serve Function!
request-handler parameter, Our Grand Finale: The serve Function!
Resource Description Framework (RDF), What Makes Lisp So Cool and Unusual?
resources, freeing up, Sending a Message over a Socket
response body, How a Web Server Works
response header, How a Web Server Works
restarts, Synopsis
return value, for command, Basic Lisp Etiquette
reverse function, Anatomy of the format Function
RISC (reduced instruction set computer) hardware architecture, Where Did Lisp Come From?
roll-dice function, Building Chance Nodes
round function, Returning Multiple Values
Ruby, Where Did Lisp Come From?
rule engine, Decoupling Dice of Doom's Rules from the Rest of the Game
runtime, Macro Expansion

S

say-hello function, Printing to the Screen
SBCL (Steel Bank Common Lisp), ANSI Common Lisp
scalable vector graphics (SVG). See SVG images, Basic Requirements
scenery description, association list for, Basic Requirements
Scheme, Lisp Dialects, Converting the Edges to Descriptions, Tail Call Optimization
namespace for, Converting the Edges to Descriptions
tail call optimization in, Tail Call Optimization
score-board function, Winning by a Lot vs. Winning by a Little
screen, printing to, Printing and Reading Text
Script-Fu Scheme, Lisp Dialects Used for Scripting
scripting, Lisp dialects for, A Tale of Two Lisps
searching, Working with Sequences, Mapping and Searching Across Lazy Lists, Mapping and Searching Across Lazy Lists
lazy lists, Mapping and Searching Across Lazy Lists
sequence functions for, Working with Sequences
security, eval function and, The Symmetry Between Code and Data in Lisp
self function, A Recursion Macro
self-referential data structures, Circular Lists
Semantic Web, If Lisp Is So Great, Why Don't More People Use It?
semantics, Exploring the Syntax of Lisp Code
sending message over socket, Socket Connections
sequence functions, When to Use Structures, Working with Sequences
for searching, Working with Sequences
sequences, When to Use Structures, Working with Sequences
iterating across, Working with Sequences
serve function, Testing get-header with a String Stream
server, for socket connection, Socket Connections
set-difference function, Preventing Islands
setf function, Defining the guess-my-number Function, Picking Up Objects, Circular Lists, Working with Arrays, Working with Structures, Memoization, Generic Setter Guild Supply Ship
for array, Working with Arrays
to change structure property, Working with Structures
shallow copy of structure, Handling Animal Reproduction
Short Code, Where Did Lisp Come From?
shortcut Boolean evaluation, Using the Stealth Conditionals and and or
show-monsters function, Monster Management Functions
shutting down CLISP, Starting Up CLISP
side effects, What Is Functional Programming?, Why Functional Programming Is Crazy, Synopsis
of functional programming, What Is Functional Programming?, Why Functional Programming Is Crazy
signaling condition, for error handling, Error Handling in Common Lisp
sin function, What Is Functional Programming?
' (single quote), as data indicator, Data Mode
single quote ('), as data indicator, Data Mode
slots, Working with Structures
smaller function, Defining the guess-my-number Function
socket streams, Working with Streams
socket, serve function creation of, Our Grand Finale: The serve Function!
socket-accept command, Sending a Message over a Socket
socket-connect command, Sending a Message over a Socket
socket-server function, Socket Connections
socket-server-close command, Tidying Up After Ourselves
sockets, Working with Files, Working with Sockets, Socket Connections, Socket Connections
addresses, Working with Sockets
connections, Socket Connections
sending message over, Socket Connections
software transactional memory, Synopsis
some function, Working with Sequences
sort function, Sequence Functions for Iterating Across a Sequence
special form, One Thing at a Time with if, One Thing at a Time with if, The Magic of Lisp Macros
if as, One Thing at a Time with if
let command as, The Magic of Lisp Macros
special variable, An Alternative Global Variable Definition Function
splash command, The game-action Macro
split macro, More Complex Macros
splitting lists, macro for, More Complex Macros
start-over function, Defining the start-over Function
starting CLISP, Starting Up CLISP
statistics, of dice rolls, Updating the AI
Steel Bank Common Lisp (SBCL), Getting Started with CLISP
Steele, Guy L., Lisp Dialects
streams, Creating a Stream, Working with Streams, Types of Streams, Input Streams, Input Streams, Sending a Message over a Socket, Sending a Message over a Socket
bidirectional, Sending a Message over a Socket
closing on network computer, Sending a Message over a Socket
commands to interact with, Input Streams
for files, Input Streams
types, Types of Streams
string builders, Working with Long Strings
string datatype, Describing the Scenery with an Association List
string streams, Streams by Type of Resource, Tidying Up After Ourselves, Working with Long Strings, Parsing the Request Header
debugging and, Working with Long Strings
get-header function testing with, Parsing the Request Header
string-downcase function, Creating XML and HTML with the tag Macro
string-equal function, Comparing Stuff: eq, equal, and More
stringp function, Sequence Functions for Iterating Across a Sequence
strings, Numbers, Writing a game-print Function, When to Use Structures
converting symbol list to, Writing a game-print Function
sequence functions for, When to Use Structures
Stroustrup, Bjarne, Where Does Lisp Get Its Power?
structures, A Faster Grand Theft Wumpus Using Hash Tables, When to Use Structures, When to Use Structures
vs. lists in Lisp code, When to Use Structures
when to use, When to Use Structures
subseq function, Sequence Functions for Iterating Across a Sequence
substitute-if function, Converting Node Identifiers
substitute-if-not function, Converting Node Identifiers
sum function, for arrays and lists, Sequence Functions for Iterating Across a Sequence
sum in loop macro, The loop Macro, Using Multiple for Clauses
suspension, Using Thunks
Sussman, Gerald Jay, Lisp Dialects
SVG images, What Is a Domain?, Using the tag Macro to Generate HTML, Creating SVG-Specific Macros and Functions, Creating SVG-Specific Macros and Functions, Creating SVG-Specific Macros and Functions, Drawing the Game Board Using the SVG Format
attributes for, Using the tag Macro to Generate HTML
circles, Creating SVG-Specific Macros and Functions
Dice of Doom game board using, Drawing the Game Board Using the SVG Format
polygons, Creating SVG-Specific Macros and Functions
writing, What Is a Domain?
svg macro, Using the tag Macro to Generate HTML
SVG Web, Writing SVG Files
svg-style function, Creating SVG-Specific Macros and Functions
symbol-function command, Memoization
symbolp function, Sequence Functions for Iterating Across a Sequence
symbols, The Building Blocks of Lisp Syntax, Comparing Stuff: eq, equal, and More, Describing the Scenery with an Association List, Writing a game-print Function
benefits of using, Describing the Scenery with an Association List
comparing, Comparing Stuff: eq, equal, and More
converting list to string, Writing a game-print Function
symmetry, Making Decisions with Conditions, Making Decisions with Conditions, Reading and Printing Stuff the Way Humans Like It
between code and data, Reading and Printing Stuff the Way Humans Like It
of () and nil, Making Decisions with Conditions
syntax, Exploring the Syntax of Lisp Code, Syntax and Semantics, Syntax and Semantics
and semantics, Exploring the Syntax of Lisp Code
building blocks for Lisp, Syntax and Semantics

T

tab variable, Memoizing the rate-position Function
tables, Printing Multiple Lines of Output, Justifying Output, Iterating Through Lists Using Control Sequences
output as, Printing Multiple Lines of Output
trick for creating pretty, Iterating Through Lists Using Control Sequences
tag macro, Creating the tag Macro, Creating the tag Macro
to generate HTML, Creating the tag Macro
tail call, Tail Call Optimization
tail call optimization, Tail Call Optimization
take function, Converting Between Regular Lists and Lazy Lists
take-all function, Converting Between Regular Lists and Lazy Lists
TCP packets, Socket Addresses
TCP/IP, How a Web Server Works
technologies supporting Lisp, comic book, Epilogue
terpri function, Control Sequences for Formatting Floating-Point Numbers
test functions, Converting Node Identifiers
testing, Writing a game-print Function, Parsing the Request Header, Parsing the Request Header
get-header function with string stream, Parsing the Request Header
user interface, Writing a game-print Function
text game interface, Adding a Custom Interface to Our Game Engine, Writing a game-print Function
testing, Writing a game-print Function
text. See also strings, Building a Text Game Engine, Writing a game-print Function, Printing Multiple Lines of Output, Iterating Through Lists Using Control Sequences, Iterating Through Lists Using Control Sequences
breaking into equal length pieces, Iterating Through Lists Using Control Sequences
converting all caps to capitalized, Writing a game-print Function
justified, Printing Multiple Lines of Output
processing, Building a Text Game Engine
then in loop macro, Using Multiple for Clauses
thereis in loop macro, Using Multiple for Clauses
threatened function, Winning by a Lot vs. Winning by a Little
threatened hex, in Dice of Doom, Winning by a Lot vs. Winning by a Little
three-way-if macro, Macro Guild Melee Fighters
thunks, Generating All the DOT Data, Capturing the Console Output
for creating graph picture, Capturing the Console Output
˜ (tilde), for control sequences, The Control String Parameter
tilde (˜), for control sequences, The Control String Parameter
time command, Hash Table Performance
to in loop macro, Using Multiple for Clauses
top-level definition of variable, The Guess-My-Number Game
tree-like data, Coping with Complicated Data
true/false functions, Listing Visible Objects
turn function, for animals, Handling Animal Motion
tweak-text function, Writing a game-print Function
type dispatching, Creating Your Own Generic Functions with Type Predicates
type predicates, for generic functions, Sequence Functions for Iterating Across a Sequence
type-checking, Working with Sequences, Working with Sequences
in generic functions, Working with Sequences
type-of function, The Monsters

U

uedges->dot function, Creating Undirected Graphs
ugraph->dot function, Creating Undirected Graphs
ugraph->png function, Creating Undirected Graphs, Initializing a New Game of Grand Theft Wumpus
undirected graphs, Creating a Picture of Our Graph
unless, Going Beyond if: The when and unless Alternatives, Using Multiple for Clauses
in loop macro, Using Multiple for Clauses
unwind-protect function, Protecting Resources Against Unexpected Conditions, Our Grand Finale: The serve Function!
update-world function, Handling Animal Reproduction
upfrom in loop macro, Using Multiple for Clauses
upto in loop macro, Using Multiple for Clauses
URLs for web pages, name/value pairs in, Decoding the Values of Request Parameters
user interface, Interacting with the World: Reading and Printing in Lisp, Interacting with the World: Reading and Printing in Lisp, Printing and Reading Text, The Symmetry Between Code and Data in Lisp, Writing a game-print Function, Drawing Our World
command-line, Interacting with the World: Reading and Printing in Lisp, Printing and Reading Text
printing to screen, Printing and Reading Text
for evolving environment game, Drawing Our World
for Wizard’s Adventure Game, The Symmetry Between Code and Data in Lisp
testing, Writing a game-print Function
usocket, Working with Sockets

V

vacuum-tube computer systems, If Lisp Is So Great, Why Don't More People Use It?
values function, Returning Multiple Values
variable capture, Avoiding Repeated Execution in Macros
variable shadowing, Tail Call Optimization
variables. See also global variables; local variables, The Guess-My-Number Game, The Guess-My-Number Game, Defining the start-over Function, Basic Requirements, Converting the Edges to Descriptions, Capturing the Console Output, The make-city-edges Function, What Is Functional Programming?, Functional Programming Reduces Bugs, Closures, Closures, Avoiding Variable Capture, Generic Setter Guild Supply Ship
asterisks (*) in names, The Guess-My-Number Game
declaration in let command, Defining the start-over Function
defining, The make-city-edges Function
destruction, Closures
for location descriptions, Basic Requirements
function to create unique name, Avoiding Variable Capture
in functional programming, What Is Functional Programming?, Functional Programming Reduces Bugs
lexical, Capturing the Console Output, Closures
modifying value, Generic Setter Guild Supply Ship
namespaces for, Converting the Edges to Descriptions
versions of function, Creating Your Own Generic Functions with Type Predicates
| (vertical pipe), for case-sensitive symbols, Starting with print and read
vertical pipe (|), for case-sensitive symbols, Starting with print and read
virtual memory paging, performance impact, Returning Multiple Values
visible objects, describing, Listing Visible Objects
visual noise, A Simple Lisp Macro
visualizing graphs, Visualizing Tree-like Data

W

walk function, Walking Around in Our World, Drawing Only the Known Parts of the City
web forms, Request Parameters
web resources, If Lisp Is So Great, Why Don't More People Use It?, ANSI Common Lisp, ANSI Common Lisp, Creating a Graph
downloading CLISP installer, ANSI Common Lisp
for Graphviz, Creating a Graph
Lisp projects, If Lisp Is So Great, Why Don't More People Use It?
web server, Protecting Resources Against Unexpected Conditions, Writing a Web Server from Scratch, How a Web Server Works, Decoding Lists of Request Parameters, Testing get-header with a String Stream, Testing get-header with a String Stream, Drawing the Board, Writing Our Web Request Handler, Limitations of Our Game Web Server, Handling the Computer Player, How It Kills Bugs
continuation-aware, How It Kills Bugs
how it works, Protecting Resources Against Unexpected Conditions
interface for Dice of Doom, Drawing the Board, Writing Our Web Request Handler, Limitations of Our Game Web Server, Handling the Computer Player
for computer player, Handling the Computer Player
for human player, Limitations of Our Game Web Server
limitations, Writing Our Web Request Handler
parsing request body, Testing get-header with a String Stream
parsing request header, Decoding Lists of Request Parameters
request parameters, How a Web Server Works
serve function, Testing get-header with a String Stream
web-announce-winner function, Limitations of Our Game Web Server
web-handle-human function, Limitations of Our Game Web Server
web-initialize function, Writing Our Web Request Handler, Limitations of Our Game Web Server
webserver.lisp file, Drawing the Game Board Using the SVG Format
website, Our Grand Finale: The serve Function!, Our Grand Finale: The serve Function!, Testing the Request Handler
dynamic, Our Grand Finale: The serve Function!
launching, Testing the Request Handler
weld function, A Command for Welding, The game-action Macro
when in loop macro, Using Multiple for Clauses
when token, Going Beyond if: The when and unless Alternatives, Counting from a Starting Point to an Ending Point
winners function, Giving Information About the State of the Game
with-open-file command, Using Thunks, Understanding Keyword Parameters, Capturing the Console Output, Input Streams
with-open-stream macro, Our Grand Finale: The serve Function!
with-output-to-string macro, Working with Long Strings
Wizard’s Adventure Game, Building a Text Game Engine, Our Game World, Our Game World, Basic Requirements, Describing the Scenery with an Association List, Describing the Paths, Joining the Descriptions, Describing Visible Objects, Walking Around in Our World, Walking Around in Our World, Picking Up Objects, The Symmetry Between Code and Data in Lisp, Visualizing Tree-like Data, Converting Edges into DOT Format, Creating Custom Game Commands for Wizard's Adventure Game, Creating New Game Commands by Hand, A Command for Welding, A Command for Dunking, The game-action Macro
basic requirements, Our Game World
custom game commands, Creating Custom Game Commands for Wizard's Adventure Game, Creating New Game Commands by Hand, A Command for Welding, A Command for Dunking
dunk, A Command for Welding
game-action macro, A Command for Dunking
welding, Creating New Game Commands by Hand
custom interface, The Symmetry Between Code and Data in Lisp
DOT information for, Converting Edges into DOT Format
location descriptions, Describing the Scenery with an Association List
look command, Describing Visible Objects
map of house in alists, Visualizing Tree-like Data
object descriptions at specific location, Joining the Descriptions
object inventory check, Picking Up Objects
path descriptions, Describing the Paths
picking up objects, Walking Around in Our World
playing completed version, The game-action Macro
scenery description with association list, Basic Requirements
walk function, Walking Around in Our World
world for, Building a Text Game Engine
write-char command, Output Streams

X

XML, Visualizing Tree-like Data
XML format, Writing SVG Files, Writing SVG Files, Writing SVG Files
and SVG format, Writing SVG Files
nested tags, Writing SVG Files
xmlns attribute, Using the tag Macro to Generate HTML

Z

zero, dividing by, One Thing at a Time with if
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
3.144.96.105