book

Functional and Concurrent Programming: Core Concepts and Features

Name: Functional and Concurrent Programming: Core Concepts and Features
Author: Michel Charpentier
ISBN: 9780137466696

by Michel Charpentier

December 2022

Intermediate to advanced

528 pages

15h 41m

English

Addison-Wesley Professional

Read now

Unlock full access

Cover Page
About This eBook
Halftitle Page
Title Page
Copyright Page
Dedication Page
Contents
List of Listings
List of Figures
Foreword by Cay Horstmann

Preface
Why Scala?Target AudienceHow to Read This Book
Acknowledgments
About the Author
Part I: Functional Programming
Chapter 1. Concepts of Functional Programming
1.1 What Is Functional Programming?1.2 Functions1.3 From Functions to Functional Programming Concepts1.4 Summary
Chapter 2. Functions in Programming Languages
2.1 Defining Functions2.2 Composing Functions2.3 Functions Defined as Methods2.4 Operators Defined as Methods2.5 Extension Methods2.6 Local Functions2.7 Repeated Arguments2.8 Optional Arguments2.9 Named Arguments2.10 Type Parameters2.11 Summary
Chapter 3. Immutability
3.1 Pure and Impure Functions3.2 Actions3.3 Expressions Versus Statements3.4 Functional Variables3.5 Immutable Objects3.6 Implementation of Mutable State3.7 Functional Lists3.8 Hybrid Designs3.9 Updating Collections of Mutable/Immutable Objects3.10 Summary
Chapter 4. Case Study: Active–Passive Sets
4.1 Object-Oriented Design4.2 Functional Values4.3 Functional Objects4.4 Summary
Chapter 5. Pattern Matching and Algebraic Data Types
5.1 Functional Switch5.2 Tuples5.3 Options5.4 Revisiting Functional Lists5.5 Trees5.6 Illustration: List Zipper5.7 Extractors5.8 Summary
Chapter 6. Recursive Programming
6.1 The Need for Recursion6.2 Recursive Algorithms6.3 Key Principles of Recursive Algorithms6.4 Recursive Structures6.5 Tail Recursion6.6 Examples of Tail Recursive Functions6.7 Summary
Chapter 7. Recursion on Lists
7.1 Recursive Algorithms as Equalities7.2 Traversing Lists7.3 Returning Lists7.4 Building Lists from the Execution Stack7.5 Recursion on Multiple/Nested Lists7.6 Recursion on Sublists Other Than the Tail7.7 Building Lists in Reverse Order7.8 Illustration: Sorting7.9 Building Lists Efficiently7.10 Summary
Chapter 8. Case Study: Binary Search Trees
8.1 Binary Search Trees8.2 Sets of Integers as Binary Search Trees8.3 Implementation Without Rebalancing8.4 Self-Balancing Trees8.5 Summary
Chapter 9. Higher-Order Functions
9.1 Functions as Values9.2 Currying9.3 Function Literals9.4 Functions Versus Methods9.5 Single-Abstract-Method Interfaces9.6 Partial Application9.7 Closures9.8 Inversion of Control9.9 Summary
Chapter 10. Standard Higher-Order Functions
10.1 Functions with Predicate Arguments10.2 map and foreach10.3 flatMap10.4 fold and reduce10.5 iterate, tabulate, and unfold10.6 sortWith, sortBy, maxBy, and minBy10.7 groupBy and groupMap10.8 Implementing Standard Higher-Order Functions10.9 foreach, map, flatMap, and for-Comprehensions10.10 Summary
Chapter 11. Case Study: File Systems as Trees
11.1 Design Overview11.2 A Node-Searching Helper Function11.3 String Representation11.4 Building Trees11.5 Querying11.6 Navigation11.7 Tree Zipper11.8 Summary
Chapter 12. Lazy Evaluation
12.1 Delayed Evaluation of Arguments12.2 By-Name Arguments12.3 Control Abstraction12.4 Internal Domain-Specific Languages12.5 Streams as Lazily Evaluated Lists12.6 Streams as Pipelines12.7 Streams as Infinite Data Structures12.8 Iterators12.9 Lists, Streams, Iterators, and Views12.10 Delayed Evaluation of Fields and Local Variables12.11 Illustration: Subset-Sum12.12 Summary
Chapter 13. Handling Failures
13.1 Exceptions and Special Values13.2 Using Option13.3 Using Try13.4 Using Either13.5 Higher-Order Functions and Pipelines13.6 Summary
Chapter 14. Case Study: Trampolines
14.1 Tail-Call Optimization14.2 Trampolines for Tail-Calls14.3 Tail-Call Optimization in Java14.4 Dealing with Non-Tail-Calls14.5 Summary
A Brief Interlude
Chapter 15. Types (and Related Concepts)
15.1 Typing Strategies15.2 Types as Sets15.3 Types as Services15.4 Abstract Data Types15.5 Type Inference15.6 Subtypes15.7 Polymorphism15.8 Type Variance15.9 Type Bounds15.10 Type Classes15.11 Summary
Part II: Concurrent Programming
Chapter 16. Concepts of Concurrent Programming
16.1 Non-sequential Programs16.2 Concurrent Programming Concepts16.3 Summary
Chapter 17. Threads and Nondeterminism
17.1 Threads of Execution17.2 Creating Threads Using Lambda Expressions17.3 Nondeterminism of Multithreaded Programs17.4 Thread Termination17.5 Testing and Debugging Multithreaded Programs17.6 Summary
Chapter 18. Atomicity and Locking
18.1 Atomicity18.2 Non-atomic Operations18.3 Atomic Operations and Non-atomic Composition18.4 Locking18.5 Intrinsic Locks18.6 Choosing Locking Targets18.7 Summary
Chapter 19. Thread-Safe Objects
19.1 Immutable Objects19.2 Encapsulating Synchronization Policies19.3 Avoiding Reference Escape19.4 Public and Private Locks19.5 Leveraging Immutable Types19.6 Thread-Safety19.7 Summary
Chapter 20. Case Study: Thread-Safe Queue
20.1 Queues as Pairs of Lists20.2 Single Public Lock Implementation20.3 Single Private Lock Implementation20.4 Applying Lock Splitting20.5 Summary
Chapter 21. Thread Pools
21.1 Fire-and-Forget Asynchronous Execution21.2 Illustration: Parallel Server21.3 Different Types of Thread Pools21.4 Parallel Collections21.5 Summary
Chapter 22. Synchronization
22.1 Illustration of the Need for Synchronization22.2 Synchronizers22.3 Deadlocks22.4 Debugging Deadlocks with Thread Dumps22.5 The Java Memory Model22.6 Summary
Chapter 23. Common Synchronizers
23.1 Locks23.2 Latches and Barriers23.3 Semaphores23.4 Conditions23.5 Blocking Queues23.6 Summary
Chapter 24. Case Study: Parallel Execution
24.1 Sequential Reference Implementation24.2 One New Thread per Task24.3 Bounded Number of Threads24.4 Dedicated Thread Pool24.5 Shared Thread Pool24.6 Bounded Thread Pool24.7 Parallel Collections24.8 Asynchronous Task Submission Using Conditions24.9 Two-Semaphore Implementation24.10 Summary
Chapter 25. Futures and Promises
25.1 Functional Tasks25.2 Futures as Synchronizers25.3 Timeouts, Failures, and Cancellation25.4 Future Variants25.5 Promises25.6 Illustration: Thread-Safe Caching25.7 Summary
Chapter 26. Functional-Concurrent Programming
26.1 Correctness and Performance Issues with Blocking26.2 Callbacks26.3 Higher-Order Functions on Futures26.4 Function flatMap on Futures26.5 Illustration: Parallel Server Revisited26.6 Functional-Concurrent Programming Patterns26.7 Summary
Chapter 27. Minimizing Thread Blocking
27.1 Atomic Operations27.2 Lock-Free Data Structures27.3 Fork/Join Pools27.4 Asynchronous Programming27.5 Actors27.6 Reactive Streams27.7 Non-blocking Synchronization27.8 Summary
Chapter 28. Case Study: Parallel Strategies
28.1 Problem Definition28.2 Sequential Implementation with Timeout28.3 Parallel Implementation Using invokeAny28.4 Parallel Implementation Using CompletionService28.5 Asynchronous Implementation with Scala Futures28.6 Asynchronous Implementation with CompletableFuture28.7 Caching Results from Strategies28.8 Summary
Appendix A. Features of Java and Kotlin
A.1 Functions in Java and KotlinA.2 ImmutabilityA.3 Pattern Matching and Algebraic Data TypesA.4 Recursive ProgrammingA.5 Higher-Order FunctionsA.6 Lazy EvaluationA.7 Handling FailuresA.8 TypesA.9 ThreadsA.10 Atomicity and LockingA.11 Thread-Safe ObjectsA.12 Thread PoolsA.13 SynchronizationA.14 Futures and Functional-Concurrent ProgrammingA.15 Minimizing Thread Blocking
Glossary
Index

Content preview from Functional and Concurrent Programming: Core Concepts and Features

Index

Symbols

::: (concat), 59, 85–86
:: (cons operator or method reference) cons operator, 31. See also functional lists
- method reference, 124, 134, 263
- (contravariance annotation), 238–239. See also contravariance
+ (covariance annotation), 237–239. See also covariance
>: (lower type bound), 176, 242. See also type bounds
| (pipe)
- pattern matching alternatives, 47. See also pattern matching
- type union, 54, 222, 226–227. See also types
& (type intersection), 222, 227, 243, 248. See also types
_ (underscore)
- for partial application, 125–126, 134, 248. See also partial application
- in pattern matching, 47–48, 50–52, 58–59. See also pattern matching
() (unit value), of type Unit, 23, 222
<: (upper type bound), 177, 241–243, 248. See also ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9780137466696

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Functional and Concurrent Programming: Core Concepts and Features

by Michel Charpentier