Index

Symbols

* (URL wildcard in Compojure), 277

+function, 46, 49

+operator, 90

-(prefix for Java methods), 98

-function, 49

.. macro, 82, 83, 216, 218

. special form, 80, 81

:: namespaced keyword prefix, 252 : macro character, 53

; macro character, 55 =, 74, 258

@ macro character, 36, 179 #<>, 249

%d format specifier, 87 %s format specifier, 87

% anonymous function argument, 59 _ underscore, 63

~@ unquote, splicing, 221 ~ unquote character, 220 " macro character, 49

‘ character, 220

A

ACID mnemonic, 180, 191 ActiveRecord, 275

agent function, 187, 188 agent-errors function, 189 Agents, 191f, 187–191

checking value of, 188 concurrency model and, 196f defined, 177

STM interaction, 178 targets and, 207 transactions and, 189–191

unified update model for, 191 validating, 188–189

aget function, 84 alias function, 252

alter function, 35, 182, 184 amap macro, 86

and macro, 226

Anonymous functions, 58–60 Ant, 43

attributes, 105 on classpath, 105

names, vs. in Clojure, 241 property names of, 108 tasks, 105–110, 141

tasks, defining for Lancet, 239 apply function, 51

areduce macro, 40, 86 Arity, 57

Arrays, 84, 127 aset function, 84

assert macro, 232, 268 assoc function, 75

Asynchronous updates, 187–191 atom function, 99, 186

Atomic updates, 180

Atoms, 177, 186–187, 191f, 196f, 207 Attributes, Ant, 105

auto-gensym, 223 Automated tests, 266–269 await function, 188 await-for function, 188

B

Bagwell, Phil, 149

Bank account service charge example, 252

Basis, 152 Basis keys, 54

bean function, 88, 107, 142 Beans, 88, 142

bench example, 222, 233

BigDecimal class, 48 binding macro, 192

Binding expressions, 125 Bindings, 62, 63, 192 Booleans, 51–52 Branches, 22, 68 Brandmeyer, Meikel, 275 by-pairs example, 162

C

Callback handlers, 195 Caller, 169

catch block, 104 Catchall handler, 276

chain example, 218, 219, 221 Characters, 50

Checked exceptions, 102 class function, 48, 247, 259 Classes

compiling, 99

dynamic nature of, 100 features, 101 initialization function, 98 in Java, 94–101

see also Collections clear-agent-errors function, 189 clj-record, 275

Clojure, 275 API for, 41

benefits of, 21–30 building yourself, 32 concurrency, 29 features of, 14, 21

functional language, 27–28 Hello, World, 32–33 installation, 30–32

Java and, 29–30 Lancet, 16, 42–44 libraries, 37–42 Lisp and, 24–27

notation conventions, 18 printing application, 245 references (refs), 35 REPL prompt, 19 resources for, 19

sample code, 20, 30 syntax, 214 variables, 33–34

clojure-contrib library, 31, 211, 229 def, 164

repl-utils, 40 sql, 270

duck-streams, 130

Prepared exclusively for WG Custom Motorcycles

test-is, 267 test-is lib, 257

clojure-loc example, 132 sql library, 270 clojure.js, 281

clojureql library, 275 Closures, 60

coerce example, 260 collection-tag function, 257 Collections, 41

in Java, 83–86 seq-able, 111 seq-ing, 127

Commas, 52

Comment, 55 comment macro, 226

commute function, 183, 184 comp function, 163

compile function, 44, 99 Compile time, 213 Compojure, 275–283 Concurrency, 177–210

agents, 187–191 challenges of, 177

commute function, 183, 184 Lancet application, 207–210 locks and, 178–179

models for, 196f noncommutative updates, 184 reasons for, 29, 177

refs and, 179–185

snake game application and, 197–206

STM and, 84

vars and, 192–196 cond macro, 26

conj function, 35, 69, 115, 182 cons function, 113

Consistent updates, 180 contains function, 136 Control flow macro, 212–218

Convenience functions, 86–88 Conventions

function names, 40, 56 functions, creating, 259 keywords as types, naming, 252 macros, 221

multimethods, creating, 259 notation, 18

parameter names, 40 property names, 143

count-heads-pairs function, 161 count-if function, 163 count-runs function, 165 create-runonce example, 208 create-snippet example, 279 create-struct function, 227 create-table function, 270 createTask method, 108

CSS files, 282 Currying, 165–166 cycle function, 119 Cygwin, 31

D

Data

accessing in Clojure, 111 manipulation of, 111

Databases

accessing, 270–275 transaction validation, 185

db example, 270 Deadlocks, 178 declare macro, 228

Deeply nested functions, 172

def special form, 35, 60, 65, 80, 164 defhinted macro, 164 define-all-ant-task example, 239 define-all-ant-tasks example, 241 define-ant-task macro, 233, 239, 240 defmacro macro, 213

defmethod, 247

defmulti macro, 247, 249

defn macro, 32, 56, 58, 76, 164 defn special form, 65

defn- function, 164 defonce macro, 164 defrecord macro, 25 defroutes macro, 276

defstruct macro, 23, 54, 227

deftarget example, 43, 233, 234, 236, 238

deftest macro, 267 defvar macro, 164 delay macro, 230 Dependencies, 43

Dependency-based build, 42 deref function, 179

derive function, 254 Design pattern, 215 Destructuring, 62

Dispatch-by-class, multimethods, 256

Prepared exclusively for WG Custom Motorcycles

Division, 47

do special form, 68 doall function, 126 doc function, 39 doc deref, 77

doc-string function, 39 dorun function, 126 doseq macro, 144 dosync function, 35, 180 dotimes macro, 90

doto macro, 83, 107 drop-while function, 121 Duck typing, 89 duck-streams library, 130 Durable updates, 180 Dynamic binding, 194

Dynamic scope, bindings, 192 Dynamic vars, 192

see also Vars

E

ellipsize example, 64 Encapsulation, 151, 238 Engelberg, Mark, 66 Equality, 74

Event handlers, 195 every function, 22, 121

Exception handling, 101–105 checked exceptions, 102 multimethods and, 250 resource cleanup, 103 responding to, 104

Expressions, seq-ing, 128

F

false, 52

faux-curry example, 166 Fibonacci numbers, 37, 153 Fibonacci, Leonardo, 153 File system, seq-ing, 129 file-seq function, 130

Files, serving, 282

filter function, 58, 59, 71, 120 Filter functions, 58

first function, 142 First-class objects, 27 Flow control, 67–70 fn special form, 58, 60

for macro, 27, 72, 124, 125 for loops, 70

force macro, 230 form-to macro, 278 format, 87

Format specifiers, 87 Forms, 46f, 45–54

boolean, 51–52 defined, 45 maps, 52

numeric literals as, 46–48 strings and characters, 49–51 structs, 54

symbols, 49

Functional languages, 27–28 Functional model, 179

Functional Programming (FP), 147–176 benefits of, 150–151

concepts in, 148–152

data structures, 148–149 recursion and laziness, 149 referential transparency, 150 six rules, 151–152

laziness, 152–160

laziness, in programming, 160–166 overview of, 176

pure functions, 148 recursion, 167–176

Functions, 56–60 anonymous, 58–60 arity, 57

caller of, 169

convenience, for Java, 86–88 deeply nested, 172

defining, 32, 56 doc-string and, 39 filter, 58

keywords as, 53, 135 lambdas (anonymous), 232 maps as, 53

math operators as, 47 parameter names, 59 parameter names and, 40 partial applications, 165 pure, 34, 148

reuse and, 238 self-recursive, 155–156 sets as, 72 structure-specific, 133–141

lists, 133 maps, 135–138 sets, 138–141

tail-recursive, 154–155

Prepared exclusively for WG Custom Motorcycles

targets as, 43, 207 tasks as, 43 vector lists, 116

vectors, mixing with, 278 see also Multimethods

G

Garbage collection, 103 get function, 53

Gilardi, Stephen C., 270

Gödel, Escher, Bach: An Eternal Golden Braid (Hofstadter, Douglas R.), 174

Goetz, Brian, 178

H

Handlers, 276, 280 Handling errors, 188–189 hash-map function, 120 Hashes, 127

head-fibo example, 160 Heads or tails problem, 161 Heap space, 158, 176 Helper functions, 278, 279 Hibernate, 274

Higher-order functions, 22 Hofstadter sequences, 173 Hofstadter, Douglas R., 174 Homoiconic, 45

Horn, David Van, 198

Houser, Chris, 40, 206 html function, 278

HTML form, building, 277–279 Hume, John D., 275 Hyphens, 56, 98

I

“Ideal Hash Trees” (Bagwell), 149 identical, 74

if special form, 67–69, 212, 213 Immutability, 23, 116, 148, 178 Imperative programs, 28

import function, 65, 67, 81 import-static macro, 229 in-ns function, 65 in-transaction-value, 183 include-css function, 281 include-js function, 281 indexOfAny example, 71, 72

index-of-any example, 72, 73, 267

Induction, 152 Infix notation, 46 method, 43

init method, 98, 108 Initialization function, 98 insert-values function, 271

Inspector library, 256 Installation, 30–32

instantiate-task example, 109, 142, 144 Integers, 48, 90, 248

interleave function, 50, 119 interpose function, 119

into function, 115 into-array function, 85

is macro, 257, 267, 268 isa function, 248, 255 Isolated updates, 180 iterate, 118

J

Java, 79–110 arrays, 84 beans, 88

callback APIs, 195 calling in Clojure, 80–88

characters and Clojure, 50 checked exceptions, 102 classes, 94–101

Clojure support for, 79–80 collections, 83–86 compiling to disk, 96–101

convenience functions for, 86–88 exception handling, 101–105 inheritance and multimethods, 248 new keyword, 215

object creation, 80

performance optimization, 88–94 persistent framework and, 274 proxies, 94–96

seq-ing collections, 127 type hints, 92–94

see also Databases

Java Concurrency in Action (Goetz, et al), 178, 179

Java Database Connectivity (JDBC), 270, 273

Java interop, 79, 229–230

Java Virtual Machine (JVM), 29–30 JavaScript files, 282

Jensen, Lau B., 275 Jetty, 277

Prepared exclusively for WG Custom Motorcycles

join function, 140

K

Key/value pairs, 52, 75, 114, 135, 144, 185

keys function, 108, 135 Keywords, 53, 135, 143, 252 Krukow, Karl, 149

L

Lambdas, avoiding, 232–233 Lancet, 16

Ant and, 42

Ant tasks, adding, 105–110, 141 Ant tasks, defining, 239

as DSL, 233–242 overview of, 42–44

properties, adding to tasks, 141–145, 233, 239, 261

targets in, running once, 207–210 type coercions, 259–262

Layout elements (snippet application), 280

Laziness, 149, 152–160

holding a reference to, 159–160 realization of, 158–159 recursion and, 171–173 referential transparency, 150 self-recursion, 155–156

without sequence manipulation, 160–166

sequences, 125–127, 156–158, 230 tail recursion, 154–155

lazy-cat macro, 160 lazy-seq macro, 156, 173 lazy-seq-fibo example, 157 Legal symbols, 49, 63

let special form, 62 letfn special form, 154 Lexical scope, 62 Libraries

Clojure-specific persistence, 274 sql, 270

inspector, 256 overview of, 37–42 sequences, 117–125 test-is, 257, 267

Lisp, 24–27 cons in, 113

seq functions, 113

list function, 119

List comprehension, 124 Lists

forms as, 46 functions as, 56–60 functions on, 133 s-list, 171

seq as, 111

seq functions, 113 sequences, 26 structural sharing, 149

vectors, functions on, 116 Locks, 178–180, 207

see also Concurrency Loggers, 106

Logical lists, 111 loop special form, 69

M

Macro expansion time, 213, 216, 224, 236

macroexpand-1 function, 216, 241 macroexpand function, 217 Macros, 211–243

argument evaluation, 213 benefits of, 25

control flow, 212–218 creating names in, 221–224 expanding, 215–217

Lancet application, 233–242 parentheses, 26

power of, 211

simplifying, 220f, 218–224 symbol capture (bug), 222 syntax quotes and, 220–221 taxonomy, 225f, 224–233

conditional evaluation, 225–227 creating vars, 227–228

Java interop, 229–230 lambdas, avoiding, 232–233 wrapping evaluation, 231–232

when to use, 211–212 see also Reader macros

make-array function, 84 map function, 122 Maps, 52, 88

building, 136 functions on, 135–138 as seqs, 114 sequences and, 127 sorted, 115

Prepared exclusively for WG Custom Motorcycles

Math operators, 47, 90, 139 Member-as-function idiom, 87 memfn macro, 87

Memoization, 150, 174–176, 194 memoize function, 194

Memory, garbage collection, 103 merge-with function, 137

meta macro, 74 Metadata, 74–77

common keys for, 77f defined, 74

Methods, Lisp and, 24 mkdir-task example, 106, 108 Multimethods, 244–264

ad hoc taxonomies, 251–255 advanced uses, 250 creating, rules for, 259 defaults, 249

defining, 247–248 inheritance, 248

life without, 245–246

type coercion example, 259–262 type coercions, 262

when to use, 256f, 255–259 Multiversion Concurrency Control

(MVCC), 182 Mutable model, 179

Mutual recursion, 167–168 my-print example, 245

N

Names, resolving in macros, 223 Namespaces, 33, 37, 38, 64–67, 252,

268 Nesting, 254

new keyword (Java), 215 new special form, 80 next-counter example, 184 nil, 52

not-every function, 122 Notation conventions, 18 ns macro, 67

Numeric literals, 46–48

O

Object-oriented design, 238 Objects, 41

creating, 80

duck typing and, 89 first-class, 27

vars and, 61 or macro, 226

P

page-not-found function, 276 Parallelization, 150 Parameters, 40

Parent/child relationships, 254 Parentheses, 26, 27, 235 Parity, 168

partial function, 165 Partial application, 165 partition function, 163 peek function, 133 Performance, 88–94

data structures and, 148 laziness and, 158 primitives for, 88–92 type hints, 92–94

Points, in transactions, 182 Polymorphism, 215, 249 pop function, 133 Predicates, 52, 120–122

prefer-method function, 250, 251 Prefix notation, 46

Primitives, 88–92 Printing application, 245 project function, 140, 144 Properties, 43, 108 Proxies, Java, 94–96 proxy function, 94

Pure functions, 34, 148

Q

Question mark, 52

Quoting, 37, 220

R

Race conditions, 178 range function, 117 Ranges, 117

re-matcher function, 128 re-seq function, 129 Read, Jeremy, 198

Read-Eval-Print Loop, see REPL Reader, 45

Reader macros, 55 see also Macros

Reader metadata, 75 Realization, laziness, 158–159

Prepared exclusively for WG Custom Motorcycles

recur special form, 69 recur-fibo example, 156 Recursion, 149, 167–176

laziness, replacing with, 171–173 memoization and, 174–176 mutual, 167–168

self-, 168 trampolining, 169–171

Recursive definitions, 152 Reddy, Abhishek, 198 redirect-to function, 279 reduce function, 40, 123 Reeves, James, 275

ref function, 29, 35, 179, 185 ref-set function, 180

refer function, 38 References (refs), 35

Referential transparency, 150 Reflection warnings, 93

Refs, 177, 179–185 vs. atoms, 186

concurrrency model and, 196f functions, validating, 180 reading contents of, 179 ref-set, 180

snake game application, 202 STM interaction, 178 targets and, 207

unified update model for, 191 updating state in, 191f validation for, 185

Regular expressions, seq-ing, 128 Relational algebra, 139f, 139, 141 rename function, 139

repeat function, 118 REPL

defined, 19, 31 Hello, World, 32–33 kill, 33

laziness and, 159 predicates, 52 ranges, 117 sequences and, 116

sequences, forcing, 126 server, reloading from, 277 snake game window, 205 variables, 33–34

repl-utils library, 40 replace function, 171 require function, 37 reset! function, 186

resolve function, 65 Resources, cleaning up, 103 Reuse, 151, 238

Root bindings, 61, 64, 192 Rules of Macro Club, 211, 224 run-server macro, 277

run-tests function, 268 runonce function, 233, 234

S

S-lists, 171

Sample code, 20, 30 SAX parser example, 94

Secure Hash Algorithm (SHA), 88 select function, 140 Self-recursion, 155–156, 168 Self-validation, tests, 266

send function, 187

Seqs, see Sequences (seqs) Sequences (seqs), 26, 111–146

arrays and, 127 capabilities of, 112, 115 file system and, 129

first/rest, 127–133 forcing, 126 immutability of, 116

Lancet application, 141–145, 233, 239, 261

laziness and, 156–158, 230 lazy and infinite, 125–127 library for, 117–125

creating, 117–120 filtering, 120–121 predicates, 121–122 transforming, 122–125

list comprehension, 124 overview of, 111–112, 146 REPL and, 116 structure-specific functions,

133–141 serve-file function, 282

service-charge example, 254 set function, 120

Set theory, 138

set! special form, 92, 195 set-property example, 261 Sets, 72

as functions, 121 functions on, 138–141 as seqs, 114

show function, 40

Prepared exclusively for WG Custom Motorcycles

Side effects, 68, 148, 189 Sierra, Stuart, 229, 267

Six rules of Clojure FP, 151–152 SLOCCount, 71

Snake game application, 197–206 description of, 197

functional model, 198–201 GUI, 203–205

layers of, 197

mutable model, 201–203 without refs, 206

Snippet server application, 275–283 Snippets table, 271

Software Transactional Memory (STM), 178–185, 201

alter function, 182

Multiversion Concurrency Control and, 182

properties of, 180 some function, 122 sorted-set function, 115 source macro, 40 Special forms, 224 Special variables, 193 Speed, see Performance Splicing unquote, 221 split-at function, 121 split-with function, 121 SQL, 275

sql lib, 270

Stack frame, 153 Stack-consuming recursion, 154 str function, 33, 39, 50, 51, 75 str-join function, 119

Streams, seq-ing, 130 String literals, 49 Strings, 49–51, 276

blank, 23 output, 119 sequences, 128

struct function, 54 Structs, 54

submit-button function, 278 sum-to example, 89, 91 swap! function, 187 Symbol capture, 222, 224 Symbols, 33, 49

Syntax, 214 Syntax quotes, 220

T

Tables, 127

Tail recursion, 154

Tail-call optimization (TCO), 70, 155 tail-fibo example, 156

take function, 118 take-while function, 120 Targets, 43

Tasklist application (Java), 96–101 Tasks, 43

Taxonomies, multimethods and, 251–255

:test function, 266–267 test function, 267 test-is library, 257, 267 Testing

automating, 266–269 benefits, in Clojure, 269 chain example, 220

code readability and, 151 duck typing and, 89 failing, 268

macro expansions, 216 self-validation, 266

text-area function, 277 Thread-local binding, 192 Thread-safe code, 27, 29, 178 thrown argument, 269

time macro, 221 to-array function, 85

trampoline function, 169, 170 Trampolining mutual recursion,

169–171 transaction macro, 274

Transactions, 35, 189–191 Treeish concepts, 257 Treeish data, 256

true, 52 try, 103

Type coercion example, 259–262 Type coercions, 262

Type hints, 92–94

U

Underscores, 63 “Understanding Clojure’s

PersistentVector Implementation” (Krukow), 149

unless example, 212, 213 Unquoted character, 220 Updates, 182

Prepared exclusively for WG Custom Motorcycles

asynchronous, with agents, 187–191 atoms for, 186–187

commutative, 183 noncommutative, 184 properties, 180 unified model for, 191

URLs, redirecting to, 279 use function, 38

V

Vaillancourt, Dale, 198 values function, 135 Van Horn, David, 198 var special form, 61 Variables, 22, 33–34, 45 Vars, 61, 196f

defined, 177

macros and, 227–228

per-thread state, 192–196 targets and, 207

values associated with, 61 vec function, 120

vector function, 119 Vectors

Compojure and, 278 destructuring collections, 62 functions on, 116

helper functions and, 278 of numbers, 46

printing, 250 as seqs, 113

Volkmann, Mark, 198

W

Wallingford, Eugene, 171 Web development, 275–283 Webb, Dan, 281

Wheeler, David A., 71 when macro, 68, 217 when-not macro, 217 Whitespace, 23 with-connection macro, 270 with-meta function, 74, 77 with-open macro, 103 with-out-str macro, 231 with-query-results macro, 272 Wrapper macros, 231 Wrappers, sequences, 128

Wrapping evaluation, 231–232