Mastering JavaScript Functional Programming by Kereki, Federico -- Read -- Imperial Library of Trantor

Index

Dedication Title Page Copyright

Mastering JavaScript Functional Programming

Credits About the Author About the Reviewer www.PacktPub.com

Why subscribe?

Customer Feedback Preface

What this book covers What you need for this book Who this book is for Conventions Reader feedback Customer support

Downloading the example code Errata Piracy Questions

Becoming Functional – Several Questions

What is Functional Programming?

Theory versus practice A different way of thinking What Functional Programming is not

Why use Functional Programming?

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

Questions Summary

Thinking Functionally - A First Example

The problem - do something only once Some bad solutions

Solution #1 - hope for the best! Solution #2 - use a global flag Solution #3 - remove the handler Solution #4 - change the handle Solution #5 - disable the button Solution #6 - redefine the handler Solution #7- use a local flag

A functional solution

A higher-order solution Testing the solution manually Testing the solution automatically An even better solution

Questions Summary

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

Questions Summary

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

Questions Summary

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()

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

Questions Summary

Producing Functions - Higher-Order Functions

Wrapping functions

Logging

Logging in a functional way Taking exceptions into account Working in a more pure way

Timing Memoizing

Simple memoization More complex memoization Memoization testing

Altering functions

Doing things once, revisited Logically negating a function Inverting results Arity changing

Other higher-order functions

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

Questions Summary

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

Questions Summary

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

Chaining and fluent interfaces Pointfree style

Defining pointfree functions Converting to pointfree style

Composing

Some examples of composition

Unary operators Counting files Finding unique words

Composing with higher order functions Testing composed functions

Questions Summary

Designing Functions - Recursion

Using recursion

Thinking recursively

Decrease and Conquer: searching Decrease and Conquer: doing powers Divide and conquer: The Tower 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

Questions Summary

Ensuring Purity - Immutability

The straightforward JS way

Mutator functions Constants Freezing Cloning and mutating Getters and setters

Getting a property Setting a property by path

Persistent data structures

Working with lists Updating objects A final caveat

Questions Summary

Implementing Design Patterns - The Functional Way

What are Design Patterns?

Design pattern categories Do we need design patterns?

Object-oriented design patterns

Façade and Adapter Decorator or Wrapper Strategy, Template, and Command Other patterns

Functional design patterns Questions Summary

Building Better Containers - Functional Data Types

Data types

Signatures for functions Other type options

Containers

Extending current data types Containers and functors

Wrapping a value: a basic container Enhancing our container: functors Dealing with missing values with Maybe

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

Questions Summary

Bibliography Answers to Questions

← Prev
Back
Next →

← Prev
Back
Next →