Index

converting from Java to Scala, Everything Is a Statement
Customer.java file, Introduction to XXY
defined as case class, Converting to Pattern Matches
eachEnabledContact method, printing out contacts, Code as Data
enabledContacts() method, Strict and Nonstrict Evaluations–Nonstrict (Lazy) Evaluation
getEnabledCustomerNames function, Functions as Objects
immutable Customer object, Immutability
making Customer.allCustomers an immutable list, Immutability
map function, Side Effects
refactoring Customer.java code into Groovy, Making the Switch to Groovy
Scala basic pattern match in createCustomer, Simple Matches
Scala extraction pattern match in createCustomer, Simple Patterns
Scala imperative createCustomer method using if structure, Simple Matches
sendEnabledCustomersEmail() method, Mutability
setters returning this, Side Effects
updateContractForCustomerList() method, Immutability
updating to have its own foreach function, Purifying Our Functions

customers, creating from command line (example), Code as Data–Code as Data

D

Database object (example), Putting It All Together

database transactions, Immutability

databases

ORMs, lazy fetch, Conclusion
writing a functional database, taking it further, Conclusion
writing a simple functional database in Scala (example), Putting It All Together–Conclusion

depth of recursion, limits on, Recursion

design patterns, New Design Patterns

message passing for concurrency, Message Passing for Concurrency
object to singleton method purity, Object to Singleton Method Purity
Option pattern, The Option Pattern (Extension of Null Object Pattern)

driver code, Conclusion

DRY (Don’t Repeat Yourself) principle, Introduction to XXY

dynamically typed languages, Making the Switch to Groovy

E

Email class (example), Static Encapsulation

as a container, Objects As Containers
with isDearReader and name fields, Objects As Containers

Email object (example), Static Encapsulation

extracting the send function with common functionality, Objects As Containers
updating to use isDearReader and name fields, Objects As Containers
with isDearReader field, using pattern match, Objects As Containers

end case, Recursion

Filter function end case with list head creation, An Introduction to Recursion
Filter function using tail recursion, Tail Recursion
Filter function with only the end case, An Introduction to Recursion
recursive function counting enabled customers with disabled contacts, Recursion

Erlang, What Next?

error logging, extracting into error function in createCustomer (example), Extracting Objects

evaluations, strict and nonstrict, Strict and Nonstrict Evaluations–Conclusion

Groovy TestClass with lazy member, Nonstrict (Lazy) Evaluation
Groovy TestClass with nonlazy member, Nonstrict (Lazy) Evaluation
laziness creating problems, Laziness Can Create Problems
lazy variable definition in Scala, Nonstrict (Lazy) Evaluation
nonstrict evaluation, Nonstrict (Lazy) Evaluation
strict evaluation, Strict Evaluation

exceptions

ensuring type safety with, Refactoring Using If-Else Structures
throwing for null return value, Output Depends on Input

extractors

extracting lists, Extracting Lists
extracting objects, Extracting Objects

F

filter function, Output Depends on Input, An Introduction to Recursion–An Introduction to Recursion

abstracting and putting into singleton class, Side Effects
basic, using recursion, An Introduction to Recursion
converting to tail-recursive call, Tail Recursion
getCustomerById method using, Output Depends on Input
getField function using, Output Depends on Input
in Groovy, using iterative loop, An Introduction to Recursion
purifying, Purifying Our Functions
simplified function using recursion, An Introduction to Recursion

final variables and @Lazy annotation (Groovy), Nonstrict (Lazy) Evaluation

final, marking closed-over variables as, Closures

find function return, converting to a list and pattern-matching against it, Extracting Lists

first-class functions, First-Class Functions, First-Class Functions–Conclusion

anonymous functions, Anonymous Functions

closures, Closures
lambda functions, Lambda Functions

functions as objects, Functions as Objects

refactoring using if-else structures, Refactoring Using If-Else Structures
using function objects to extract fields, Refactoring Using Function Objects to Extract Fields

higher-order functions, Higher-Order Functions

refactoring get functions using Groovy, Refactoring get Functions by Using Groovy

using in recursive summation, Recursion

XXY company (example), Introduction to XXY

Customer.java file, Introduction to XXY
DRY principle, Introduction to XXY

flatten() function, Strict Evaluation

for loops, Output Depends on Input

abstracting into a filter function, Output Depends on Input
as statements, Everything Is a Statement
basic for loop in Scala (example), Everything Is a Statement
for comprehension in Scala (example), Everything Is a Statement
for comprehension over another list in Scala, Everything Is a Statement
for comprehension versus map function, Everything Is a Statement
summation in, Recursion

foreach function, Purifying Our Functions

abstracting and putting into singleton class, Side Effects
defined in Customer class (example), Purifying Our Functions
side effects and, Side Effects

function chaining

counting enabled customers with disabled contacts (example), Recursion

functional programming

and concurrency, Functional Programming and Concurrency
concepts in, Overview of Concepts in Functional Programming
first-class functions, First-Class Functions
immutable variables, Immutable Variables
importance of, Why Functional Programming Is Important
nonstrict evaluations, Nonstrict Evaluation
pattern matching, Pattern Matching
pure functions, Pure Functions
recursion, Recursion
statements, Statements
taking the database concept further, Conclusion
transforming imperative code into functional code, From Imperative to Functional–What Next?
using with OOP, Why Functional Alongside OOP?, Functional OOP–Conclusion
versus imperative programming, Why Functional over Imperative?
writing a simple functional database in Scala (example), Putting It All Together–Conclusion

functional programming languages, What Next?

functions, Math Notation Review

as objects, Functions as Objects

using function objects to extract fields, Refactoring Using Function Objects to Extract Fields

components of, Functions as Objects

in Scala, Introducing Scala

passing a mutable object to, Mutability

passing a mutable variable to, Mutability

referencing, Code as Data

G

generic typing (Scala), Block Statements

get functions, refactoring using Groovy, Refactoring get Functions by Using Groovy

getCustomerById() method (example), Output Depends on Input

in Groovy, Making the Switch to Groovy
purifying, Purifying Our Functions
using a filter function, Output Depends on Input

getDisabledCustomerNames() function (example)

refactoring in Groovy, Making the Switch to Groovy
taking purity too far, Conclusion

getEnabledCustomerField() function (example), Refactoring Using If-Else Structures

passing ConversionFunction object to, Refactoring Using Function Objects to Extract Fields
using if-else structure, Refactoring Using If-Else Structures
with generic typed Function1, Refactoring Using Function Objects to Extract Fields

getEnabledCustomerNames() function (example), Functions as Objects

getters and setters, Everything Is a Statement

Groovy, Who Is This Book For?

@Lazy annotation and final variables, Nonstrict (Lazy) Evaluation

converting to, Making the Switch to Groovy

dynamic typing, Making the Switch to Groovy

Filter function in, An Introduction to Recursion

getCustomerById() function in, Making the Switch to Groovy

laziness problem in, Laziness Can Create Problems

lazy usage, good, example of, Laziness Can Create Problems

printing all contracts, Making the Switch to Groovy

refactoring other Customer.java code into, Making the Switch to Groovy

setContractEnabledForCustomer() method (example), Purifying Our Functions

setContractForCustomer method, Making the Switch to Groovy

syntax, Refactoring get Functions by Using Groovy

TestClass with lazy member (example)

and print statements, Nonstrict (Lazy) Evaluation
lazy member not evaluated until it’s referenced, Nonstrict (Lazy) Evaluation

TestClass with nonlazy member (example), Nonstrict (Lazy) Evaluation

and print statements, Nonstrict (Lazy) Evaluation

updating contract field, Making the Switch to Groovy

using higher-order functions in, Introduce Higher-Order Functions

using to refactor get functions, Refactoring get Functions by Using Groovy

volatile keyword, using with @Lazy annotation, Nonstrict (Lazy) Evaluation

guard, Converting to Pattern Matches

H

head (lists), An Introduction to Recursion

extracting in Scala, Extracting Lists

higher-order functions, Higher-Order Functions

defined, Refactoring get Functions by Using Groovy
introducing, Introduce Higher-Order Functions

I

if statements, Math Notation Review, Statements

in recursiive function end case, An Introduction to Recursion
in Scala, Introducing Scala, Everything Is a Statement
using with getEnabledCustomerField function, Refactoring Using If-Else Structures

if/else structures

converting to pattern matches

countEnabledCustomersWithNoEnabledContacts method, Converting to Pattern Matches

in getEnabledCustomerField function (example), Refactoring Using If-Else Structures

in Scala updateCustomerByIdList, converting to pattern matches, Simple Patterns

recreated in pattern-match style, Simple Matches

using in Scala imperative createCustomer method, Simple Matches

immutability, Mutability, Immutability

immutable Contract object, Immutability
immutable Customer object, Immutability
in recursive algorithm, An Introduction to Recursion
maintained with nonstrict evaluation, Strict and Nonstrict Evaluations
mutable allCustomers list containing immutable Customer objects, Immutability

immutable variables, Immutable Variables, Immutable Variables–Conclusion

benefits of using, Conclusion
converting mutable variables to, Convert Mutable Variables into Immutable Variables

imperative programming, Why Functional over Imperative?

transforming imperative code into functional code, From Imperative to Functional–What Next?

changing to functional programming language, What Next?
converting existing methods to pure functions, Convert Existing Methods into Pure Functions
converting loops to tail/recursive-tail methods, Convert Loops to Tail/Recursive-Tail Methods
converting mutable variables into immutable variables, Convert Mutable Variables into Immutable Variables
introducing higher-order functions, Introduce Higher-Order Functions

instance methods, Object to Singleton Method Purity

interfaces (Java)

abstraction for higher-order function, Purifying Our Functions
creating abstraction of function to pass to another function, Refactoring Using Function Objects to Extract Fields
encapsulating functions, Refactoring Using Function Objects to Extract Fields

isEmpty method (Scala), Introducing Scala

iteration

counting enabled customers with disabled contacts (example), Recursion
iterative algorithms versus recursive, Recursion

J

Java, Who Is This Book For?

imperative programming, Why Functional over Imperative?
introducing higher-order functions, Introduce Higher-Order Functions
lazy variable, example of, Strict and Nonstrict Evaluations
method chaining (example), Everything Is a Statement
Null Object pattern, The Option Pattern (Extension of Null Object Pattern)
setter as statement (example), Everything Is a Statement
simple assignment statement, Statements
singleton method purity, Object to Singleton Method Purity
Strategy design pattern, Code as Data

L

lambda functions, Anonymous Functions

using to reduce number of inner classes, Lambda Functions

lazy evaluations

example of good usage in Groovy, Laziness Can Create Problems
example of good usage in Scala, Laziness Can Create Problems
laziness creating problems in Groovy, Laziness Can Create Problems

lazy variables, Strict and Nonstrict Evaluations

definition in Scala, Nonstrict (Lazy) Evaluation

LISP, Introduction

lists

and for comprehensions in Scala, Everything Is a Statement
appending rather than prepending to output list, Tail Recursion
extracting from, Extracting Lists
Filter function end case with head creation, An Introduction to Recursion
Filter function outputting tail of list, An Introduction to Recursion
flattening, Strict Evaluation
head and tail of, An Introduction to Recursion
map function call on, in Scala, Everything Is a Statement

looping, Refactoring Using If-Else Structures

abstracting in updateCustomer and updateContract methods, Immutability

loops, converting to recursive methods, Convert Loops to Tail/Recursive-Tail Methods

M

macros, Functions as Objects

map function, Side Effects

abstracting and putting into singleton class, Side Effects
map call on a list in Scala, Everything Is a Statement
versus a for comprehension, when to use, Everything Is a Statement

match statement, Simple Matches

mathematical notation, Math Notation Review

message passing for concurrency, Message Passing for Concurrency

method chaining in Java, Everything Is a Statement

mutability, Mutability–Mutability

mutable variables, Mutability

converting to immutable, Convert Mutable Variables into Immutable Variables
passed to a function, modifying, Mutability

N

name (of a function), Functions as Objects

None class, Extracting Lists, The Option Pattern (Extension of Null Object Pattern)

nonstrict evaluation, Nonstrict Evaluation, Strict and Nonstrict Evaluations

Customer.enabledContacts method, Nonstrict (Lazy) Evaluation
Groovy TestClass with lazy member, Nonstrict (Lazy) Evaluation
laziness creating problems, Laziness Can Create Problems
lazy usage, good, in Scala, Laziness Can Create Problems
when and where to use, Conclusion

Null Object pattern, The Option Pattern (Extension of Null Object Pattern)

nullity, Output Depends on Input

avoiding null as dangerous construct, An Introduction to Recursion

NullPointerException, Output Depends on Input

nulls, returning empty list instead of, Purifying Our Functions

O

object to singleton method purity, Object to Singleton Method Purity

object-oriented programming (OOP)

functional, Functional OOP–Conclusion

code as data, Code as Data
objects as containers, Objects As Containers
static encapsulation, Static Encapsulation

functional style with, Why Functional Alongside OOP?

functions in, Object to Singleton Method Purity

objects

extracting, Extracting Objects
functions as, First-Class Functions, Functions as Objects
Scala, Simple Statements

Option interface, Extracting Lists, The Option Pattern (Extension of Null Object Pattern)

Option pattern, Extracting Objects, The Option Pattern (Extension of Null Object Pattern)

extracting logging of error and returning of None object, Extracting Objects

match structure for, Extracting Objects

handling specific value in a case object, Extracting Objects

Scala createCustomer method returning, Extracting Objects

using with CommandLine.options variable (example), Code as Data

ORMs (object-relational models), lazy fetch, Conclusion

P

parameter list, Functions as Objects

passing a function to a function, Refactoring Using Function Objects to Extract Fields

pattern matching, Pattern Matching, Pattern Matching–Conclusion

converting if/else structure in Scala updateCustomerByIdList method, Simple Patterns
converting to pattern matches, Converting to Pattern Matches
Email object extracting send function with common functionality, Objects As Containers
Email object with isDearReader using, Objects As Containers
extracting lists, Extracting Lists
extracting objects, Extracting Objects
Scala basic pattern match in createCustomer method, Simple Matches
simple matches, Simple Matches
simple patterns, Simple Patterns

patterns, defining, Simple Matches

placeholders, variables as, Immutability

pure functions, Pure Functions, Pure Functions–Making the Switch to Groovy

converting existing methods to, Convert Existing Methods into Pure Functions

making the switch to Groovy, Making the Switch to Groovy

output depends on input, Output Depends on Input

purifying our functions, Purifying Our Functions

filter function, Purifying Our Functions
foreach function, Purifying Our Functions
getCustomerById() method(example), Purifying Our Functions

side effects, Side Effects–Side Effects

R

Record class (example), Putting It All Together

recursion, Recursion, Recursion–Introducing Scala

concerns about, Recursion

converting loops to tail-recursive methods, Convert Loops to Tail/Recursive-Tail Methods

countEnabledCustomersWithNoEnabledContacts function in Scala, Introducing Scala

example of recursive function in mathematics, Recursion

function counting enabled customers with disabled contacts, Recursion

addition, returning, Recursion
defining base logic, Recursion
end case, Recursion

introduction to, An Introduction to Recursion

basic Filter function using recursion, An Introduction to Recursion
end case, An Introduction to Recursion
simplified filter function using recursion, An Introduction to Recursion

refactoring countEnabledCustomersWithNoEnabledContacts function, Refactoring Our countEnabledCustomersWithNoEnabledContacts Function

using trampolining, Refactoring Our countEnabledCustomersWithNoEnabledContacts Function

summation using a recursive function, Recursion

tail recursion, Tail Recursion

recursive algorithms versus iterative algorithms, Recursion

reduce operations, Recursion

reducing list of customrs into a count, Recursion

regular expressions, Pattern Matching

Runnable interface, Refactoring Using Function Objects to Extract Fields

S

Scala, Who Is This Book For?, Introducing Scala, Taking the Plunge, Introduce Higher-Order Functions

basic pattern match in createCustomer (example), Simple Matches

Command pattern using functions, Conclusion

CommandLine.askForInput method, Code as Data

CommandLine.options variable, Code as Data

print each enabled contact option, Code as Data

CommandLine.prompt method, Code as Data

CommandLineOption case class, Code as Data

Contact class.sendEmail method, Static Encapsulation

Contact.scala file, Simple Statements

Contact.sendEmail method, refactored, Static Encapsulation

Contract.scala file, Block Statements

countEnabledCustomersWithNoEnabledContacts method, Converting to Pattern Matches

Customer class defined as case class, Converting to Pattern Matches
pattern match on enabled customers, Converting to Pattern Matches
pattern match on enabled customers and blank Contact list, Converting to Pattern Matches

Customer.scala file, Everything Is a Statement

Email class, Static Encapsulation

Email class with isDearReader and name fields, Objects As Containers

Email object, Static Encapsulation

Email object extracting send function with common functionality, Objects As Containers

Email object using isDearReader and name fields, Objects As Containers

Email object with isDearReader using pattern match, Objects As Containers

end date statement (example), Block Statements

extraction pattern match in createCustomer (example), Simple Patterns

extraction pattern match, createCustomer returning Option pattern, Extracting Objects

for comprehension (example), Everything Is a Statement

for comprehension over another list (example), Everything Is a Statement