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

_. (Underscore functions), Applicative Programming, reduceRight, reduceRight, reject, all, any, sortBy, groupBy, and countBy, sortBy, groupBy, and countBy, sortBy, groupBy, and countBy, Data Thinking, Data Thinking, Data Thinking, Data Thinking, Data Thinking, Data Thinking, Data Thinking, Data Thinking, Data Thinking, Data Thinking, “Table-Like” Data, “Table-Like” Data, “Table-Like” Data, Global Scope, Thinking About Passing Functions: max, finder, and best, More Thinking About Passing Functions: repeat, repeatedly, and iterateUntil, Stitching Functions End-to-End with Compose, Summary, Self-Absorbed Functions (Functions That Call Themselves), Deep Cloning with Recursion, Purity, The Relationship Between Purity and Testing, Observing Immutability at the Function Level, Chaining, Chaining, Chaining
_.all, all
_.any, any
_.chain, Chaining
_.clone, Deep Cloning with Recursion
_.compose, Stitching Functions End-to-End with Compose, Summary
_.countBy, sortBy, groupBy, and countBy
_.defaults, Data Thinking
_.extend, Observing Immutability at the Function Level
_.findWhere, Data Thinking
_.groupBy, sortBy, groupBy, and countBy
_.invert, Data Thinking
_.keys, Data Thinking
_.map, The Relationship Between Purity and Testing
_.max, Thinking About Passing Functions: max, finder, and best, More Thinking About Passing Functions: repeat, repeatedly, and iterateUntil
_.noConflict, Global Scope
_.object, Data Thinking
_.omit, Data Thinking
_.pairs, Data Thinking
_.pick, “Table-Like” Data
_.pluck, Data Thinking, “Table-Like” Data
_.random, Purity
_.reduce, Applicative Programming, reduceRight, “Table-Like” Data
_.reduceRight, reduceRight
_.reject, reject
_.sortBy, sortBy, groupBy, and countBy
_.tap, Chaining
_.value, Chaining
_.values, Data Thinking
_.where, Data Thinking
_.zip, Self-Absorbed Functions (Functions That Call Themselves)
(see also functions)

A

abstract tasks, “Table-Like” Data, Closures as an Abstraction
accumulator arguments, Depth-First Self-Recursive Search with Memory, Recursion and Composing Functions: Conjoin and Disjoin
_.all function, all
allong.es library (Braithwaite), allong.es
always function, Functions That Return Other Functions
andify function, Recursion and Composing Functions: Conjoin and Disjoin
_.any function, any
applicative programming, Applicative Programming–Defining a Few Applicative Functions, Summary
arguments, Capturing Arguments to Higher-Order Functions, Partial Application–Partial Application in Action: Preconditions, Self-Absorbed Functions (Functions That Call Themselves), Depth-First Self-Recursive Search with Memory
accumulator arguments, Depth-First Self-Recursive Search with Memory
capturing to higher-order functions, Capturing Arguments to Higher-Order Functions
in recursive functions, Self-Absorbed Functions (Functions That Call Themselves)
partial application of, Partial Application–Partial Application in Action: Preconditions
array indexing, Functions as Units of Behavior
Array#forEach method, The Case for JavaScript
Array#map method, A Taste of Functional JavaScript
Array#sort method, Functions as Units of Behavior
arrays, Data as Abstraction, Data Thinking, Self-Absorbed Functions (Functions That Call Themselves), Self-Absorbed Functions (Functions That Call Themselves), Walking Nested Arrays
building with recursion, Self-Absorbed Functions (Functions That Call Themselves)
“consuming” with recursion, Self-Absorbed Functions (Functions That Call Themselves)
nested, Data as Abstraction, Data Thinking, Walking Nested Arrays
associative data, Data Thinking
asynchronous change, ensuring coherence in, Class Hierarchies
asynchronous libraries, The Trampoline Principle and Callbacks

B

Batman (Bruce Wayne), What Is Underscore?
best function, Tightening it up a bit
Bilby library (McKenna), Bilby
binding, definition of, Variable Scope and Closures
“blowing the stack” error, Too Much Recursion!
Braithwaite, Reginald, allong.es

C

callbacks, The Trampoline Principle and Callbacks
captured variable, Free variables
_.chain function, Chaining
chaining, Chaining (see method chaining)
class hierarchies, Class Hierarchies, Class Hierarchies–Flattening the Hierarchy with Mixins, Changing Hierarchies, Flattening the Hierarchy with Mixins
basics of, Class Hierarchies
changing, Changing Hierarchies
flattening with mixins, Flattening the Hierarchy with Mixins
class-based object system, Data as Abstraction, Programming Without Class
client-service application architectures, The Case for JavaScript
Clojure programming language, Underscore-contrib
ClojureScript programming language, ClojureScript–ClojureScript
_.clone function, Deep Cloning with Recursion
Closure: The Definitive Guide (Bolin), Papers/Books/Blog Posts/Talks
closures, Encapsulation and Hiding, Closures–Closures as an Abstraction, Closures, Simulating Closures–Shadowing, Simulating Closures, Using Closures, Closures as an Abstraction, Summary, Functions That Return Other Functions
as abstractions, Closures as an Abstraction
definition of, Closures, Simulating Closures
hiding data with, Encapsulation and Hiding
overview of, Summary
simulation of, Simulating Closures–Shadowing
using, Using Closures, Functions That Return Other Functions
Codd library (Fogus), Underscore-contrib
code elision, On Speed
code in-lining, On Speed
CoffeeScript programming language, CoffeeScript
collection-centric programming, Collection-Centric Programming
combinators, Functions That Return Other Functions, Recursion and Composing Functions: Conjoin and Disjoin
command/query separation, Pipelining
comparator function, Functions as Units of Behavior
comparators, Functions as Units of Behavior
compare-and-swap semantics, Class Hierarchies, New Types via Mixin Mixing
comparison, of arbitrary objects, Thinking About Passing Functions: max, finder, and best
complement function, Using Closures
_.compose function, Stitching Functions End-to-End with Compose, Summary
constructPair function, Self-Absorbed Functions (Functions That Call Themselves)
control flow vs. data flow, Data Flow versus Control Flow–A Function to Simplify Action Creation
core prototype munging, Core Prototype Munging
_.countBy function, sortBy, groupBy, and countBy
Crockford, Douglas, The Source Code for Functional JavaScript, Whom Functional JavaScript Is Written For
cross-browser incompatability, The Case for Underscore
currying, Currying–Automatically Currying Parameters, Currying, Currying, Currying–The Disadvantages of Currying in JavaScript, To Curry Right, or To Curry Left, Automatically Currying Parameters, Currying for Fluent APIs, The Disadvantages of Currying in JavaScript, Partial Application, Summary, Pipelining
automatic, Automatically Currying Parameters
definition of, Currying
direction of, To Curry Right, or To Curry Left
disadvantages of, The Disadvantages of Currying in JavaScript
for fluent APIs, Currying for Fluent APIs
left-to-right currying, Currying
overview of, Summary
vs. partial application, Partial Application
and pipelines, Pipelining
right-to-left currying, Currying–Automatically Currying Parameters

D

data, Data as Abstraction, “Table-Like” Data, Graph Walking with Recursion, Generators, Purity, Immutability
as abstraction, Data as Abstraction
generating lazy, Generators
generating random, Purity
graph-like structure, Graph Walking with Recursion
immutable types of, Immutability
table-like data, “Table-Like” Data
data flow vs. control flow, Data Flow versus Control Flow–A Function to Simplify Action Creation
data handling, Data as Abstraction, Data Thinking, Pipelining
associative data technique, Data Thinking
functional vs. object-oriented, Data as Abstraction
improving explicitness of, Pipelining
data hiding, Encapsulation and Hiding, Capturing Variables for Great Good
data orientation, Data Orientation–Building Toward Functions
data tables, Data as Abstraction
data transformation, Why Functional Programming Matters, Data as Abstraction, “Table-Like” Data, Pipelining
for abstract tasks, “Table-Like” Data
functions and, Data as Abstraction
nondestructive, Why Functional Programming Matters
pipelined functions for, Pipelining
data-centric thinking, “Table-Like” Data
declarative, Data Thinking, Partial Application in Action: Preconditions, RxJS
deepClone function, Deep Cloning with Recursion
_.defaults function, Data Thinking
default values, assigning lazily, A Function to Guard Against Nonexistence: fnull
depthSearch function, Depth-First Self-Recursive Search with Memory
dispatch function, The Essence of Functional Composition
dynamic scope, Dynamic Scope–JavaScript’s Dynamic Scope

E

ECMAScript.next, The Case for JavaScript, Data as Abstraction, Data Thinking, Function Scope, Capturing Variables for Great Good, A Function to Guard Against Nonexistence: fnull, Tail (self-)recursion, Generators, Flattening the Hierarchy with Mixins
Elm programming language, Elm
encapsulation, Encapsulation and Hiding
executeIfHasField, A Taste of Functional JavaScript
existy function, A Taste of Functional JavaScript
_.extend function, Observing Immutability at the Function Level
extent, Global Scope

F

filter function, Applicative Programming
find function, find
finder function, Thinking About Passing Functions: max, finder, and best
_.findWhere function, Data Thinking
first-class functions, Functions as First-Class Things, Summary, Closures, Higher-Order Functions, Function-Building Functions
and closures, Closures
building on the fly, Function-Building Functions
definition of, Functions as First-Class Things
and higher-order functions, Higher-Order Functions
overview of, Summary
flow-based programming, Flow-Based Programming–Summary, Chaining–Promises, Pipelining–Pipelining, Data Flow versus Control Flow–A Function to Simplify Action Creation
chaining, Chaining–Promises
data flow vs. control flow, Data Flow versus Control Flow–A Function to Simplify Action Creation
pipelining, Pipelining–Pipelining
fnull function, A Function to Guard Against Nonexistence: fnull
free variables, Free variables
Friebyrd library (Fogus), Underscore-contrib
function scope, Function Scope
Function#apply method, The Case for JavaScript–The Case for JavaScript, Lexical Scope
and dynamic scope, Lexical Scope
Function#call method, The Case for JavaScript, Metaprogramming, JavaScript’s Dynamic Scope, JavaScript’s Dynamic Scope–JavaScript’s Dynamic Scope, Flattening the Hierarchy with Mixins
and dynamic scope, JavaScript’s Dynamic Scope
as subclass initializer, Metaprogramming, Flattening the Hierarchy with Mixins
functional composition, Function-Building Functions–Summary, The Essence of Functional Composition–Mutation Is a Low-Level Operation, Currying–The Disadvantages of Currying in JavaScript, Partial Application–Partial Application in Action: Preconditions, Stitching Functions End-to-End with Compose, Summary, Recursion and Composing Functions: Conjoin and Disjoin, }).call(“Finis”);
compose function, Stitching Functions End-to-End with Compose
creating combinators, Recursion and Composing Functions: Conjoin and Disjoin
currying, Currying–The Disadvantages of Currying in JavaScript
essence of, The Essence of Functional Composition–Mutation Is a Low-Level Operation
overview of, Summary
partial application, Partial Application–Partial Application in Action: Preconditions
vs. object-oriented approach, }).call(“Finis”);
Functional JavaScript, The Source Code for Functional JavaScript, Notational Conventions, Whom Functional JavaScript Is Written For, A Roadmap for Functional JavaScript, Data as Abstraction
focus on arrays and objects, Data as Abstraction
notational conventions used, Notational Conventions
prerequisites to learning, Whom Functional JavaScript Is Written For
source code for, The Source Code for Functional JavaScript
topic outline, A Roadmap for Functional JavaScript
Functional JavaScript library (Steele), Functional JavaScript
functional programming, What Is Underscore?, The Case for JavaScript, Getting Started with Functional Programming–On Speed, Why Functional Programming Matters, Encapsulation and Hiding, Data as Abstraction, A Taste of Functional JavaScript, On Speed–On Speed, Summary, Functions as First-Class Things, Imperative programming, Prototype-based object-oriented programming, Metaprogramming, Defining a Few Applicative Functions, Mutation Is a Low-Level Operation, Recursion, Purity, Immutability, and Policies for Change, Purity and the Relationship to Idempotence, Pipelining, Data Orientation, Core Prototype Munging, }).call(“Finis”);, Functional Libraries for JavaScript–Other Functional Libraries
basics of, Getting Started with Functional Programming–On Speed
chain of calls in, Pipelining
definition of, Functions as First-Class Things
example of, A Taste of Functional JavaScript
flexibility of, }).call(“Finis”);
idempotence and, Purity and the Relationship to Idempotence
vs. imperative programming, Imperative programming
JavaScript support for, What Is Underscore?, The Case for JavaScript, Functional Libraries for JavaScript–Other Functional Libraries
key facet of, Defining a Few Applicative Functions
vs. metaprogramming, Metaprogramming
and mutation, Mutation Is a Low-Level Operation
vs. object-oriented approach, Why Functional Programming Matters, Encapsulation and Hiding, Data as Abstraction, Data Orientation
overview of, Summary
vs. prototype-based OOP, Prototype-based object-oriented programming, Core Prototype Munging
reducing complexity with, Purity, Immutability, and Policies for Change
relation to recursion, Recursion
speed of, On Speed–On Speed
Functional Reactive Programming (FRP), Elm
functions, Why Functional Programming Matters, Functions as Units of Abstraction, Functions as Units of Abstraction, Functions as Units of Behavior, Functions as Units of Behavior, Functions as Units of Behavior, A Taste of Functional JavaScript, A Taste of Functional JavaScript, Functions as First-Class Things–Metaprogramming, Prototype-based object-oriented programming, Applicative Programming, Applicative Programming, Applicative Programming, find, Defining a Few Applicative Functions, Data Thinking, “Table-Like” Data, Summary, Closures, Using Closures, Using Closures, Closures as an Abstraction, Higher-Order Functions, Higher-Order Functions–Summary, Functions That Take Other Functions–I said, “Use functions, not values”, Thinking About Passing Functions: max, finder, and best, Tightening it up a bit, More Thinking About Passing Functions: repeat, repeatedly, and iterateUntil, Use functions, not values, I said, “Use functions, not values”, Functions That Return Other Functions, Functions That Return Other Functions–A Function to Guard Against Nonexistence: fnull, Functions That Return Other Functions, Functions That Return Other Functions, Capturing Variables for Great Good, Capturing Variables for Great Good, A Function to Guard Against Nonexistence: fnull, Function-Building Functions, Function-Building Functions–Summary, The Essence of Functional Composition, The Essence of Functional Composition, Currying, Building new functions using currying, Self-Absorbed Functions (Functions That Call Themselves)–Recursion and Composing Functions: Conjoin and Disjoin, Self-Absorbed Functions (Functions That Call Themselves), Graph Walking with Recursion, Depth-First Self-Recursive Search with Memory, Recursion and Composing Functions: Conjoin and Disjoin, Codependent Functions (Functions Calling Other Functions That Call Back)–Walking Nested Arrays, Deep Cloning with Recursion, Walking Nested Arrays, Recursion Is a Low-Level Operation, The Relationship Between Purity and Testing, Observing Immutability at the Function Level, Observing Immutability at the Function Level, Data Flow versus Control Flow
always function, Functions That Return Other Functions
andify function, Recursion and Composing Functions: Conjoin and Disjoin
applicative functions, Defining a Few Applicative Functions
as units of abstraction, Functions as Units of Abstraction
as units of behavior, Functions as Units of Behavior
best function, Tightening it up a bit
building with currying, Building new functions using currying
comparator function, Functions as Units of Behavior
complement function, Using Closures
deepClone function, Deep Cloning with Recursion
definition of, Prototype-based object-oriented programming
depthSearch function, Depth-First Self-Recursive Search with Memory
dispatch function, The Essence of Functional Composition
existy function, A Taste of Functional JavaScript
filter function, Applicative Programming
find function, find
finder function, Thinking About Passing Functions: max, finder, and best
first-class functions, Functions as First-Class Things–Metaprogramming, Summary, Closures, Higher-Order Functions, Function-Building Functions
fnull function, A Function to Guard Against Nonexistence: fnull
function-building functions, Function-Building Functions–Summary
function-returning functions, Functions That Return Other Functions–A Function to Guard Against Nonexistence: fnull
function-taking functions, Functions That Take Other Functions–I said, “Use functions, not values”
higher-order functions, Functions as Units of Behavior, Higher-Order Functions–Summary, Recursion Is a Low-Level Operation
and immutability, Observing Immutability at the Function Level
in functional programming, Why Functional Programming Matters
of incongruous return types, Data Flow versus Control Flow
invoker function, Functions That Return Other Functions, Currying
iterateUntil function, I said, “Use functions, not values”
makeUniqueStringFunction, Capturing Variables for Great Good
map function, Applicative Programming
mutually recursive, Codependent Functions (Functions Calling Other Functions That Call Back)–Walking Nested Arrays
nexts function, Graph Walking with Recursion
parseAge function, Functions as Units of Abstraction
plucker function, Closures as an Abstraction
polymorphic functions, The Essence of Functional Composition
pure functions, The Relationship Between Purity and Testing, Observing Immutability at the Function Level
reduce function, Applicative Programming
repeat function, More Thinking About Passing Functions: repeat, repeatedly, and iterateUntil
repeatedly function, Use functions, not values, Functions That Return Other Functions
restrict function, “Table-Like” Data
selector functions, Data Thinking
self-recursive functions, Self-Absorbed Functions (Functions That Call Themselves)–Recursion and Composing Functions: Conjoin and Disjoin
truthy function, A Taste of Functional JavaScript, Using Closures
uniqueString function, Capturing Variables for Great Good
unzip function, Self-Absorbed Functions (Functions That Call Themselves)
visit function, Walking Nested Arrays
(see also _. Underscore functions)

G

global scope, Global Scope
Google Apps, The Case for JavaScript
Google Closure compiler, On Speed
_.groupBy function, sortBy, groupBy, and countBy

H

hex color builders, Currying three parameters to implement HTML hex color builders
Hickey, Rich, If a Tree Falls in the Woods, Does It Make a Sound?
higher-order functions, Higher-Order Functions, Higher-Order Functions–Summary, Functions That Take Other Functions–I said, “Use functions, not values”, Thinking About Passing Functions: max, finder, and best, Thinking About Passing Functions: max, finder, and best, Tightening it up a bit, Use functions, not values, I said, “Use functions, not values”, Functions That Return Other Functions, Functions That Return Other Functions–A Function to Guard Against Nonexistence: fnull, Functions That Return Other Functions, Functions That Return Other Functions, Capturing Arguments to Higher-Order Functions, Capturing Variables for Great Good, A Function to Guard Against Nonexistence: fnull, Summary, Recursion Is a Low-Level Operation
always function, Functions That Return Other Functions
best function, Tightening it up a bit
capturing arguments to, Capturing Arguments to Higher-Order Functions
capturing variables, Capturing Variables for Great Good
definition of, Higher-Order Functions
finder function, Thinking About Passing Functions: max, finder, and best
fnull function, A Function to Guard Against Nonexistence: fnull
function-returning functions, Functions That Return Other Functions–A Function to Guard Against Nonexistence: fnull
function-taking functions, Functions That Take Other Functions–I said, “Use functions, not values”
invoker function, Functions That Return Other Functions
iterateUntil function, I said, “Use functions, not values”
_.max function, Thinking About Passing Functions: max, finder, and best
overview of, Summary
vs. recursion, Recursion Is a Low-Level Operation
repeatedly function, Use functions, not values, Functions That Return Other Functions
HTML hex colors builders, Currying three parameters to implement HTML hex color builders

I

idempotence, Purity and the Relationship to Idempotence
immutability, Immutability–Objects Are Often a Low-Level Operation, Immutability, If a Tree Falls in the Woods, Does It Make a Sound?, Immutability and the Relationship to Recursion, Defensive Freezing and Cloning, Observing Immutability at the Function Level, Observing Immutability in Objects–Observing Immutability in Objects, Policies for Controlling Change, Summary
at function level, Observing Immutability at the Function Level
benefits of, Immutability, If a Tree Falls in the Woods, Does It Make a Sound?
defensive freezing and cloning, Defensive Freezing and Cloning
in objects, Observing Immutability in Objects–Observing Immutability in Objects
overview of, Summary
policies for, Policies for Controlling Change
and recursion, Immutability and the Relationship to Recursion
imperative programming, Some Limitations of JavaScript, Imperative programming, Mutation Is a Low-Level Operation
implicit global scope, Global Scope
in-lining optimizations, On Speed
_.invert function, Data Thinking
invoker function, Functions That Return Other Functions, Currying
iterateUntil function, I said, “Use functions, not values”

J

JavaScript, The Case for JavaScript, Some Limitations of JavaScript, Data as Abstraction, Data as Abstraction, Functions as First-Class Things, JavaScript’s Multiple Paradigms–Metaprogramming, Prototype-based object-oriented programming, JavaScript’s Dynamic Scope, Closures, Putting It All Together: Object Validators, Deep Cloning with Recursion, Too Much Recursion!, The Trampoline Principle and Callbacks, Immutability, Data Orientation, Functional Libraries for JavaScript–Other Functional Libraries, Functional Programming Languages Targeting JavaScript
as a functional language, Functions as First-Class Things
asynchronous APIs, The Trampoline Principle and Callbacks
dynamic scope in, JavaScript’s Dynamic Scope
eliminating named types/hierarchies with, Data Orientation
everything-is-an-object foundation of, Deep Cloning with Recursion
first-class functions and, Closures
functional libraries for, Functional Libraries for JavaScript–Other Functional Libraries
functional programming languages for, Functional Programming Languages Targeting JavaScript
immutability in, Immutability
limitations of, Some Limitations of JavaScript, Too Much Recursion!
multiple paradigms of, JavaScript’s Multiple Paradigms–Metaprogramming
object prototype model, Data as Abstraction
reasons to use, The Case for JavaScript, Data as Abstraction
this-reference semantics, Prototype-based object-oriented programming
validation in, Putting It All Together: Object Validators
JavaScript: The Definitive Guide, 6th Edition (Flanagan), Papers/Books/Blog Posts/Talks
JavaScript: The Good Parts (Crockford), Whom Functional JavaScript Is Written For, Some Limitations of JavaScript, Papers/Books/Blog Posts/Talks
jQuery, On Speed, Promises
functional idioms in, On Speed
promises, Promises

K

_.keys function, Data Thinking

L

lazy data, definition of, Generators
LazyChain object, A Lazy Chain, Data Orientation
Lemonad library (Fogus), The Source Code for Functional JavaScript, Underscore-contrib
lexical scope, Lexical Scope
lookup schemes, Lexical Scope

M

makeUniqueString function, Capturing Variables for Great Good
map function, Applicative Programming, The Relationship Between Purity and Testing
Math#max, Thinking About Passing Functions: max, finder, and best, Tightening it up a bit
_.max function, Thinking About Passing Functions: max, finder, and best, More Thinking About Passing Functions: repeat, repeatedly, and iterateUntil
McKenna, Brian, Bilby
metaprogramming, Metaprogramming
method chaining, Chaining, Chaining, Chaining, Chaining, A Lazy Chain, Promises, Pipelining, Summary
benefits of, Chaining
_.chain function, Chaining
downsides to, Pipelining
lazy chains, A Lazy Chain
overview of, Summary
promises, Promises
_.tap function, Chaining
_.value function, Chaining
methods, Prototype-based object-oriented programming, Methods Are Low-Level Operations
definition of, Prototype-based object-oriented programming
as low-level operations, Methods Are Low-Level Operations
Microsoft’s RxJS library, RxJS
Minker library (Fogus), Underscore-contrib
mixin-based extensions, Mixins–Methods Are Low-Level Operations
mixins, Mixins, Mixins–Methods Are Low-Level Operations, Core Prototype Munging, Class Hierarchies–Flattening the Hierarchy with Mixins, Flattening the Hierarchy with Mixins, Flattening the Hierarchy with Mixins, New Semantics via Mixin Extension, New Types via Mixin Mixing
and class hierarchies, Class Hierarchies–Flattening the Hierarchy with Mixins
definition of, Flattening the Hierarchy with Mixins
flattening hierarchies with, Flattening the Hierarchy with Mixins
need for, Mixins
new semantics with, New Semantics via Mixin Extension
new types with, New Types via Mixin Mixing
vs. core prototype munging, Core Prototype Munging
monads, Finding a Common Shape
mutations, Putting It All Together: Object Validators, Mutation Is a Low-Level Operation, Purity and the Relationship to Idempotence, Immutability, If a Tree Falls in the Woods, Does It Make a Sound?–Immutability and the Relationship to Recursion, Defensive Freezing and Cloning–Defensive Freezing and Cloning, Observing Immutability at the Function Level–Observing Immutability at the Function Level, Policies for Controlling Change
as low-level operation, Mutation Is a Low-Level Operation
avoid by freezing, Defensive Freezing and Cloning–Defensive Freezing and Cloning
hiding, Putting It All Together: Object Validators, If a Tree Falls in the Woods, Does It Make a Sound?–Immutability and the Relationship to Recursion, Observing Immutability at the Function Level–Observing Immutability at the Function Level
in JavaScript, Purity and the Relationship to Idempotence, Immutability
policies for control of, Policies for Controlling Change
(see also immutability)
mutually recursive functions, Codependent Functions (Functions Calling Other Functions That Call Back)
myLength operation, Self-Absorbed Functions (Functions That Call Themselves)

N

nexts function, Graph Walking with Recursion
_.noConflict function, Global Scope
number, generating random, Purity

O

_.object function, Data Thinking
object oriented programming (OOP), Why Functional Programming Matters, Encapsulation and Hiding, Prototype-based object-oriented programming, Programming Without Class, }).call(“Finis”);
object validators, Putting It All Together: Object Validators
Object#freeze operation, Defensive Freezing and Cloning
object-centric thinking, Data Orientation, Mixins
objects, Thinking About Passing Functions: max, finder, and best, Deep Cloning with Recursion, Immutability, Defensive Freezing and Cloning, Observing Immutability in Objects, Objects Are Often a Low-Level Operation
comparing arbitrary, Thinking About Passing Functions: max, finder, and best
deep cloning of, Deep Cloning with Recursion
defensive freezing of, Defensive Freezing and Cloning
as low-level operations, Objects Are Often a Low-Level Operation
mutability of, Immutability
pervasive freezing of, Observing Immutability in Objects
_.omit function, Data Thinking
OOP, Why Functional Programming Matters (see object oriented programming)
optimizations, On Speed

P

_.pairs function, Data Thinking
parseAge function, Functions as Units of Abstraction
partial application, Partial Application–Partial Application in Action: Preconditions, Partial Application, Partially Applying One and Two Known Arguments, Partially Applying an Arbitrary Number of Arguments, Partial Application in Action: Preconditions, Summary, Pipelining
of arbitrary number of arguments, Partially Applying an Arbitrary Number of Arguments
vs. currying, Partial Application
of one and two known arguments, Partially Applying One and Two Known Arguments
overview of, Summary
and pipelines, Pipelining
preconditions, Partial Application in Action: Preconditions
_.pick function, “Table-Like” Data
pipelining, Pipelining–Pipelining, Summary, Building Toward Functions
_.pluck function, Data Thinking, “Table-Like” Data
plucker function, Closures as an Abstraction
polymorphic functions, The Essence of Functional Composition
predicates, Functions as Units of Behavior
program optimizers, On Speed
promises, Promises
property testing, Property-Testing Impure Functions–Property-Testing Impure Functions
prototype chains, Prototype-based object-oriented programming
prototype-based object-oriented programming, Prototype-based object-oriented programming, Core Prototype Munging
purity, Purity–Purity and the Relationship to Idempotence, Purity, The Relationship Between Purity and Testing, Separating the Pure from the Impure, Property-Testing Impure Functions, Purity and the Relationship to Referential Transparency, Purity and the Relationship to Idempotence, Summary
determination of, Purity
and idempotence, Purity and the Relationship to Idempotence
isolating impure functions, Separating the Pure from the Impure
overview of, Summary
properties of, The Relationship Between Purity and Testing
and referential transparency, Purity and the Relationship to Referential Transparency
testing impure functions, Property-Testing Impure Functions

R

_.random functions, Purity
random numbers, Purity
Reactive Extensions for JavaScript (RxJS), RxJS
recursion, Recursion–Summary, Self-Absorbed Functions (Functions That Call Themselves), Self-Absorbed Functions (Functions That Call Themselves)–Recursion and Composing Functions: Conjoin and Disjoin, Self-Absorbed Functions (Functions That Call Themselves), Codependent Functions (Functions Calling Other Functions That Call Back)–Walking Nested Arrays, Deep Cloning with Recursion, Walking Nested Arrays, Too Much Recursion!, Generators, Generators, Recursion Is a Low-Level Operation, Summary, Immutability and the Relationship to Recursion
benefits of, Self-Absorbed Functions (Functions That Call Themselves)
codependent function, Codependent Functions (Functions Calling Other Functions That Call Back)–Walking Nested Arrays
deep cloning with, Deep Cloning with Recursion
and immutability, Immutability and the Relationship to Recursion
lazy data streams, Generators
as low-level operation, Recursion Is a Low-Level Operation
overview of, Summary
potential errors, Too Much Recursion!, Generators
rules of thumb for, Self-Absorbed Functions (Functions That Call Themselves)
self-absorbed functions, Self-Absorbed Functions (Functions That Call Themselves)–Recursion and Composing Functions: Conjoin and Disjoin
traversing nested arrays, Walking Nested Arrays
_.reduce function, Applicative Programming–reduceRight, “Table-Like” Data
_.reduceRight function, reduceRight
referential transparency, Take care when mutating values, Purity and the Relationship to Referential Transparency
_.reject function, reject
rename utility, “Table-Like” Data
repeat function, More Thinking About Passing Functions: repeat, repeatedly, and iterateUntil
repeatedly function, Use functions, not values, Functions That Return Other Functions
RESTful architectures, Purity and the Relationship to Idempotence
restrict function, “Table-Like” Data
Roy programming language, Roy
run-to-completion guarantees, Class Hierarchies
runtime speed enhancements, On Speed
RxJS library, RxJS

S

scope, Variable Scope and Closures, Global Scope–Function Scope, Global Scope
definitions of, Variable Scope and Closures
extent of, Global Scope
variable scope, Global Scope–Function Scope
searches, depth-first self-recursive, Depth-First Self-Recursive Search with Memory
select* functions, Data as Abstraction
selector functions, Data Thinking
self-absorbed functions, Self-Absorbed Functions (Functions That Call Themselves)–Recursion and Composing Functions: Conjoin and Disjoin, Self-Absorbed Functions (Functions That Call Themselves), Self-Absorbed Functions (Functions That Call Themselves), Self-Absorbed Functions (Functions That Call Themselves), Self-Absorbed Functions (Functions That Call Themselves), Graph Walking with Recursion, Depth-First Self-Recursive Search with Memory, Tail (self-)recursion, Recursion and Composing Functions: Conjoin and Disjoin
benefits of, Self-Absorbed Functions (Functions That Call Themselves)
building arrays with, Self-Absorbed Functions (Functions That Call Themselves)
“consuming” arrays with, Self-Absorbed Functions (Functions That Call Themselves)
creating combinators, Recursion and Composing Functions: Conjoin and Disjoin
depth-first search, Depth-First Self-Recursive Search with Memory
for graph-like data structures, Graph Walking with Recursion
rules of thumb for, Self-Absorbed Functions (Functions That Call Themselves), Tail (self-)recursion
self-recursion, Self-Absorbed Functions (Functions That Call Themselves)
shadowing, Shadowing
short-circuiting laziness, Recursion and Composing Functions: Conjoin and Disjoin
single-page application architectures, The Case for JavaScript
_.sortBy function, sortBy, groupBy, and countBy
stack explosions, Too Much Recursion!
static optimization, On Speed
Steele, Oliver, Functional JavaScript

T

tables, Data as Abstraction, “Table-Like” Data
table-like data, “Table-Like” Data
with nested arrays, Data as Abstraction
tail (self)-recursion, Tail (self-)recursion
_.tap function, Chaining
tasks, “Table-Like” Data, Closures as an Abstraction, The Trampoline Principle and Callbacks
abstract, “Table-Like” Data, Closures as an Abstraction
performing concurrent, The Trampoline Principle and Callbacks
test-driven development (TDD), Functions as Units of Abstraction
this reference, JavaScript’s Dynamic Scope
this-reference semantics, Prototype-based object-oriented programming
thunks, definition of, A Lazy Chain
time-sensitive states, Purity and the Relationship to Idempotence
“Too much recursion” error, Too Much Recursion!, Generators
trampoline, Too Much Recursion!, Generators, The Trampoline Principle and Callbacks–The Trampoline Principle and Callbacks
and callbacks, The Trampoline Principle and Callbacks–The Trampoline Principle and Callbacks
trampoline principle, Generators
trampoline principle, Generators
truthy function, A Taste of Functional JavaScript, Using Closures

U

Underscore-contrib library, Underscore-contrib
Underscore.js, What Is Underscore?, Getting Underscore, Using Underscore, The Case for Underscore, Pipelining
description of, What Is Underscore?
downloading, Getting Underscore
first arguments in, Pipelining
interacting with, Using Underscore
reasons for choosing, The Case for Underscore
uniqueString function, Capturing Variables for Great Good
unzip function, Self-Absorbed Functions (Functions That Call Themselves)

V

validation testing, The Relationship Between Purity and Testing, Property-Testing Impure Functions
and purity, The Relationship Between Purity and Testing
of impure functions, Property-Testing Impure Functions
validators, Putting It All Together: Object Validators
_.value function, Chaining
_.values function, Data Thinking
values, building with recursion, Self-Absorbed Functions (Functions That Call Themselves)
var keyword, Global Scope
variable scope, Variable Scope and Closures–Function Scope, Global Scope–Global Scope, Lexical Scope–Lexical Scope, Dynamic Scope–JavaScript’s Dynamic Scope, Function Scope–Function Scope, Summary
dynamic scope, Dynamic Scope–JavaScript’s Dynamic Scope
function scope, Function Scope–Function Scope
global scope, Global Scope–Global Scope
lexical scope, Lexical Scope–Lexical Scope
overview of, Summary
variables, Global Scope, Global Scope, Free variables, Shadowing, Capturing Variables for Great Good, Capturing Variables for Great Good, Take care when mutating values
capturing, Capturing Variables for Great Good
creating private, Capturing Variables for Great Good
free variables, Free variables
lifetime of, Global Scope
mutability of, Global Scope, Take care when mutating values
shadowing of, Shadowing
visit function, Walking Nested Arrays

W

“web of mutation”, Immutability–Immutability, Policies for Controlling Change
_.where function, Data Thinking

Z

_.zip function, Self-Absorbed Functions (Functions That Call Themselves)
zombie, Data Thinking–Data Thinking
..................Content has been hidden....................

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