Charpentier M. Functional and Concurrent Programming

New York: Addison-Wesley Professional, 2022. — 630 p.ForewordWhy Scala?Target AudienceHow to Read This Book
Additional Resources
Acknowledgements
About the Author
Functional Programming
Concepts of Functional Programming
What Is Functional Programming?
Functions
From Functions to Functional Programming ConceptsFunctions in Programming Languages
Defining Functions
Composing Functions
Functions Defined as Methods
Operators Defined as Methods
Extension Methods
Local Functions
Repeated Arguments
Optional Arguments
Named Arguments
Type ParametersImmutability
Pure and Impure Functions
Actions
Expressions Versus Statements
Functional Variables
Immutable Objects
Implementation of Mutable State
Functional Lists
Hybrid Designs
Updating Collections of Mutable/Immutable ObjectsCase Study: Active–Passive Sets
Object-Oriented Design
Functional Values
Functional ObjectsPattern Matching and Algebraic Data Types
Functional Switch
Tuples
Options
Revisiting Functional Lists
Trees
Illustration: List Zipper
ExtractorsRecursive Programming
The Need for Recursion
Recursive Algorithms
Key Principles of Recursive Algorithms
Recursive Structures
Tail Recursion
Examples of Tail Recursive FunctionsRecursion on Lists
Recursive Algorithms as Equalities
Traversing Lists
Returning Lists
Building Lists from the Execution Stack
Recursion on Multiple/Nested Lists
Recursion on Sublists Other Than the Tail
Building Lists in Reverse Order
Illustration: Sorting
Building Lists EfficientlyCase Study: Binary Search Trees
Binary Search Trees
Sets of Integers as Binary Search Trees
Implementation Without Rebalancing
Self-Balancing TreesHigher-Order Functions
Functions as Values
Currying
Function Literals
Functions Versus Methods
Single-Abstract-Method Interfaces
Partial Application
Closures
Inversion of ControlStandard Higher-Order Functions
Functions with Predicate Arguments
map and foreach
flatMap
fold and reduce
iterate, tabulate, and unfold
sortWith, sortBy, maxBy, and minBy
groupBy and groupMap
Implementing Standard Higher-Order Functions
foreach, map, flatMap, and for-ComprehensionsCase Study: File Systems as Trees
Design Overview
A Node-Searching Helper Function
String Representation
Building Trees
Querying
Navigation
Tree ZipperLazy Evaluation
Delayed Evaluation of Arguments
By-Name Arguments
Control Abstraction
Internal Domain-Specific Languages
Streams as Lazily Evaluated Lists
Streams as Pipelines
Streams as Infinite Data Structures
Iterators
Lists, Streams, Iterators, and Views
Delayed Evaluation of Fields and Local Variables
Illustration: Subset-SumHandling Failures
Exceptions and Special Values
Using Option
Using Try
Using Either
Higher-Order Functions and PipelinesCase Study: Trampolines
Tail-Call Optimization
Trampolines for Tail-Calls
Tail-Call Optimization in Java
Dealing with Non-Tail-CallsA Brief Interlude
Types (and Related Concepts)
Typing Strategies
Types as Sets
Types as Services
Abstract Data Types
Type Inference
Subtypes
Polymorphism
Type Variance
Type Bounds
Type ClassesConcurrent Programming
Concepts of Concurrent Programming
Non-sequential Programs
Concurrent Programming ConceptsThreads and Nondeterminism
Threads of Execution
Creating Threads Using Lambda Expressions
Nondeterministic Behavior of Multithreaded Programs
Thread Termination
Testing and Debugging Multithreaded ProgramsAtomicity and Locking
Atomicity
Non-atomic Operations
Atomic Operations and Non-atomic Composition
Locking
Intrinsic Locks
Choosing Locking TargetsThread-Safe Objects
Immutable Objects
Encapsulating Synchronization Policies
Avoiding Reference Escape
Public and Private Locks
Leveraging Immutable Types
Thread-SafetyCase Study: Thread-Safe Queue
Queues as Pairs of Lists
Single Public Lock Implementation
Single Private Lock Implementation
Applying Lock SplittingThread Pools
Fire-and-Forget Asynchronous Execution
Illustration: Parallel Server
Different Types of Thread Pools
Parallel CollectionsSynchronization
Illustration of the Need for Synchronization
Synchronizers
Deadlocks
Debugging Deadlocks with Thread Dumps
The Java Memory ModelCommon Synchronizers
Locks
Latches and Barriers
Semaphores
Conditions
Blocking QueuesCase Study: Parallel Execution
Sequential Reference Implementation
One New Thread per Task
Bounded Number of Threads
Dedicated Thread Pool
Shared Thread Pool
Bounded Thread Pool
Parallel Collections
Asynchronous Task Submission Using Conditions
Two-Semaphore ImplementationFutures and Promises
Functional Tasks
Futures as Synchronizers
Timeouts, Failures, and Cancellation
Future Variants
Promises
Illustration: Thread-Safe CachingFunctional-Concurrent Programming
Correctness and Performance Issues with Blocking
Callbacks
Higher-Order Functions on Futures
Function flatMap on Futures
Illustration: Parallel Server Revisited
Functional-Concurrent Programming PatternsMinimizing Thread Blocking
Atomic Operations
Lock-Free Data Structures
Fork/Join Pools
Asynchronous Programming
Actors
Reactive Streams
Non-blocking SynchronizationCase Study: Parallel Strategies
Problem Definition
Sequential Implementation with Timeout
Parallel Implementation Using invokeAny
Parallel Implementation Using CompletionService
Asynchronous Implementation with Scala Futures
Asynchronous Implementation with CompletableFuture
Caching Results from StrategiesAppendix A Features of Java and Kotlin
Functions in Java and Kotlin
Immutability
Pattern Matching and Algebraic Data Types
Recursive Programming
Higher-Order Functions
Lazy Evaluation
Handling Failures
Types
Threads
Atomicity and Locking
Thread-Safe Objects
Thread Pools
Synchronization
Futures and Functional-Concurrent Programming
Minimizing Thread BlockingConverted PDF (from EPUB-like formats)