Mastering JavaScript Functional Programming

✍ Scribed by Federico Kereki

• Publisher: PACKT Publishing
• Year: 2020
• Tongue: English
• Leaves: 457
• Edition: 2
• Category: Library

✦ Table of Contents

Cover
Title Page
Copyright and Credits
Dedication
About Packt
Contributors
Table of Contents
Preface
Technical Requirements
Chapter 1: Becoming Functional - Several Questions
What is functional programming?
Theory versus practice
A different way of thinking
What FP is not
Why use FP?
What we need
What we get
Not all is gold
Is JavaScript functional?
JavaScript as a tool
Going functional with JavaScript
Key features of JavaScript
Functions as first-class objects
Recursion
Closures
Arrow functions
Spread
How do we work with JavaScript?
Using transpilers
Working online
Testing
Summary
Questions
Chapter 2: Thinking Functionally - A First Example
Our problem – doing something only once
Solution 1 – hoping for the best!
Solution 2 – using a global flag
Solution 3 – removing the handler
Solution 4 – changing the handler
Solution 5 – disabling the button
Solution 6 – redefining the handler
Solution 7 – using a local flag
A functional solution to our problem
A higher-order solution
Testing the solution manually
Testing the solution automatically
Producing an even better solution
Summary
Questions
Chapter 3: Starting Out with Functions - A Core Concept
All about functions
Of lambdas and functions
Arrow functions – the modern way
Returning values
Handling the this value
Working with arguments
One argument or many?
Functions as objects
A React-Redux reducer
An unnecessary mistake
Working with methods
Using functions in FP ways
Injection – sorting it out
Callbacks, promises, and continuations
Continuation passing style
Polyfills
Detecting Ajax
Adding missing functions
Stubbing
Immediate invocation
Summary
Questions 
Chapter 4: Behaving Properly - Pure Functions
Pure functions
Referential transparency
Side effects
Usual side effects
Global state
Inner state
Argument mutation
Troublesome functions
Advantages of pure functions
Order of execution
Memoization
Self-documentation
Testing
Impure functions
Avoiding impure functions
Avoiding the usage of state
Injecting impure functions
Is your function pure?
Testing – pure versus impure
Testing pure functions
Testing purified functions
Testing impure functions
Summary
Questions
Chapter 5: Programming Declaratively - A Better Style
Transformations
Reducing an array to a value
Summing an array
Calculating an average
Calculating several values at once
Folding left and right
Applying an operation – map
Extracting data from objects
Parsing numbers tacitly
Working with ranges
Emulating map() with reduce()
Dealing with arrays of arrays
Flattening an array
Mapping and flattening – flatMap()
Emulating flat() and flatMap()
More general looping
Logical higher-order functions
Filtering an array
A reduce() example
Emulating filter() with reduce()
Searching an array
A special search case
Emulating find() and findIndex() with reduce()
Higher-level predicates – some, every
Checking negatives – none
Working with async functions
Some strange behaviors
Async-ready looping
Looping over async calls
Mapping async calls
Filtering with async calls
Reducing async calls
Summary
Questions
Chapter 6: Producing Functions - Higher-Order Functions
Wrapping functions – keeping behavior
Logging
Logging in a functional way
Taking exceptions into account
Working in a purer way
Timing functions
Memoizing functions
Simple memoization
More complex memoization
Memoization testing
Altering a function's behavior
Doing things once, revisited
Logically negating a function
Inverting the results
Arity changing
Changing functions in other ways
Turning operations into functions
Implementing operations
A handier implementation
Turning functions into promises
Getting a property from an object
Demethodizing – turning methods into functions
Finding the optimum
Summary
Questions
Chapter 7: Transforming Functions - Currying and Partial Application
A bit of theory
Currying
Dealing with many parameters
Currying by hand
Currying with bind()
Currying with eval()
Partial application
Partial application with arrow functions
Partial application with eval()
Partial application with closures
Partial currying
Partial currying with bind()
Partial currying with closures
Final thoughts
Parameter order
Being functional
Summary
Questions
Chapter 8: Connecting Functions - Pipelining and Composition
Pipelining
Piping in Unix/Linux
Revisiting an example
Creating pipelines
Building pipelines by hand
Using other constructs
Debugging pipelines
Using tee
Tapping into a flow
Using a logging wrapper
Pointfree style
Defining pointfree functions
Converting to pointfree style
Chaining and fluent interfaces
An example of fluent APIs
Chaining method calls
Composing
Some examples of composition
Unary operators
Counting files
Finding unique words
Composing with higher-order functions
Testing composed functions
Transducing
Composing reducers
Generalizing for all reducers
Summary
Questions
Chapter 9: Designing Functions - Recursion
Using recursion
Thinking recursively
Decrease and conquer – searching
Decrease and conquer – doing powers
Divide and conquer – the Towers of Hanoi
Divide and conquer – sorting
Dynamic programming – making change
Higher-order functions revisited
Mapping and filtering
Other higher-order functions
Searching and backtracking
The eight queens puzzle
Traversing a tree structure
Recursion techniques
Tail call optimization
Continuation passing style
Trampolines and thunks
Recursion elimination
Summary
Questions
Chapter 10: Ensuring Purity - Immutability
Going the straightforward JavaScript way
Mutator functions
Constants
Freezing
Cloning and mutating
Getters and setters
Getting a property
Setting a property by path
Lenses
Working with lenses
Implementing lenses with objects
Implementing lenses with functions
Prisms
Working with prisms
Implementing prisms
Creating persistent data structures
Working with lists
Updating objects
A final caveat
Summary
Questions
Chapter 11: Implementing Design Patterns - The Functional Way
Understanding design patterns
Design pattern categories
Do we need design patterns?
Object-oriented design patterns
Facade and adapter
Decorator or wrapper
Strategy, Template, and Command
Observer and reactive programming
Basic concepts and terms
Operators for observables
Detecting multi-clicks
Providing typeahead searches
Other patterns
Functional design patterns
Summary
Questions
Chapter 12: Building Better Containers - Functional Data Types
Specifying data types
Signatures for functions 
Other data type options
Building containers 
Extending current data types
Containers and functors
Wrapping a value – a basic container
Enhancing our container – functors
Dealing with missing values with Maybe
Dealing with varying API results
Implementing Prisms
Monads
Adding operations
Handling alternatives – the Either monad
Calling a function – the Try monad
Unexpected monads – promises
Functions as data structures
Binary trees in Haskell
Functions as binary trees
Summary
Questions
Bibliography
Answers to Questions
Other Books You May Enjoy
Index