*Grokking Functional Programming* is a practical book. Written especially for object-oriented programmers, it will help you map familiar ideas like objects and inheritance to FP concepts such as programming with immutable data, higher order functions, composing functions, concurrent programming and even the dreaded monad. And you'll be pleased to know that we skip the academic baggage of lambda calculus, category theory, and the mathematical foundations of FP in favor of applying functional programming to everyday programming tasks. At the end of the book, you'll be ready to pick a functional language and start writing useful software.

# PART 1: RETHINKING PROGRAMMING

## 1. Learning Functional Programming

### Perhaps you picked up this book because…

### Don’t read this book if…

### What do you need to know before we start?

### What language are we going to use?

### What this book expects of you

### Where does functional programming fit?

### Not just programming in a new language

### Get our tools ready

### What tools can we use?

### A little functional fun

### Abbreviating names explained

### Coffee Break exercises explained

### More fun with Strings

### Fun with Strings explained

### Summary

## 2. Referential Transparency

### What is interesting about maths functions?

### Why do we have such high trust in maths?

### A review of the quick exercises

### A second reason to trust maths: no side effects

### What just happened to our classes?

### Going closer to purity

### Another Quick Exercise

### Review of Exercise #3

### Referential Transparency is why we trust maths

### Steps to achieving referential transparency

### One last exercise

### Review of Exercise #4

### From Java to Scala: does an FP language help us?

### Defining Immutable objects with Scala

### Experiencing Immutable objects with Scala

### Experiments with Immutable collections

### Using immutable collections in Scala

### Aggregation over immutable collections

### PAUSE: Where are we?

### Where to from here?

### Immutability

### Persistent Data Structures

### Higher Order Functions

### Multi-threading and Concurrency

### Summary

## 3. Programming with Immutable Collections

### Programming with immutability is strange

### Immutability at block scope

### How do we add a list of numbers in our head?

### Another way to think about looping

### Implementing loops without loops in code

### No loops: a recursive sum function in Scala

### We still value expression of purpose with functions

### A Scala way to hide our recursive implementation

### Counting recursively

### Using a local function for the recursive count

### Practicing Recursion

### Solutions to our recursion practice exercises

### Nasty recursive functions

### When can recursion cause a stack overflow?

### How to cause a stack overflow in a few lines

### Visualising the different recursion functions

### Time to catch our breath

### We still value DRY - Don’t Repeat Yourself

### What shall we name our DRY recursive function?

### Passing in code so that we still honor DRY

### Passing code into foldLeft with Scala

### Understanding Scala’s built-in foldLeft function

### Playing with Scala’s foldLeft function

### Playing with Scala’s foldLeft explained

### Summary

## 4. Immutable Collections

### Functions for programming immutable collections

### How to add elements to a mutable list

### How to add elements to an immutable list

### Heads and Tails: Another way to think about lists

### Some observations about immutable lists

### A Simple linked list

### Simple Linked List: Prepend or append?

### Simple Linked List: Concatenating two lists

### Coffee Break: Reverse a linked list

### Coffee Break Explained: Reverse a linked list

### Linked Lists: Summary

### Another interesting data structure: binary search tree

### Binary Search Tree: A Simple Scala Implementation

### Binary Search Tree: Structural Sharing

### Binary Search Tree: Inserting items

### Binary Search Tree: A Path for Depth First Traversal

### Coffee Break: Find the maximum value in a tree

### Coffee Break Explained: Maximum value in a tree

### Binary Search Tree: Summary

### Why do we care about persistent data structures?

### Transforming persistent data structures

### Transforming with filter

### Practicing with filter

### Transforming with map

### Practicing with map

### Combining filters and maps into pipelines

### Coffee Break: data transformations

### Coffee Break Explained: data transformations

### Summary

## 5. List Comprehensions

### List Comprehensions: An alternative to map and filter

### List Comprehensions with Scala: the for-expression

### Coffee Break: Simple list comprehensions

### Coffee Break Explained: Simple list comprehensions

### A Generalisation of a list comprehension

### Comprehension over lists of objects

### Coffee Break: Working with lists of objects

### Coffee Break Explained: Working with lists of objects

### Comprehension over lists that have lists

### Comprehensions on lists of lists are flatMaps

### Relating filter, map and flatMap to comprehensions

### Working with multiple lists

### Coffee Break: Working with multiple lists

### Coffee Break Explained: Working with multiple lists

### List Comprehensions or filter, map and flatMap?

### Summary

## 6. Immutable Data Structures

### Our journey of learning to program with immutability

### Boolean: A really simple immutable data structure

### Coffee Break: Extend the SwitchState data structure

### Coffee Break Explained: Extend the SwitchState

### Recursive data structures

### Implementing a tree as a sum type data structure

### Coffee Break: Find the size of a tree

### Coffee Break Explained: Finding the size of a tree

### Data structures that are combinations of elements

### Programming with immutable data structures

### Thinking in Data Structures is thinking in Types

### Coffee Break: More types for the Turtle

### Coffee Break Explained: More types for the Turtle

### Interesting applications of functional data structures

### Category Theory and Algebraic Data Types

### Summary

## 7. Software Transactional Memory

### Why should we bother with higher order functions?

### A look at concise code with higher order functions

### Concise code tends to be declaritive code

### What is a higher order function?

### A higher order function receives functions as inputs

### Coffee Break: functions that receive functions

### Coffee Break: functions that receive functions

### A higher order function can return a function as output

### Binding input data to returned functions

### Coffee Break: functions that return functions

### Coffee Break: functions that return functions

### Functions as Types

### Designing with Functions and Data as Types

### Wrap-up: Abstractions with Functions and Data Types

### Coffee Break: Designing with Functions and Data

### Coffee Break: Designing with Functions and Data

### Summary

## Binding data to functions

## Combinators

## Composition

## Data stream programming

## Concurrency with Actors

# PART 2: APPLYING FUNCTIONAL

## User Interface programming

## Web application programming

## Pure Simon Says

## Modularity

## About the Technology

Functional programming is more than just writing the same old code in Scala, Clojure, or Haskell. To grok FP—to really get it—you need to rewire your brain to see the world differently. We're here to help you flip the switch. *Grokking Functional Programming* teaches you first to break down problems in a new way so you can approach them from a FP mindset. Following carefully-selected examples with thorough, carefully-paced explanations, you'll immerse yourself in FP concept by concept. Along the way, exercises, checks for understanding, and even the occasional puzzler give you opportunities to think and practice what you're learning.

## What's inside

- Designing with functions instead of objects
- Multiple learning approaches to help you grok each new concept
- A practical programming-first teaching style
- Programming with immutable collections
- Writing concurrent programs with a functional style

**Manning Early Access Program (MEAP)**Read chapters as they are written, get the finished eBook as soon as itâ€™s ready, and receive the pBook long before it's in bookstores.

- MEAP combo $44.99 pBook + PDF
- MEAP eBook $35.99 PDF only

**FREE domestic shipping** on three or more pBooks