Index
A
- actors
- using / Using actors
- about / Using actors
- creating / Creating actors
- messages, passing between / Passing messages between actors
- errors, handling with / Handling errors with actors
- state, managing with / Managing state with actors
- comparing with processes / Comparing processes and actors
- agents
- used, for managing state / Using agents
- asynchronous state / Using agents
- independent state / Using agents
- algebraic structures / Demystifying category theory
- alts!! functions / Using channels
- alts! function / Using channels
- application
- errors, logging in / Logging errors in your application
- applicative functors
- using / Using applicative functors
- assert function / Writing tests
- associative / Using monoids
- atoms
- synchronous state / Using atoms
- used, for managing state / Using atoms
- independent state / Using atoms
- auto-gensym variable / Creating macros
B
- backtick
- URL / Creating macros
- Bacon.js library
- reference library / Using functional reactive programming
- behavior-driven development (BDD) / Testing with specs
- best practices, Clojure / Thinking in Clojure
- buffered channel / Using channels
C
- category theory
- demystifying / Demystifying category theory
- cats library
- chan function / Using channels
- channels
- using / Using channels
- customizing / Customizing channels
- connecting / Connecting channels
- dining philosophers problem / Revisiting the dining philosophers problem
- about / Using actors
- chunked sequences / What's wrong with sequences?
- chunks / What's wrong with sequences?
- CIDER
- reference link / Debugging your code
- claypoole library
- cljx library
- Clojure
- reference link / Using actors
- best practices / Thinking in Clojure
- Clojure style guide
- reference link / Thinking in Clojure
- code
- evaluating / Reading and evaluating code
- reading / Reading and evaluating code
- quoting / Quoting and unquoting code
- unquoting / Quoting and unquoting code
- transforming / Transforming code
- debugging / Debugging your code
- code debugging
- about / Debugging your code
- tracing, using / Using tracing
- Spyscope, using / Using Spyscope
- collections
- transforming, with reduce functions / Using reduce to transform collections, What's wrong with sequences?
- parallelizing, with fold / Using fold to parallelize collections
- combining function / Using fold to parallelize collections
- Communicating Sequential Processes
- reference link / Building reactive user interfaces
- Communicating Sequential Processes (CSPs) / Using channels
- compositional event systems (CESs) / Using functional reactive programming
- concurrent tasks
- managing / Managing concurrent tasks
- delays, using / Using delays
- futures, using / Using futures and promises
- promises, using / Using futures and promises
- core.async library
- reference link / Using channels
- core.logic library
- reference link / Diving into logic programming
- core.match
- core.typed library
- reference link / Testing with types
- union types / Testing with types
- parameterized types / Testing with types
- intersection types / Testing with types
- Counterclockwise
- reference link / Debugging your code
- CSP vs. FRP
- reference link / Building reactive user interfaces
D
- data
- processing, with reducers / Processing data with reducers
- dataflow programming / Reactive programming with fibers and dataflow variables
- dataflow variables
- used, for reactive programming / Reactive programming with fibers and dataflow variables
- about / Reactive programming with fibers and dataflow variables
- defun
- delay
- using / Using delays
- synchronous / Using delays
- deref function / Using delays
- design patterns / Encapsulating patterns in macros
- deterministic methodology / Managing state
- dining philosophers problem / Using refs
- revisiting / Revisiting the dining philosophers problem
- reference link / Revisiting the dining philosophers problem
- doo library
- reference link / Defining unit tests
- dropping-buffer function / Using channels
E
- errors
- handling, with actors / Handling errors with actors
- logging, in application / Logging errors in your application
- event bus / Using functional reactive programming
F
- fibers / Using actors
- used, for reactive programming / Reactive programming with fibers and dataflow variables
- about / Reactive programming with fibers and dataflow variables
- fold
- used, for parallelizing collections / Using fold to parallelize collections
- fold function / Using fold to parallelize collections
- force function / Using delays
- fork/join model / Using fold to parallelize collections
- functional reactive programming (FRP)
- functors
- using / Using functors
- futures
- using / Using futures and promises
G
- generative testing
- about / Generative testing
- reference link / Generative testing
- global vars / Using vars
H
- homoiconic language / Understanding the reader
- homomorphism / Using applicative functors
- hygenic macros / Creating macros
I
- identity element / Using monoids
- identity morphism / Demystifying category theory
- identity value / Using fold to parallelize collections
- infix notation / Creating macros
- Input / Using actors
- Integrated Development Environment (IDE) / Debugging your code
- interchange / Using applicative functors
- interning / Using vars
- iota library
J
- Java fork/join framework
- joint / Connecting channels
- joint fitting / Connecting channels
L
- laziness
- reference link / Thinking in Clojure
- lazy sequences / Thinking in sequences, Lazy sequences
- list comprehension
- creating / Transforming sequences
- local vars / Using vars
- logging configuration
- reference link / Logging errors in your application
- logical relations
- about / Diving into logic programming
- solving / Solving logical relations
- combining / Combining logical relations
- solutions, to problems / Thinking in logical relations
- n-queens problem, solving / Solving the n-queens problem
- Sudoku puzzle, solving / Solving a Sudoku puzzle
- logic programming
- exploring / Diving into logic programming
- logical relations, solving / Solving logical relations
- logical relations, combining / Combining logical relations
M
- macroexpanded / Understanding the reader
- macroexpansion / Understanding the reader
- macros
- expanding / Expanding macros
- creating / Creating macros
- patterns, encapsulating / Encapsulating patterns in macros
- avoiding / Avoiding macros
- thumb rules / Avoiding macros
- issues / Avoiding macros
- map function
- characteristics / What's wrong with sequences?
- metaconstants / Using top-down testing
- Midje library
- reference link / Using top-down testing
- miniKanren
- about / Diving into logic programming
- reference link / Diving into logic programming
- mix function / Connecting channels
- mocking / Writing tests
- monads
- using / Using monads
- monoid / Using fold to parallelize collections
- monoids
- using / Using monoids
- about / Using monoids
- morphisms / Demystifying category theory
- multithreading / Managing concurrent tasks
- mutable state, modeling
- identity / Managing state
- state / Managing state
- time / Managing state
N
- n-queens problem
- solving / Solving the n-queens problem
- reference link / Solving the n-queens problem
O
- objects / Demystifying category theory
- observables / Using Reactive Extensions
- observer / Using Reactive Extensions
- Om library
- reference link / Introducing Om
- about / Introducing Om
- optional typing / Testing with types
- Output / Using actors
P
- parallelism
- about / Executing tasks in parallel
- controlling, with thread pools / Controlling parallelism with thread pools
- parse tree / Understanding the reader
- pattern matching
- working with / Working with pattern matching
- pipe / Connecting channels
- postfix notation / Creating macros
- prefix notation / Understanding the reader
- processes
- about / Using channels
- comparing, with actors / Comparing processes and actors
- promises
- using / Using futures and promises
- publication / Connecting channels
- Pulsar library
- reference link / Using actors, Reactive programming with fibers and dataflow variables
Q
- queues
- about / Using channels
- quoting / Reading and evaluating code
R
- race condition / Managing state
- React.js
- reference link / Introducing Om
- reactive extensions (Rx)
- using / Using Reactive Extensions
- reactive programming
- fibers, using / Reactive programming with fibers and dataflow variables
- dataflow variables, using / Reactive programming with fibers and dataflow variables
- reactive user interfaces
- building / Building reactive user interfaces
- reader conditional form / Using reader conditionals
- reader conditionals
- using / Using reader conditionals
- reader conditional splicing form / Using reader conditionals
- reader macro
- about / Understanding the reader
- \x / Understanding the reader
- ; / Understanding the reader
- (.method o) / Understanding the reader
- @( ... ) / Understanding the reader
- @x / Understanding the reader
- ^{ ... } / Understanding the reader
- 'x or '( ... ) / Understanding the reader
- `x or `( ... ) / Understanding the reader
- ~x or ~( ... ) / Understanding the reader
- ~@x or ~@( ... ) / Understanding the reader
- #'x / Understanding the reader
- #=x or #=( ... ) / Understanding the reader
- #?( ... ) / Understanding the reader
- #?@( ... ) / Understanding the reader
- reader macros / Understanding the reader
- recursive functions
- defining / Defining recursive functions
- reduce functions
- used, for transforming collections / Using reduce to transform collections, What's wrong with sequences?
- reducers
- about / Introducing reducers
- used, for processing data / Processing data with reducers
- comparing, with transducers / Comparing transducers and reducers
- reducing function / Introducing reducers
- reducing function transformers / Introducing reducers
- reference types
- about / Managing state
- characterizing, ways / Managing state
- asynchronous / Managing state
- synchronous / Managing state
- mutation / Managing state
- refs
- used, for managing state / Using refs
- coordinated states / Using refs
- synchronous state / Using refs
- RxClojure library
- reference library / Using Reactive Extensions
S
- s-expression / Understanding the reader
- semigroup / Using monoids
- seqable / Thinking in sequences
- seq library
- using / Using the seq library
- sequence (seq)
- about / Thinking in sequences
- lazy sequences / Thinking in sequences, Lazy sequences
- creating / Creating sequences
- transforming / Transforming sequences
- filtering / Filtering sequences
- zippers, using / Using zippers
- sequences
- limitations / What's wrong with sequences?
- sexp / Understanding the reader
- sliding-buffer function / Using channels
- Software Transactional Memory (STM) / Using refs
- Speclj
- reference link / Testing with specs
- Specs
- reference link / Testing with specs
- used, for testing / Testing with specs
- Spyscope
- reference library / Using Spyscope
- using / Using Spyscope
- state
- managing / Managing state
- managing, with vars / Using vars
- managing, with refs / Using refs
- managing, with atoms / Using atoms
- managing, with agents / Using agents
- managing, with actors / Managing state with actors
- stubbing / Writing tests
- Sudoku puzzle
- solving / Solving a Sudoku puzzle
- symbol capture / Creating macros
- symbolic expression / Understanding the reader
- symbols / Understanding the reader
- syntax-quote
- URL / Creating macros
- syntax tree / Understanding the reader
T
- tasks
- executing, in parallel / Executing tasks in parallel
- test-driven development (TDD) / Defining unit tests
- testing
- with Specs / Testing with specs
- with types / Testing with types
- tests
- writing / Writing tests
- unit tests, defining / Defining unit tests
- top-down testing, using / Using top-down testing
- Thread/sleep method / Using delays
- threadpool / Using agents
- thread pools
- used, for controlling parallelism / Controlling parallelism with thread pools
- Timbre
- reference link / Logging errors in your application
- timeout / Using channels
- tools.nrepl library
- reference link / Thinking in Clojure
- tools.trace contrib library
- reference library / Using tracing
- top-down testing
- about / Using top-down testing
- using / Using top-down testing
- transducers
- about / Understanding transducers
- standard functions, URL / Understanding transducers
- results. producing / Producing results from transducers
- comparing, with reducers / Comparing transducers and reducers
- using / Transducers in action
- used, for managing volatile references / Managing volatile references
- creating / Creating transducers
- early termination / Creating transducers
- transformers / Introducing reducers
- truthy value / Using the seq library
- type checking / Testing with types
U
- unbound var / Using vars
- unbuffered / Using channels
- unit tests
- defining / Defining unit tests
V
- values / Understanding the reader
- variable capture / Creating macros
- vars
- used, for managing state / Using vars
- volatile references
- managing / Managing volatile references
W
- watch function / Using atoms
Y
- Yolk examples
- reference link / Using functional reactive programming
- Yolk library
- reference library / Using functional reactive programming
Z
- zippers
- using / Using zippers