The Joy of Clojure

from inner functions. But built on Clojure’s dynamic Var binding is a more active

mode of error handling, where handlers are pushed into inner functions. In section

11.10, we mentioned that the binding form is used to create thread-local bindings,

but its utility isn’t limited to this use case. In its purest form, dynamic scope is a struc-

tured form of a side effect (Steele 1978). You can use it to push Vars down a call stack

from the outer layers of a function nesting into the inner layers, a technique that we’ll

demonstrate next.

DYNAMIC TREE TRAVERSAL

In section 8.4, we built a simple tree structure for a domain model where each node

was of this form:

{:tag <node form>, :attrs {}, :content [<nodes>]}

As it turns out, the traversal of a tree built from such nodes is straightforward using

mundane recursion, as shown:

(defn traverse [node f]

(when node

(f node)

(doseq [child (:content node)]

(traverse child f))))

For each node in the tree, the function f is called with the node itself, and then each

of the node’s children is traversed in turn. Observe how traverse works for a single

root node:

(traverse {:tag :flower :attrs {:name "Tanpopo"} :content []}

println)

; {:tag :flower, :attrs {:name Tanpopo}, :content []}

But it’s much more interesting if we traverse trees larger than a single node. There-

fore, we can build a quick tree from an XML representation using Clojure’s clojure.

xml/parse function:

(use '[clojure.xml :as xml])

(def DB

(-> "<zoo>

<pongo>

<animal>orangutan</animal>

Download from Wow! eBook <www.wowebook.com>

Error handling and debugging

307

</pongo>

<animal>Lopshire</animal>

</panthera>

</zoo>"

.getBytes

(java.io.ByteArrayInputStream.)

xml/parse))

The DB Var contains an animal listing for a small zoo. Note that two of the animals

listed have the elements Spot and Lopshire; both are seemingly out of order for a

zoo. Therefore, we can write a function to handle these nefarious intruders.

Listing 13.8 Handling nefarious tree nodes with exceptions

(defn ^{:dynamic true} handle-weird-animal

[{[name] :content}]

Define error handler

(throw (Exception. (str name " must be 'dealt with'"))))

(defmulti visit :tag)

(defmethod visit :animal [{[name] :content :as animal}]

(case name

"Spot" (handle-weird-animal animal)

"Lopshire" (handle-weird-animal animal)

(println name)))

(defmethod visit :default [node] nil)

The multimethod visit can be used as the input function to the traverse function

and will only trigger when a node with the :tag attribute of :animal is encountered.

When the method triggered on :animal is executed, the node :content is destruc-

tured and checked against the offending Spot and Lopshire values. When found, the

devious node is then passed along to an error handler handle-weird-animal for

reporting.5 By default, the error handler throws an exception. This model of error

handling is the inside-out model of exceptions. But handling errors in this way stops

the processing:

(traverse DB visit)

; orangutan

; java.lang.Exception: Spot must be 'dealt with'

We’ve managed to identify Spot, but the equally repugnant Lopshire escapes our

grasp. It’d be nice to instead use a different version of handle-weird-animal that

allows us to both identify and deal with every such weird creature. We could pass

handle-weird-animal along as an argument to be used as an error continuation,6 but

The metadata {:dynamic true} attached to handle-weird-animal isn’t really used in Clojure 1.2, but it

may be required in future versions of Clojure starting with 1.3 to allow the dynamic binding we’re about to

demonstrate.

See section 7.3 for more information on continuation-passing style.

Download from Wow! eBook <www.wowebook.com>

308

CHAPTER 13 Clojure changes the way you think

that pollutes the argument list of every function along the way. Likewise, we could

inject catch blocks at a point further down the call chain, say within visit, but we

might not be able to change the source, and if we could it makes for a more insidious

pollution. Instead, using a dynamic binding is a perfect solution, because it allows us

to attach specific error handlers at any depth in the stack according to their appropri-

ate context:

(defmulti handle-weird (fn [{[name] :content}] name))

(defmethod handle-weird "Spot" [_]

(println "Transporting Spot to the circus."))

(defmethod handle-weird "Lopshire" [_]

(println "Signing Lopshire to a book deal."))

(binding [handle-weird-animal handle-weird]

(traverse DB visit))

; orangutan

; Transporting Spot to the circus.

; lion

; Signing Lopshire to a book deal.

As you might expect, this approach works across threads to allow for thread-specific

handlers:

(def _ (future

(binding [handle-weird-animal #(println (:content %))]

(traverse DB visit))))

; orangutan

; [Spot]

; lion

; [Lopshire]

What we’ve outlined here is a simplistic model for a grander error-handling scheme.

Using dynamic scope via binding is the preferred way to handle recoverable errors in

a context-sensitive manner.

13.4.2 Debugging

The natural progression of debugging techniques as discovered by a newcomer to

Clojure follows a fairly standard progression:

(println)

A macro to make (println) inclusion simpler

Some variation on debugging as discussed in this section

IDEs, monitoring, and profiling tools

Many Clojure programmers stay at step 1, because it’s simple to understand and also

highly useful, but there are better ways. After all, you’re dealing with Clojure—a

highly dynamic programming environment. Observe the following function:

(defn div [n d] (int (/ n d)))

Download from Wow! eBook <www.wowebook.com>

Error handling and debugging

309

The function div simply divides two numbers and returns an integer value. You can

break div in a number of ways, but the most obvious is to call it with zero as the

denominator: (div 10 0). Such an example would likely not give you cause for con-

cern should it fail, because the conditions under which it fails are fairly limited, well

known, and easily identified. But not all errors are this simple, and the use of println

is fairly limited. Instead, a better tool would likely be a generic breakpoint7 that could

be inserted at will and used to provide a debug console for the current valid execution

context. Imagine it would work as follows:

(defn div [n d] (break) (int (/ n d)))

(div 10 0)

debug=>

At this prompt, you can query the current lexical environment, experiment with dif-

ferent code, and then resume the previous execution as before. As it turns out, such a

tool is within your grasp.

A BREAKPOINT MACRO

We hope that by the end of this section, you’ll understand that Lisps in general, and

Clojure in particular, provide an environment where the whole of the language truly is

“always available” (Graham 1993). First of all, an interesting fact to note is that the

Clojure REPL is available and extensible via the Clojure REPL itself, via the clojure.

main/repl function. By accessing the REPL implementation directly, you can custom-

ize it as you see fit for application-specific tasks.

Typing (clojure.main/repl) at the REPL seemingly does nothing, but rest

assured you’ve started a sub-REPL. What use is this? To start, the repl function takes a

number of named parameters, each used to customize the launched REPL in different

ways. We’ll utilize three such hooks—:prompt, :eval, and :read—to fulfill a break-

point functionality.

OVERRIDING THE REPL’S READER

The repl function’s :read hook takes a function of two arguments: the first corre-

sponding to a desired display prompt, and the second to a desired exit form. We want

the debug console to provide convenience functions—we’d like it to show all of the

available lexical bindings and also to resume execution. It also needs to be able to

read valid Clojure forms, but because that’s too complex a task, we’ll instead farm that

functionality out to Clojure’s default REPL reader.

Listing 13.9 A modest debug console reader

(defn readr [prompt exit-code]

(let [input (clojure.main/repl-read prompt exit-code)]

(if (= input ::tl)

exit-code

input)))

7 The code in this section is based on debug-repl created by the amazing George Jahad, extended by Alex

Osborne, and integrated into Swank-Clojure by Hugo Duncan.

Download from Wow! eBook <www.wowebook.com>

310

CHAPTER 13 Clojure changes the way you think

We can start testing the reader immediately:

(readr #(print "invisible=> ") ::exit)

[1 2 3]

;=> [1 2 3]

(readr #(print "invisible=> ") ::exit)

::tl

;=> :user/exit

The prompt that we specified was of course not printed, and typing ::tl at the

prompt did nothing because the readr function isn’t yet provided to the repl as its

:read hook. But before we do that, we need to provide a function for the :eval hook.

Needless to say, this is a more complex task.

OVERRIDING THE REPL’S EVALUATOR

In order to evaluate things in context, we first need a function cab to garner the bind-

ings in the current context. Fortunately for us, Clojure macros provide an implicit

argument &env that’s a map of the local bindings available at macro-expansion time.

We can then extract from &env the values associated with the bindings and zip them

up with their names into a map for the local context, as shown next.

Listing 13.10 Creating a map of the local context using &env

(defmacro local-context []

(let [symbols (keys &env)]

(zipmap (map (fn [sym] `(quote ~sym)) symbols) symbols)))

(local-context)

;=> {}

(let [a 1, b 2, c 3]

(let [b 200]

(local-context)))

;=> {a 1, b 200, c 3}

The local-context macro provides a map to the most immediate lexical bindings,

which is what we want. But what we really want to do is to provide a way to evaluate

expressions with this contextual bindings map. Wouldn’t you know it, the contextual-

eval function from section 8.1 fits the bill. So now that we have the bulk of the imple-

mentation complete, we’ll now hook into the repl function to provide a breakpoint

facility.

PUTTING IT ALL TOGETHER

The hard parts are done, so to wire them into a usable debugging console is relatively

easy, as shown next.

Listing 13.11 The implementation of a breakpoint macro

(defmacro break []

`(clojure.main/repl

:prompt #(print "debug=> ")

:read readr

:eval (partial contextual-eval (local-context))))

Download from Wow! eBook <www.wowebook.com>

Error handling and debugging

311

Using this macro, we can now debug the original div function:

(defn div [n d] (break) (int (/ n d)))

(div 10 0)

debug=>

Querying locals to find the “problem” is simple:

debug=> n

;=> 10

debug=> d

;=> 0

debug=> (local-context)

;=> {div #<user$div__155 user$div__155@51e67ac>, n 10, d 0}

debug=> ::tl

; java.lang.ArithmeticException: Divide by zero

So there’s the problem! We passed in a zero as the denominator. We should fix that.

MULTIPLE BREAKPOINTS AND BREAKPOINTS IN MACROS

What would be the point if you couldn’t set multiple breakpoints? Fortunately, you

can, as we show in the following listing.

Listing 13.12 Using multiple breakpoints in function keys-apply

(defn keys-apply [f ks m]

(break)

(let [only (select-keys m ks)]

(break)

(zipmap (keys only) (map f (vals only)))))

(keys-apply inc [:a :b] {:a 1, :b 2, :c 3})

debug=> only

; java.lang.Exception: Unable to resolve symbol: only in this context

debug=> ks

;=> [:a :b]

debug=> m

;=> {:a 1, :b 2, :c 3}

debug=> ::tl

debug=> only

;=> {:b 2, :a 1}

debug=> ::tl

;=> {:a 2, :b 3}

And finally, you can use breakpoints within the body of a macro (in its expansion, not

its logic), as shown next.

Listing 13.13 Using a breakpoint in a macro awhen

(defmacro awhen [expr & body]

(break)

`(let [~'it ~expr]

(if ~'it

(do (break) ~@body))))

(awhen [1 2 3] (it 2))

Download from Wow! eBook <www.wowebook.com>

312

CHAPTER 13 Clojure changes the way you think

debug=> it

; java.lang.Exception: Unable to resolve symbol: it in this context

debug=> expr

;=> [1 2 3]

debug=> body

;=> ((it 2))

debug=> ::tl

debug=> it

;=> [1 2 3]

debug=> (it 1)

;=> 2

debug=> ::tl

;=> 3

There’s much room for improvement, but we believe that the point has been made.

Having access to the underpinnings of the language allows you to create a powerful

debugging environment with little code. We’ve run out of ideas by now, so we’ll say

our credo only once more, and we hope by now you believe us.

Clojure changes the way that you think.

13.5

Fare thee well

This book possess many lacunae, but it’s this way by design. In many cases, we’ve

skipped approaches to solving problems via a certain route to avoid presenting non-

idiomatic code. In many examples, we’ve left exposed wiring. For example, the

defcontract macro requires that you partially apply the contract to the function

under constraint instead of providing a comprehensive contract overlay façade. It was

our goal to leave wiring exposed because exposed wiring can be explored, tampered

with, and ultimately enhanced—which we hope you’ll find the motivation to do.

We’ve worked hard to provide a vast array of relevant references should you choose

to further enhance your understanding of the workings and motivations for Clojure.

But it’s likely that we’ve missed some excellent resources, and we hope that you

instead are able to uncover them in time. Finally, this wasn’t a survey of Clojure, and

many of the functions available to you weren’t used in this book. We provide some

pointers in the resource list, but there’s no way that we could do justice to the librar-

ies and applications mentioned and those unmentioned. We implore you to look

deeper into the functionality of not only Clojure, but the rich ecology of libraries and

applications that have sprung up in its relatively short life span.

Thank you for taking the time to read this book; we hope it was as much a pleasure

to read as it was for us to write. Likewise, we hope that you’ll continue your journey

with Clojure. Should you choose to diverge from this path, then we hope that some of

what you’ve learned has helped you to view the art of programming in a new light.

Clojure is an opinionated language, but it and most of its community believe that

these opinions can work to enhance the overall state of affairs in our software indus-

try. The onus is on us to make our software robust, performant, and extensible. We

believe that the path toward these goals lies with Clojure.

Do you?

—FOGUS AND HOUSER 2010

Download from Wow! eBook <www.wowebook.com>

resources

Miscellaneous resources

Abadi, Martin, and Luca Cardelli. 1996. A Theory of Objects. New York: Springer. Although not a math-

ematical concept, object-oriented programming has obtained rigor with this gem.

Abelson, Harold, and Gerald Jay Sussman. 1988. “ Lisp: A Language for Stratified Design.” AI Memo

(MIT) 986.

———. 1996. Structure and Interpretation of Computer Programs. Cambridge, MA: MIT Press. There is no

better book for learning Scheme and the fine art of programming.

Abiteboul, Serge, Richard Hull, and Victor Vianu. 1995. Foundations of Databases. Boston: Addison-

Wesley. Clojure’s clojure.set namespace is actually modeled more on the named conjunctive

algebra, for which this book provides a great reference.

Armstrong, Joe. 2007. Programming Erlang. Raleigh, NC: Pragmatic Bookshelf.

———. 2007. “A History of Erlang.” Proceedings of the Third ACM SIGPLAN Conference on History of Pro-

gramming Languages.

Bagwell, Phil. 2001. Ideal Hash Trees. Technical report. Clojure’s persistent data structures owe a lot to

Phil Bagwell’s paper.

Baker, Henry. 1993. “Equal Rights for Functional Objects or, The More Things Change, The More

They Are the Same.” ACM SIGPLAN OOPS Messenger 4, no. 4.

Beck, Kent. 2002. Test Driven Development: By Example. Boston: Addison-Wesley.

Bloch, Joshua. 2008. Effective Java. Upper Saddle River, NJ: Addison-Wesley.

Boncz, Peter, Zukowski Marcin, and Niels Nes. 2005. “MonetDB/X100: Hyper-Pipelining Query 

Execution.” Proceedings of the CIDR Conference. This paper motivated the implementation of

chunked sequences.

Bratko, Ivan. 2000. PROLOG: Programming for Artificial Intelligence. New York: Addison Wesley.

Budd, Timothy. 1995. Multiparadigm Programming in Leda. Reading, MA: Addison-Wesley. This is an

expanded discussion of the complexities wrought from a mono-paradigm approach to software

development.

Clinger, William. 1998. “Proper Tail Recursion and Space Efficiency.” Proceedings of the ACM SIGPLAN

1998 Conference on Programming Language Design and Implementation.

Cormen, Thomas, Charles Leiserson, Ronald Rivest, and Clifford Stein. 2009. Introduction to Algo-

rithms. Cambridge, MA: MIT Press. This is a great reference on algorithmic complexity and Big-

O, and as an added bonus, you could use it to stop a charging rhinoceros.

313

Download from Wow! eBook <www.wowebook.com>

314

RESOURCES

Crockford, Douglas. 2008. JavaScript: The Good Parts. Yahoo Press.

Date, C.J. 2009. SQL and Relational Theory: How to Write Accurate SQL Code. Sebastopol, CA: O’Reilly.

Dijkstra, Edsger Wijbe. 1959. “ A Note on Two Problems in Connexion with Graphs.” Numerische Mathema-

tik 1, no. 1. You could change the h function in listing 7.9 to (defn dijkstra-estimate-cost

[step-cost-est sz y x] 0) to conform to the ideal presented in this paper.

Flanagan, David. 2006. JavaScript: The Definitive Guide. Sebastopol, CA: O’Reilly.

Forman, Ira, and Nate Forman. 2004. Java Reflection in Action. Greenwich, CT: Manning. Although reflec-

tion provides some meta-level manipulation, it’s quite apart from the notion of functions as data.

Friedl, Jeffrey. 1997. Mastering Regular Expressions. Sebastopol, CA: O’Reilly.

Friedman, Daniel, Mitchell Wand, and Christopher T. Haynes. 2001. Essentials of Programming Languages.

Cambridge, MA: MIT Press.

Gabriel, Richard, and Kent Pitman. 2001. “Technical Issues of Separation in Function Cells and Value

Cells.” This is a more thorough examination of the differences between Lisp-1 and Lisp-2.

Gamma, Erich, Richard Helm, Ralph Johnson, and John Vlissides. 1995. Design Patterns: Elements of 

Reusable Object-Oriented Software. Reading, MA: Addison-Wesley.

Ghosh, Debasish. 2010. DSLs in Action. Greenwich, CT: Manning. There is a much finer level of distinc-

tion determining what constitutes whole cloth, including that between internal and external DSLs.

In this book, we focus on the classical Lisp model of internal DSLs, but DSLs in Action provides a sur-

vey of many DSL-creation techniques.

Glickstein, Bob. 1997. Writing GNU Emacs Extension s. Sebastopol, CA: O’Reilly.

Goetz, Brian. 2006. Java Concurrency in Practice. Upper Saddle River, NJ: Addison-Wesley. Why haven’t you

read this yet?

Goldberg, David. 1991. “ What Every Computer Scientist Should Know About Floating-Point Arithmetic.”

Computing Surveys (March).

Graham, Paul. 1993. On Lisp. Englewood Cliffs, NJ: Prentice Hall. Is there any book or any author more

influential to the current generation of dynamic programmers than Graham and On Lisp?

———. 1995. ANSI Common Lisp. Englewood Cliffs, NJ: Prentice Hall.

Gray, Jim, and Andreas Reuter. 1992. Transaction Processing: Concepts and Techniques. San Mateo, CA: Mor-

gan Kaufmann Publishers.

Halloway, Stuart. 2009. “ Clojure is a better Java than Java .” Presented at the Greater Atlanta Software

Symposium, Atlanta. The origin of the phrase “Java.next” most likely stems from this talk by 

Halloway.

Hart, Peter, Nils Nilsson, and Bertram Raphael. 1968. “A Formal Basis for the Heuristic Determination

of Minimum Cost Paths.” IEEE Transactions on Systems Science and Cybernetics In Systems Science and

Cybernetics 4, no. 2.

Hewitt, Carl, Peter Bishop, and Richard Steiger. 1973. “ A Universal Modular ACTOR Formalism for Arti-

ficial Intelligence .” Proceedings of the Third International Joint Conference on Artificial Intelligence.

Heinlein, Robert. 1966. The Moon Is a Harsh Mistress. New York: Putnam. We had considered offering an

implementation of Mike as an appendix, but we ran over our page count.

Herlihy, Maurice, and Nir Shavit. 2008. The Art of Multiprocessor Programming. Amsterdam; Boston:

Elsevier/Morgan Kaufmann.

Hickey, Rich. 2009. “ Are We There Yet?” Presented at JVM Languages Summit. This wonderful presenta-

tion made firm the popular view of Rich as Philosopher Programmer.

Hofstadter, Douglas. 1979. Gödel, Escher, Bach: An Eternal Golden Braid. New York: Basic Books. See the sec-

tions “Classes and Instances,” “The Prototype Principle,” and “The Splitting-off of Instances from

Classes” for more detail of the topics in section 9.2.

Download from Wow! eBook <www.wowebook.com>

RESOURCES

315

Hoyte, Doug. 2008. Let Over Lambda. Lulu.com. This is an amazing look into the mind-bending power of

Common Lisp macros that provided the motivation for the DSLs section of this book. It will blow

your mind—in a good way.

Hudak, Paul. 2000. The Haskell School of Expression: Learning Functional Programming Through Multimedia.

New York: Cambridge University Press.

Huet, Gerard. 1997. “Functional Pearl: The Zipper.” Journal of Functional Programming.

Hutton, Graham. 1999. “A Tutorial on the Universality and Expressiveness of fold.” Journal of Functional

Programming 9, no. 4.

Kahan, William, and Joseph Darcy. 1998. “How Java’s Floating-Point Hurts Everyone Everywhere.” Pre-

sented at the ACM Workshop on Java for High-Performance Network Computing. This paper pro-

vides more information on the cyclopian nightmares awaiting you in Java floating point.

Keene, Sonya. 1989. Object-Oriented Programming in Common Lisp: A Programmer’s Guide to CLOS. Boston:

Addison-Wesley. The best book on CLOS ever written.

Knuth, Donald. 1997. The Art of Computer Programming: Volume 1 - Fundamental Algorithms. Reading, MA:

Addison-Wesley. This book goes into exquisite detail about the primary characteristics of FIFO

queues and is highly recommended reading.

———. 1998. The Art of Computer Programming, Vol. 3: Sorting and Searching. Reading, MA: Addison-Wesley.

Running quick-sort on a sorted sequence is an O(n2) operation, which for our implementation in

chapter 6 completely defeats its laziness.

Koenig, Dierk, Andrew Glover, Paul King, Guilaume LaForge, and Jon Skeet. 2007. Groovy in Action.

Greenwich, CT: Manning.

Kuki, Hirondo, and William James Cody. 1973. “A Statistical Study of the Accuracy of Floating Point

Number Systems.” Communications of the ACM 1973 16, no. 4.

Laddad, Ramnivas. 2003. AspectJ in Action: Practical Aspect-Oriented Programming. Greenwich, CT: 

Manning. We do not do justice to the notion of aspects—so read this instead.

Martin, Robert. 2002. Agile Software Development: Principles, Patterns, and Practices. Upper Saddle River, NJ:

Prentice Hall.

McCarthy, John. 1960. “Recursive Functions of Symbolic Expressions and Their Computation by

Machine, Part I.” Communications of the ACM. This is the essay that started it all.

———. 1962. LISP 1.5 Programmer’s Manual. Cambridge, MA: MIT Press. Lisp had an array type at least as

early as 1962. Sadly, this fact is little known.

McConnell, Steve. 2004. Code Complete: A Practical Handbook of Software Construction. Redmond, WA: 

Microsoft Press.

Meyer, Bertrand. 1991. Eiffel: The Language. New York: Prentice Hall. The programming language Eiffel

relies heavily on contract-based programming methodologies, a cornerstone element of Fogus’s

philosophy of Apperception-Driven Development.

———. 2000. Object-Oriented Software Construction. Upper Saddle River, NJ: Prentice Hall.

Michie, Donald. 1968. “ Memo Functions and Machine Learning.” Nature 218.

Mooers, Calvin, and Peter Deutsch. 1965. “TRAC, A Text-Handling Language.”

Moseley, Ben, and Peter Marks. 2006. “Out of the Tar Pit.” Presented at SPA2006.

Mozgovoy, Maxim. 2009. Algorithms, Languages, Automata, and Compilers: A Practical Approach. Sudbury,

MA: Jones and Bartlett Publishers.

Noble, James, and Brian Foote. 2003. “Attack of the Clones.” Proceedings of the 2002 Conference on Pattern

Languages of Programs 13. The clone function is inspired by this paper.

Norvig, Peter. 1991. Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp. San Fran-

cisco: Morgan Kaufman Publishers.

Download from Wow! eBook <www.wowebook.com>

316

RESOURCES

Odersky, Martin, Lex Spoon, and Bill Venners. 2008. Programming in Scala: A Comprehensive Step-by-step

Guide. Mountain View, CA: Artima.

Okasaki, Chris. 1996. “ The Role of Lazy Evaluation in Amortized Data Structures.” Presented at the

International Conference on Functional Programming. This is a much more thorough discussion

of incremental vs. monolithic computation.

———. 1999. Purely Functional Datastructures. Cambridge University Press. Chris Okasaki to the rescue

again! Clojure’s persistent queue implementation is based on Okasaki’s batched queue from this

seminal work.

Olsen, Russ. 2007. Design Patterns in Ruby . Upper Saddle River, NJ: Addison-Wesley

Papadimitriou, Christos. 1986. Theory of Database Concurrency Control. New York: Computer Science 

Press, Inc.

Pierce, Benjamin. 2002. Types and Programming Languages. Cambridge, MA: MIT Press. Fun fact: Repre-

senting numbers using lambda calculus is known as church encoding. The church-encoded number

9 would be represented as (fn [f] (fn [x] (f (f (f (f (f (f (f (f (f x))))))))))) in 

Clojure.

Raymond, Eric. 2003. The Art of Unix Programming. Reading, MA: Addison-Wesley Professional.

Rosenberg, Doug, Mark Collins-Cope, and Matt Stephens. 2005. Agile Development with ICONIX Process: 

People, Process, and Pragmatism. Berkeley, CA: Apress.

Skeel, Robert. 1992. “ Roundoff Error and the Patriot Missile.” SIAM News 25, no. 4: 11.

Steele, Guy L. 1977. “ Lambda: the Ultimate GOTO.” ACM Conference Proceedings.

———. 1990. Common LISP: The Language. Bedford, MA: Digital Press. This is a very witty book in addition

to being packed with information.

Steele, Guy L., and Gerald Sussman. 1978. “The Art of the Interpreter.” AI Memo (MIT) 453.

Stewart, Ian. 1995. Concepts of Modern Mathematics. New York: Dover. These Dover math books are often

true gems. It would be great to see an adventurous publisher print a similar series revolving around

C.S.-relevant topics—monads, category theory, lambda calculus, and so on.

Sussman, Gerald, and Guy L. Steele. 1975. “Scheme: An Interpreter for the Extended Lambda Calculus.”

Higher-Order and Symbolic Computation 11, no. 4. This is a discussion of Scheme’s early implementa-

tion of lexical closures.

Symbolics Inc. 1986. Reference Guide to Symbolics Common Lisp: Language Concepts. Symbolics Release 7 Doc-

ument Set.

Thompson, Simon. 1999. Haskell: The Craft of Functional Programming. Reading, MA: Addison-Wesley.

Ullman, Jeffrey. 1988. Principles of Database & Knowledge-Base Systems Vol. 1: Classical Database Systems.

Rockville, MD: Computer Science Press.

Ungar, David, and Randal Smith. 1987. “ SELF: The power of simplicity.” Presented at the Conference on

Object-Oriented Programming Systems, Languages, and Applications (OOPSLA), Orlando. The

Self programming language is likely the greatest influence on prototypal inheritance.

Van Roy, Peter, and Seif Haridi. 2004. Concepts, Techniques, and Models of Computer Programming. 

Cambridge, MA: MIT Press.

Wadler, Philip. 1989. “Theorems for Free!” Presented at the fourth International Conference on Func-

tional Programming and Computer Architecture.

Wampler, Dean, and Alex Payne. 2009. Programming Scala. Sebastopol, CA: O’Reilly.

Download from Wow! eBook <www.wowebook.com>

RESOURCES

317

Whitehead, Alfred North. 1929. Process and Reality: An Essay in Cosmology. Cambridge University Press. For

a general overview of Whitehead, see The Wit And Wisdom of Alfred North Whitehead by A.H. Johnson

(Boston, Beacon Press, 1947).

Williams, Laurie. 2002. Pair Programming Illuminated. Boston: Addison-Wesley Professional. The limita-

tions of the book format only shadow the idealistic model of pair programming.

Online resources

Braithwaite, Reginald. 2007. “Why Why Functional Programming Matters Matters.” http://mng.bz/

2pZP. This column discusses a language-level separation of concerns.

Clementson, Bill. 2008. “Clojure could be to Concurrency-Oriented Programming what Java was to

OOP.” http://bc.tech.coop/blog/081201.html. A much deeper discussion concerning Erlang actors and Clojure agents.

Dekorte, Steve. Io . http://iolanguage.com.

Fogus, Michael. Lithp. http://github.com/fogus/lithp.

Fowler, Martin. 2005. “Fluent Interface.” http://mng.bz/e2r5.

———. 2007. “Mocks Aren’t Stubs.” http://mng.bz/mq95.

Graham, Paul. Arc. www.paulgraham.com/arc.html.

———. 2001. “What Made Lisp Different.” www.paulgraham.com/diff.html. As Paul Graham states,

“The whole language always available” appears as a theme throughout this book and as a finale in

section 13.5.

Houser, Chris. error-kit API . http://mng.bz/07FF. The clojure.contrib.error-kit namespace contains an open error system similar to CL conditions that don’t require recompilation when defining new

error types.

Krukow, Karl. 2009. “Understanding Clojure’s PersistentVector Implementation.” http://mng.bz/tmjv.

Lindholm, Tim, and Frank Yellin. 1999. Java Virtual Machine Specification. http://java.sun.com/docs/

books/jvms/.

Peter. 1998. “ Design Patterns in Dynamic Programming .” http://norvig.com/design-patterns/. 

The section on design patterns was inspired by this presentation.

Tarver Mark. 2008. Functional Programming in Qi. www.lambdassociates.org/Book/page000.htm. Some programming languages perform partial application automatically when a function is 

supplied with fewer than the expected number of arguments. One such language is Qi.

———. 2009. “The Next Lisp: Back to the Future .” http://mng.bz/8wA9. The notion of Lisp as a programming language genotype is explored.

_why. Shoes. http://github.com/shoes/shoes.

Yegge, Steve. 2006. “ Execution in the Kingdom of Nouns . ” http://mng.bz/9ApS.

———. 2008. “The Universal Design Pattern.” http://mng.bz/6531. Like many programmers of our generation, we were in many ways inspired and influenced by Steve Yegge’s work—which is why we

asked him to write this book’s foreword.

Download from Wow! eBook <www.wowebook.com>

index

Keywords and symbols

ACID 238

arglists 164

ad-hoc hierarchies 16, 70, 184,

argument 68

, 25, 158

186, 188, 304

arrays 74, 7 7, 79, 2 18–2 20

; 21

derivation hierarchy 186–187

amap 220

:as 40–41, 48–49, 182, 264

make-hierarchy 187

areduce 220

:exclude 41, 182, 258

adornment 278

multidimensional arrays 222

:import 42, 1 82

Agents 235, 240, 247, 249–255,

primitive arrays 218–2 19

as-futures 263–265, 268

restart-agent 253–254

assertions 173, 2 03

:refer-clojure 182, 2 58

send 248, 2 51–2 53

assert 134

:require 41, 1 82

send-off 248, 251–2 53

Ahead of Time Compilation

asum-sq 220, 278–2 80

naked :use 183

(AOT) 218, 227–228

asynchronous 240, 247

*warn-on-reflection* 278, 2 89

Atoms 235, 2 40, 2 55–2 57

alias 183

& 48, 5 0

compare-and-set! 255

anaphora 170–1 71, 2 11

autoboxing 288

anaphoric 173

auto-gensym 36, 1 65

anaphoric macros 170, 2 11

ancestors 186

A* pathfinding 149

and (logical) 114, 1 75

astar 149–154

anonymous inner classes 126

candidate paths 150

Apache Ant 181

backslash 73

cost-estimate function 150

Application Programming

bad-make-move 243

path-finding 149

Interface (API) 204, 293

beget 184

abstraction-oriented

public-facing API 181

184, 1 89, 206, 285–2 87

aquarium 69

best practices 303

abstractions 166, 1 88, 208, 2 27,

319

Download from Wow! eBook <www.wowebook.com>

320

INDEX

Big-O 77, 80–8 2

expressiveness of 5

compile 141, 2 13–214

algorithmic complexity 77

succinctness 72

compiler 117, 213, 218, 277,

asymptotic complexity 80–81,

clojure.contrib.json 168

288–291

124

clojure.contrib.repl-utils 52–53

Compiler.java 55

linear time 81

clojure.core 41, 1 79, 1 83, 2 71

compile-time 141, 231

logarithmic complexity 81

clojure.lang.IMeta 212

complement 128, 1 30

bind 47

clojure.lang.IPersistentStack 86

complexity 103, 2 38, 2 73

binding 47, 300

clojure.lang.PersistentQueue/

essential complexity 5

bit-xor 51

EMPTY 92

incidental complexities 164

blocks 29, 31

clojure.main/repl 309

composition 305

boilerplate 162, 164–1 65

clojure.set 40, 9 4, 9 6, 1 83, 2 94

Boolean (Java class) 44, 8 3

clojure.test 128, 1 83, 3 00

concrete classes 16, 1 93, 1 95,

Boolean context 45

clojure.test/run-tests 128

208

bot object 139–1 40

clojure.xml 183, 262

concrete realization 286

bottom-up programming 298

clojure.xml/emit 305

concurrency 3, 1 4, 1 09, 2 34–

bound 272

clojure.xml/parse 263, 306

237, 245, 2 49, 2 58, 2 61

boxing 288

clojure.zip 183, 2 62

concurrent modification

autoboxing 288

clojure.zip/xml-zip 263

220, 259

unboxing 288

closures 17, 135–1 41, 1 97, 2 30,

concurrent modification

breakpoint 309–3 10

258, 3 05

errors 109

build-contract 174, 1 81

closing over parameters 137

concurrent

build-move 205–206

functions returning

programming 234–2 35,

byte 83

closures 136

248, 259

bytecode 141, 2 08, 2 10, 2 22

model, distributed 248–249

functions 137

priority inversion 238

sharing closure context 138

vs. parallelism 235

code

cond 69, 1 62, 2 98

C (programming language) 8,

avoid repeating 196

confounding 281

21, 194, 1 98

is data 8, 1 1, 1 57–1 58, 1 61,

conj 86, 8 8, 9 0–92, 110, 196

calculations, precise 66

consistency 7–8, 238, 242, 261

callbacks 138, 2 66

coercion 277, 2 87–291

reporting problem 238

call-by-need 119

fifth rule of coercion 291

constant factor 81

canvas 51

first rule of coercion 288

constant time 281

capitalize 41

fourth rule of coercion 290

constructors 37, 5 5, 1 98, 2 04,

capturing group 74

second rule of coercion 290

212, 305

car 80, 90

third rule of coercion 290

contains? 89, 9 1, 9 5

case 147, 298

collect-bodies 173–1 74

continuation-passing style

chaining 202

collection 46, 280

(CPS) 148–1 49, 2 29, 3 04

change-message 209, 211

return continuation 148

character classes 73

commenting 21, 74

continuations 266, 307

characters, in a string 23

commits 248

continuation function 148

chars 279

Common Lisp (programming

continue 252, 2 54

chess 16, 202, 204–2 05, 2 41–2 42

language) 46, 7 2, 1 69, 2 98

contracts programming 173,

choose-move 242

cdr 80, 90

175–1 76, 299, 302–3 03, 3 12

chunked sequences 283

Common Lisp Object System

constraints 133, 1 73, 1 75,

Clojure

control structures 157, 159,

as opinionated language 312

comparator 95

161, 163

Clojure 1.3 271, 3 07

compare-and-swap 255

conversion specification 296

Download from Wow! eBook <www.wowebook.com>

INDEX

321

coordination 241, 269

subscriber patterns 129

dynamic scope 273–2 74, 3 06,

copies, defensive 226

Visitor pattern 304

308

counted 90

Design Patterns: Elements of 

dynamic type systems 278, 2 87

counter-optimizations 280

Reusable Object-Oriented

count-tweet-text-task 263–2 64,

Software 303

266

destructuring 8, 47–4 8, 54, 57,

associative destructuring 50

embedding 73

in function parameters 50

empowerment 6

nested 49

empty sequence 78–7 9

versus accessor methods 50

empty? 46

data structures, immutable

with a map 49

encapsulation 16–17, 305

108–1 09

with a vector 48

block-level encapsulation 17

database 236

determinacy 235

local encapsulation 17

deadlock 236, 238, 248–2 50,

directive 48–4 9, 5 2

namespace encapsulation 17

259, 2 67

directory structure 180–1 81

Enlive 168

deterministic 267

disappear 53

enumeration values 68

debugging 293, 3 10, 3 12

dissoc 86, 1 90–1 91, 2 57

ephemeral 280

debug-repl 309

distributive 66

equality 68, 7 0–7 1, 1 09, 1 87

decimal 22

do 29, 163, 262

equality partitions 79, 102,

documentation, viewing 53

equality semantics 79

def 27–28, 135, 137, 181, 271,

domain 166

Erlang (programming

273

domain-specific language

language) 248–2 49

actor 248

default-handler 209–210

(DSL) 10–1 1, 7 0, 1 64, 1 67,

Actor model 143

defformula 303–304

173, 204, 2 92–2 95, 2 98,

in-process versus distributed

definterface 227–2 29

301

concurrency models 248

defmacro 162, 1 81, 2 71

domain expertise 302

share-nothing 248

defmulti 188, 2 71

putting parentheses around

error handling 229, 2 54, 

defn 17, 2 7, 1 36, 1 64, 1 81, 2 71

the specification 295

306–3 08

defonce 271

unit conversion DSL 297

defrecord 189–191, 1 99–200

doseq 7, 46, 55

contextual-eval 160–161, 310

defstruct 182, 190

dosync 242, 2 48

eval 159–1 61, 3 09–310

downfall of defstructs 190

exceptions 38, 5 5, 2 05, 2 29,

def-watched 165

double 63, 8 3

236, 2 52–2 54, 2 82, 2 93,

delay 113, 119, 121, 149, 287

dependency injection (DI) 305

double-quotes 73

checked 229–2 30

deref 240, 2 55, 2 70, 2 72

ConcurrentModification-

descendants 186

drawing 53

Exception 259

design patterns 292, 303

duck typing 189

finally 172, 261

Abstract Factory pattern 304

java.lang.ClassCastException

chain of responsibility 305

DynaFrame.clj 213

231

Façade pattern 305

dynamic binding 287, 2 93, 3 06,

java.lang.Exception 230

Interpreter pattern 305

308

java.lang.NullPointer-

Observer pattern 303–304

binding 117, 271, 273, 290,

Exception 114

Prototype pattern 305

306, 308

java.lang.RuntimeException

Strategy pattern 304

bound-fn 274

230

Download from Wow! eBook <www.wowebook.com>

322

INDEX

exceptions (continued)

runtime vs. compile-time 230

frequencies 288

global hierarchy map 188

throw 38, 5 4–55, 2 31

Gödel, Escher, Bach: An Eternal

expansion 297

frustrating 246

Golden Braid 183

expected case 81

fully qualified 258, 270, 272

good-move 242

experimentation 179

fun 51

Graham, Paul 298, 309

expression problem 16

functional programming 12,

graphic 54

extend 15, 1 92, 1 95–1 97, 1 99

19, 1 08, 303

graphical user interface (GUI)

extend-protocol 192, 197

currying 127

138, 212, 2 14–216, 218

extend-type 192–193, 197

first-class functions 72, 126,

graphics context 53

Extensible Markup Language

130

greatest common

(XML) 168, 262–264,

functional composition 169,

denominator 144, 2 84

305–306

288, 2 94

green thread 254

higher-order functions 115,

Greenspun’s Tenth Rule 303,

129–131, 137, 142, 151,

305

154, 1 61, 1 73–174, 230,

partial application 127, 305

factory methods 305

pure functions 5, 1 18, 

131–132, 149, 241, 298

fail 252, 2 54

referentially

false 44–45, 56

Halloway, Stuart 101, 2 08

transparent 131–1 32, 2 56,

anonymous 28, 129, 138, 210

hash-map 80, 8 8, 9 7, 1 90

fence post errors 203

arity 26

Haskell (programming

filter 78, 1 19, 1 29, 1 38, 3 04

Calling Functions 25

language) 12, 4 7, 1 13,

find-doc 51

dangerous 75

118, 1 49, 161, 1 98, 2 85, 301

find-ns 179

function signatures 192

out of order execution 149

finite state machines 146

local 147

Template Haskell 161

first 78, 8 0, 9 0, 1 21, 1 27

multiple function bodies 50

typeclasses 198, 2 85

First In, First Out (FIFO) 91,

named arguments 132

heuristic 151

192

futures 235, 261–263, 265, 269

Hickey, Rich 4–5, 206

First In, Last Out (FILO) 192

as callbacks 262

hidden 52

first-class 12, 27, 128

future 149, 2 55, 274

FIXO 192–193, 195, 197

future-cancelled? 264

homoiconicity 12, 293

fixo-peek 199

future-done? 264

hooks 304, 309

fixo-push 193, 195, 200

floating point 22, 6 2, 6 5–67

Gang of Four 303

hyphens 181

overflow 83

garbage collection 207, 280,

gen-class 38, 212, 2 14–215,

I/O 239, 2 49, 252

fluent builder 202–203

218, 2 33, 3 04

idempotent 239, 2 55–2 56

FluentMove 204–205

generalized tail-call

identical? 70–71

fn 26, 28, 82, 1 35–1 36, 1 46, 164

optimization 143–1 44, 1 49

identifiers 70

for 7, 51

generic 46

identity 3, 1 3–1 4, 71, 2 02, 2 11,

Download from Wow! eBook <www.wowebook.com>

INDEX

323

idiomatic 34, 36, 46, 62, 82, 87,

into-array 218–2 19, 2 22

java.lang.Thread 255

98, 1 14, 154, 1 58, 1 69, 179,

inversion of control 164

java.util.ArrayList 79

if-let 120, 1 71

invoke 214

java.util.Collection 225

image 51, 56

Io (programming

java.util.Collections/sort 223

immutability 7, 14, 30, 77–7 8,

language) 185

java.util.Comparator 222–223

86, 9 1, 93, 1 00, 107–1 09,

Ioke (programming

java.util.concurrent 258, 261

136, 143, 2 02, 224, 248, 2 80

language) 207

java.util.concurrent

imperative programming 14,

java.util.concurrent.atomic.

implementation details 182

ISeqable 200

AtomicInteger 136, 256

implicit do 30

ISliceable 228–229

java.util.concurrent.Blocking-

java.util.concurrent.Callable 

index numbers 47

iterator 78, 8 8

222

infinite lazy range 68

java.util.concurrent.locks 260

infinite loop 46

java.util.concurrent.locks.

infinite sequence 113, 1 18, 2 83

ReentrantLock 260

infix notation 25

Jahad, George 160

java.util.concurrent.locks.

inheritance 5, 183, 185–186

Java 37, 2 08, 2 90

ReentrantReadWriteLock

language) 4, 6, 8, 16, 18,

java.util.List 15, 7 9, 2 23, 2 25

inheritance 196

21, 3 2, 36, 38, 67, 91, 108–

java.util.Observable 304

interface inheritance 16

109, 1 29, 1 79, 192, 194,

java.util.RandomAccess 48

prototype chain 184, 187

198, 2 07, 2 09, 211, 215,

java.util.regex.Matcher 48, 7 5

prototype maps 183, 1 86

java.util.regex.Pattern 73

inherited behaviors 186

224, 2 35, 2 55, 260, 290

javadoc 53, 73

init 55

Java 7 126

JavaScript (programming

init-proxy 212

Java Collections

language) 16, 135, 141, 184

in-process programming

Framework 224, 2 26

javax.swing.JFrame 212

variadic constructor 222

joy.gui.DynaFrame 212

overflow 64

Java Virtual Machine (JVM) 4,

JRuby (programming

interactive command

6, 3 6, 6 2, 6 5, 1 44, 146, 

language) 207

prompt 51

207–2 08, 2 20, 2 29, 2 34,

just-in-time (JIT) 207

interfaces 8, 16, 192–1 93, 1 95,

intern 179–1 80, 2 70, 2 72

java.awt 52

language) 207

internal reduce 280

java.awt.Container 212, 2 15

interop 73

java.awt.Frame 52

interoperability 24, 6 2, 1 96,

java.io.FilterOutputStream 211

200, 2 08, 218, 222, 224,

java.io.OutputStream 211

227, 2 77, 304

java.lang 42, 1 79

kapow 143

accessing Java instance

java.lang.Iterable 225

keep-indexed 102

members 37

java.lang.Math/round 291

key 49, 80, 88

accessing static class

java.lang.Object 128, 2 05, 2 20,

keys-apply 131–132

members 36

279

keyword arguments 278

creating Java class

java.lang.Runnable 222

keywords 23, 68–70, 241

instances 36

java.lang.StackOverflowError 

plumbing, separating from

setting Java instance

java.lang.String/format 222

ubiquity of 75

into 83, 89, 196

java.lang.StringBuilder 218

Kingdom of Nouns 18

Download from Wow! eBook <www.wowebook.com>

324

INDEX

locking 14, 2 34, 2 36, 2 38, 2 50,

blocking 224, 2 48, 2 50–2 51,

Lambda Papers 143

map 25, 68, 71, 78–7 9, 8 7, 

last 86

explicit locks 261

97–98, 100, 102, 119, 

laziness 113, 117, 1 19, 1 22,

fairness 250

129, 189, 2 04, 2 22, 2 69,

124, 274, 2 82

orphaning 238, 2 59

273–274, 295, 304

combinatorially exploding

reentrant 260

array map 98, 1 00, 1 90

full realization of interim

math-context 273–2 74

lazy evaluation 149

logging 249, 251

Maven 181

lazy sequences 68, 87, 131,

long 83, 2 79

max-history 247

268–269, 274, 283–284

look-around clauses 73

McCarthy, John 9

lazy-seq 115–116, 143

lookup 17–18, 6 8, 2 85–286

memoization 132, 256–257,

lazy-seq recipe 115, 1 17, 

loops 30–31, 1 46, 2 90

short-circuiting laziness 114

let 29, 3 6, 5 2, 82, 1 17, 135, 1 37,

lowercase 74

hit 285–2 86

170, 273, 2 90

manipulable-memoize 

letfn 18, 147

256–257, 286

lexical scope 135, 2 73–274, 

memoization protocol 

290

M literal 21, 6 2–6 3

285–286

lexical bindings 309–3 10

macroexpand 161

memoize 256–257, 284–2 85

lexical context 138, 169

macroexpand-1 161

miss 285–2 86

lexical contour 170

macros 9, 24, 34, 55, 72, 

PluggableMemoization 

lexical environment 138,

119, 1 60–161, 164, 166, 

286–287

140, 309

169–170, 173, 231, 263,

through 286–2 87

line number 55

296–298, 303, 305, 308,

Mersenne primes 283–284

line terminators 74

310–311

metadata 69, 71, 1 28, 1 64, 1 81,

linear search 100

combining forms 164

191, 256

Lisp (programming language

compile-time 31, 1 57, 1 61,

attaching 71

family) 4, 8 –9, 2 2, 2 5, 3 0,

169, 2 30

meta 71, 1 91

36, 68, 7 9–80, 87, 90, 126,

hygienic 171

with-meta 71, 1 91

172, 202, 2 95, 2 98, 3 04

macro that builds another

macro-definition time 171

min-by 151, 154

Lisp-1 62, 72

macro-expansion time 169,

min-history 247

lists 24–2 5, 3 3, 7 9, 9 0–91, 122,

310

mini-language 8, 4 7, 298

159

returning functions 173

using to change forms 165

monitor context 259

literal 73

using to control symbolic 

monkey-patching 16, 1 95

literal syntax 23–25, 83, 89, 97,

local-context 138, 310

magical formula 269

multi-line mode 74

locals 29–3 0, 7 2, 117, 136, 143,

main 203

multimethods 15, 68, 7 0, 185,

272–273, 290

make-array 219

187–1 88, 202, 304–3 05, 3 07

local bindings 310

make-dumb-array 258

multimethod dispatch 221

Download from Wow! eBook <www.wowebook.com>

INDEX

325

multimethods (continued)

performance 190, 202, 277,

multiple transactions 246

ns-unmap 179

291

multiversion concurrency

nth 84, 91

measurements 282

control (MVCC) 236, 239

nthnext 116

Perl (programming

snapshot isolation 245

persistent data structures 7, 77,

mutability 78, 108–109, 13 6,

binary 22

81, 90, 110, 113, 280–281

220, 224, 235, 239, 255,

distribution of represented

persistent hash trie 81

259, 261, 280–2 82

numbers 65

pixel 51

isolated pools of mutation

polymorphism 3, 16, 139–141,

mutable state 14

radix notation 22

184–185, 188–189, 19 2–

mutation 109, 235, 239, 257,

radix-32 22

194, 202, 206

298

scientific notation 22

pool 251

mutators 202

numerical precision 75

pop 86, 91–93, 192

pos 101–103

positionally 47

postconditions 133, 173, 175,

name resolution 72

302

object-oriented

name shadowing 72, 169

13, 1 5, 1 8–1 9, 3 2, 9 7, 1 64,

named structures 50

arbitrary precision 21

205–2 06, 2 92, 3 03, 3 05

namespaces 17, 21, 36, 39 ,

preconditions 173, 206, 302

conflict resolution

42, 69, 71, 94, 163, 169,

predicates 103, 138

strategy 187

178, 180–182, 189, 198,

type-based 79, 102

hierarc hies 5, 18, 103, 164,

212–213, 215, 262, 270,

prefix notation 9, 25

204, 298, 304

272, 305

primitives 21, 64, 83, 200, 229,

objects 279

as class specifications 212

279, 287, 290–291

obscure 47

compilation 214

println 30, 114, 160, 308–309

occur-count 288–289

in-ns 179

print-method 92

On Lisp 298

name-mangled local 290

programmer efficiency 278

one-at-a-ti me realization

namespace compilation 214

Programming Clojure 101

282–284

namespace qualification 69

promises 235, 261, 266–267,

operator precedenc e 5, 25

ns 39, 70, 179, 182, 212

269

privacy 181

optimizations 277, 280, 289

callback API to blocking

qualification 40, 69, 170,

option flags 74

API 266

179, 183

or (logical) 49, 3 05

deliver 265

remove-ns 180

original map 49

promise 149, 265–26 6

two-level mapping 178, 18 0

with-promises 268

user 21

protocols 15–16, 121, 189, 192,

natural language 296

195, 197, 227, 258, 285,

neighbors 85–86, 150, 242

pair 49

305

nest 236

parallelism 149, 235, 261,

design of 285

nested syntax-quotes 297

264–266, 269

Prototype Principle 183

new 36

dataflow 267

prototyping 214

next 46, 57, 79, 89–91, 110 ,

nil 24–25, 44–45, 49, 56, 7 8,

partial 127–128, 1 30, 2 42

proxy 38, 171, 208, 210–212,

80, 94, 101, 110, 117,

partition 298

261, 304

163, 195, 253

Patriot missile 64–6 5

proxy-mappings 210

nil pun 57

pattern matching 47, 24 9

proxy-super 211

nondeterminism 235

patterns 54, 7 3

update-proxy 210, 21 2

Download from Wow! eBook <www.wowebook.com>

326

INDEX

pure virtual classes 192

tail-call optimization

reuse 127

purely functional 131, 282

(TCO) 6, 145–1 46

reverse 41, 8 7

push 192–1 93

tail-recursive 124, 1 42, 1 54

roll 288–289

pvalues 235, 268–269

tail-recursive self-call 144

root binding 28, 2 70–271

Python (programming

reduce 119, 1 29, 180, 280, 304

root cause 55

language) 6, 4 4, 1 26, 1 32

refactoring 290

rounding error 64

reference types 14, 108, 1 10,

rseq 80, 8 4

165, 2 02, 2 35–236, 240,

RSS2 262, 299

242, 2 45, 2 47, 2 52, 2 55,

rss-children 266, 299

Qi (programming language) 12

257–259, 261, 270, 272,

rsubseq 99

queues 91, 9 3, 2 52–2 53

303–304

Ruby (programming

PersistentQueue 91–92

add-watch 164, 3 03

language) 16, 1 35, 1 63

priority queues 192

coordinated 240–244, 247

synchronous 241, 2 47, 2 52,

quote 32–3 4, 7 0, 1 59, 1 71

255

quoting forms 161

uncoordinated 255

SafeArray protocol 258–259

nested syntax-quotes 160

language) 47, 1 26, 1 45,

watchers 304

170, 207, 3 01

referential transparency 12, 1 32

scalar 61

reflection 279–2 80, 2 89

scalar types 75

range 51, 6 8, 8 3, 9 0, 1 17, 282

Refs 235, 2 40–2 41, 2 43–2 46,

language) 87, 1 43–145

semantic coupling 302

read 309–310

regular expressions 52, 6 1, 7 5

separation of concerns 7

reader feature 28

case insensitivity 74

seq 46, 74, 77–80, 83–8 4, 9 8,

Read-Eval-Print Loop

re-find 75

200

(REPL) 21, 26, 3 2, 3 9, 

regex 73–74

seq protocol 305

54–55, 57, 97, 117, 123,

re-groups 75

seq1 283–284

179, 213–214, 221, 267,

reluctant quantifiers 73

sequence abstraction 77–78,

270, 273, 2 78, 2 89, 3 09

re-matcher 75

80, 8 2, 9 7, 1 00–101, 204

reify 38, 1 41, 1 98, 2 08, 2 11, 304

sequences 78–8 0, 2 90

records 189, 191, 1 95, 1 97–1 98,

factory function 198

chunked 277, 2 82–283, 291

205–206

relational functions 293–2 94

chunk-at-a-time model 282

recur 30–31, 1 42, 1 44–147, 200

SELECT 10, 2 93

sequentials 48, 78–7 9

recursion 30, 1 41–1 42

relative-units 296, 298

remote-procedure call

difference 97

freeing the recursive call 142

(RPC) 262, 2 66–2 67

intersection 96

generalized tail-call

rename 42

relative complement 97

optimization 145

reordering 245

union 97

mundane 142–143, 145, 306

recursive call trapped 142

resolve 72, 2 72

shared-state concurrency 234

stack consumption 142

rest 46, 78, 8 0, 89, 9 1, 115–1 16,

tail position 30–3 1, 143, 1 46

reusability 234

shuffle 226

Download from Wow! eBook <www.wowebook.com>

INDEX

327

side effects 29, 131–132, 1 54,

subseq 95, 99

transactions 235–2 36, 2 39, 2 41,

163, 1 80, 248, 255, 306

subvec 88–89

243–2 48, 2 55–2 57

simplicity 4, 103, 288

superclass constructor 212

embedded transactions 236

simplification 204

Sussman, Gerald 143

retry 236, 2 43, 247–2 48, 255,

transients 108, 2 77, 2 80–282,

symbols 23, 2 6, 2 8, 7 0–71, 159,

Rule of Transients 280

slope 133–134

171, 1 78, 2 64

TreeNode 189, 1 93, 1 95, 2 01

slowly 257, 2 87

auto-qualification 34

trees 110–1 11, 1 66, 1 68, 1 95,

snapshot 235–236

symbolic mappings 179

software transactional memory

syntactic sugar 222

persistent binary 191

(STM) 3, 235–238, 243,

syntax-quote 32, 34–3 5, 72,

traversing 111, 3 06–3 07

commit 236, 243, 245–246

unbalanced 113

commit-time 245

triangle 118

in-transaction 243, 2 45–2 46

truncation 62, 2 90–2 91

retry 236

tail position 142

truthiness 43–4 4, 5 6

some 94

and recur targets 145

truthy 52, 6 9, 9 4, 1 19

tweetless-rss-children 300

sorted-map 98–99, 113

take 124

tweet-occurrences 264

sorted-map-by 95, 9 9

terminating condition 46

Twitter 262–264, 299

sorted-set 94–95, 113

test-driven development (TDD)

type conversion, automatic 63

sorted-set-by 95

109, 292, 298–3 01

type hints 228, 2 77–2 80, 

sort-parts 123

specification language 302

287, 2 91

special form 24, 2 6, 3 3

unit tests 128

types 189, 227, 304–3 05

split 74–7 5

there ain’t no such thing as a

deftype 38, 2 00–202

spot optimizations 280

free lunch 237

spreadsheets 130, 139, 268

third-party libraries 171, 194,

SQL 10–1 1, 2 93–294

198

this 108, 171, 1 85, 198, 2 10–2 11

thread-local 28, 2 40, 2 70, 2 73

unchecked 64

errors 145

thread-local bindings 271–273,

threads 5, 28, 220, 224, 2 36,

Unicode 73

IPersistentStack 201

240–2 41, 2 47, 2 49–2 52,

case insensitivity 74

state 3, 13–14, 186, 202, 

254–2 55, 2 58, 2 60–2 61,

234–2 35, 2 39, 2 42, 

unit conversions 294–2 95

265, 2 67–2 68, 2 74, 2 82,

245, 2 47, 249, 255

unit testing 128, 292, 298, 302

static type system 278

Universal Design Pattern

thread-safe 211, 240

static versus dynamic 278

(UDP) 183–1 86, 1 88

time 13, 235, 247

Steele, Guy Lewis 47, 143

timelines 235, 243

Unix line terminator 74

straight-line path 150

unquote 35, 1 60, 1 63–164

strings 23, 7 1, 7 3, 79

toString 204–2 05

unquote-splice 35, 1 63

zero-length strings 44

trampoline 147

up-arrow key 51

structural sharing 110

trampoline for mutual

Download from Wow! eBook <www.wowebook.com>

328

INDEX

variable arguments 26

volatile 202

variables 14, 2 9, 2 55

xconj 110, 1 12, 1 91, 1 93, 

Vars 25, 2 7, 3 2–3 4, 4 0, 7 2, 1 28,

195–196

137, 163–164, 178, 181,

xor 51

235, 240, 2 70, 3 07

when 8, 3 1, 5 2, 1 62–1 63, 1 70

with-local-vars 272–2 73

Yegge, Steve 183

vectors 24, 3 3, 8 0, 82, 9 8, 193

Whitehead, Alfred North 61

as stacks 86

whitespace, ignoring 74

IPersistentVector 193, 198

with-open 82, 172, 274

Zawinski, Jamie (JWZ) 73

vector 29, 3 2, 8 3–84, 126,

walking in reverse order 84

world 150–152

verbosity 140, 2 02

worst-case 81

Download from Wow! eBook <www.wowebook.com>

FUNCTIONAL PROGRAMMING

THE Joy OF Clojure

SEE INSERT

Fogus Houser

If you’ve seen how dozens of lines of Java or Ruby can dissolve

into just a few lines of Clojure, you’ll know why the authors

of this book call it a “joyful language.” Clojure is a dialect

“You’ll learn fast!”

of Lisp that runs on the JVM. It combines the nice features of a

—From the foreword

scripting language with the powerful features of a production

by Steve Yegge, Google

environment—features like persistent data structures and clean

multithreading that you’ll need for industrial-strength

“Simply unputdownable!”

application development.

—Baishampayan Ghose (BG)

Qotd, Inc .

The Joy of Clojure goes beyond just syntax to show you how to

write fl uent and idiomatic Clojure code. You’ll learn a functional

“Discover the why, not just

approach to programming and will master Lisp techniques

the how of Clojure.”

that make Clojure so elegant and effi

cient. Th

e book gives

—Federico Tomassetti

you easy access to hard soft ware areas like concurrency,

Politecnico di Torino

interoperability, and performance. And it shows you how

great it can be to think about problems the Clojure way.

“What Irma Rombauer

did for cooking, Fogus

What’s Inside

and Houser have done

e what and why of Clojure

for Clojure.”

How to work with macros

—Phil Hagelberg, Sonian

How to do elegant application design

Functional programming idioms

Written for programmers coming to Clojure from another

programming background—no prior experience with

Clojure or Lisp is required.

Michael Fogus is a member of Clojure/core with experience in

distributed simulation, machine vision, and expert systems.

Chris Houser is a key contributor to Clojure who has

implemented several of its features.

For online access to the authors and a free ebook for owners

of this book, go to manning.com/TheJoyofClojure

M A N N I N G

$44.99 / Can $51.99 [INCLUDING eBOOK]