book

Functional Programming in Scala, Second Edition

by Paul Chiusano, Runar Bjarnason, Michael Pilquist

July 2023

Beginner to intermediate

488 pages

14h

English

Manning Publications

Read now

Unlock full access

foreword to the first editionforeword to the second editionpreface to the second editionacknowledgmentsabout this bookHow this book is structuredAudienceHow to read this bookCode conventions and downloadsSetting expectationsliveBook discussion forumabout the authors
1.1 Understanding the benefits of functional programming1.1.1 A program with side effects1.1.2 A functional solution: Removing the side effects1.2 Exactly what is a (pure) function?1.3 Referential transparency, purity, and the substitution model1.4 ConclusionSummary
2.1 Introducing Scala the language2.1.1 Running our program2.2 Objects and namespaces2.3 Higher-order functions: Passing functions to functions2.3.1 A short detour: Writing loops functionally2.3.2 Writing our first higher-order function2.4 Polymorphic functions: Abstracting over types2.4.1 An example of a polymorphic function2.4.2 Calling higher-order functions with anonymous functions2.5 Following types to implementations2.6 ConclusionSummary2.7 Exercise answers
3.1 Defining functional data structures3.2 Pattern matching3.3 Data sharing in functional data structures3.3.1 The efficiency of data sharing3.3.2 Recursion over lists and generalizing to higher-order functions3.3.3 More functions for working with lists3.3.4 Loss of efficiency when assembling list functions from simpler components3.4 Trees3.5 ConclusionSummary3.6 Exercise answers
4.1 The good and bad aspects of exceptions4.2 Possible alternatives to exceptions4.3 The Option data type4.3.1 Usage patterns for Option4.3.2 Option composition, lifting, and wrapping exception-oriented APIs4.4 The Either data type4.4.1 Accumulating errors4.4.2 Extracting a Validated type4.5 ConclusionSummary4.6 Exercise answers

5.1 Strict and nonstrict functions5.2 Lazy lists: An extended example5.2.1 Memoizing lazy lists and avoiding recomputation5.2.2 Helper functions for inspecting lazy lists5.3 Separating program description from evaluation5.4 Infinite lazy lists and corecursion5.5 ConclusionSummary5.6 Exercise answers
6.1 Generating random numbers using side effects6.2 Purely functional random number generation6.3 Making stateful APIs pure6.4 A better API for state actions6.4.1 Combining state actions6.4.2 Nesting state actions6.5 A general state action data type6.6 Purely functional imperative programming6.7 ConclusionSummary6.8 Exercise Answers
7.1 Choosing data types and functions7.1.1 A data type for parallel computations7.1.2 Combining parallel computations7.1.3 Explicit forking7.2 Picking a representation7.2.1 Refining the API7.3 The algebra of an API7.3.1 The law of mapping7.3.2 The law of forking7.3.3 Breaking the law: A subtle bug7.3.4 A fully non-blocking Par implementation using actors7.4 Refining combinators to their most general form7.5 ConclusionSummary7.9 Exercise answers
8.1 A brief tour of property-based testing8.1.1 Choosing data types and functions8.1.2 Initial snippets of an API8.1.3 The meaning and API of properties8.1.4 The meaning and API of generators8.1.5 Generators that depend on generated values8.1.6 Refining the Prop data type8.2 Test case minimization8.2.1 Using the library and improving its usability8.2.2 Some simple examples8.2.3 Writing a test suite for parallel computations8.3 Testing higher-order functions and future directions8.4 The laws of generators8.5 ConclusionSummary8.6 Exercise answers
9.1 Designing an algebra first9.2 A possible algebra9.2.1 Slicing and nonempty repetition9.3 Handling context sensitivity9.4 Writing a JSON parser9.4.1 The JSON format9.4.2 A JSON parser9.5 Error reporting9.5.1 A possible design9.5.2 Error nesting9.5.3 Controlling branching and backtracking9.6 Implementing the algebra9.6.1 One possible implementation9.6.2 Sequencing parsers9.6.3 Labeling parsers9.6.4 Failover and backtracking9.6.5 Context-sensitive parsing9.7 ConclusionSummary9.8 Exercise answers
10.1 What is a monoid?10.2 Folding lists with monoids10.3 Associativity and parallelism10.4 Example: Parallel parsing10.5 Typeclasses10.6 Foldable data structures10.7 Composing monoids10.7.1 Assembling more complex monoids10.7.2 Using composed monoids to fuse traversals10.8 ConclusionSummary10.9 Exercise answers
11.1 Functors: Generalizing the map function11.1.1 Functor laws11.2 Monads: Generalizing the flatMap and unit functions11.2.1 The Monad trait11.3 Monadic combinators11.4 Monad laws11.4.1 The associative law11.4.2 Proving the associative law for a specific monad11.4.3 The identity laws11.5 Just what is a monad?11.5.1 The identity monad11.5.2 The State monad and partial type application11.6 ConclusionSummary11.7 Exercise answers
12.1 Generalizing monads12.2 The Applicative trait12.3 The difference between monads and applicative functors12.3.1 The Option applicative versus the Option monad12.3.2 The Parser applicative versus the Parser monad12.4 The advantages of applicative functors12.4.1 Not all applicative functors are monads12.5 The applicative laws12.5.1 Left and right identity12.5.2 Associativity12.5.3 Naturality of product12.6 Traversable functors12.7 Uses of Traverse12.7.1 From monoids to applicative functors12.7.2 Traversals with State12.7.3 Combining traversable structures12.7.4 Traversal fusion12.7.5 Nested traversals12.7.6 Monad composition12.8 ConclusionSummary12.9 Exercise answers
13.1 Factoring effects13.2 A simple IO type13.2.1 Handling input effects13.2.2 Benefits and drawbacks of the simple IO type13.3 Avoiding the StackOverflowError13.3.1 Reifying control flow as data constructors13.3.2 Trampolining: A general solution to stack overflow13.4 A more nuanced I/O type13.4.1 Free monads13.4.2 A monad that supports only console I/O13.4.3 Pure interpreters13.5 Non-blocking and asynchronous I/O13.5.1 Composing free algebras13.6 Capabilities13.7 A general-purpose I/O type13.7.1 The main program at the end of the universe13.8 Why the IO type is insufficient for streaming I/O13.9 ConclusionSummary13.10 Exercise answers
14.1 Purely functional mutable state14.2 A data type to enforce the scoping of side effects14.2.1 A little language for scoped mutation14.2.2 An algebra of mutable references14.2.3 Running mutable state actions14.2.4 Mutable arrays14.2.5 A purely functional in-place quicksort14.3 Purity is contextual14.3.1 What counts as a side effect?14.4 ConclusionSummary14.5 Exercise answers
15.1 Problems with imperative I/O: An example15.2 Simple stream transformations15.2.1 Creating pulls15.2.2 Composing stream transformations15.2.3 Processing files15.3 Extensible pulls and streams15.3.1 Effectful streaming computations15.3.2 Handling errors15.3.3 Ensuring resource safety15.3.4 Dynamic resource allocation15.4 Applications15.5 ConclusionSummary15.6 Exercise answers

Overview

This international bestseller has been revised with new exercises, annotations, and full coverage of Scala 3.

In Functional Programming in Scala, Second Edition you will learn how to:

Recognize and write purely functional code
Work with errors without using exceptions
Work with state and concurrency
Interact with functional structures that define common behaviors
Write code that performs I/O without sacrificing functional programming

Functional Programming in Scala has helped over 30,000 developers discover the power of functional programming. You’ll soon see why reviewers have called it “mindblowing”! The book smooths the complexity curve of functional programming, making it simple to understand the basics and intuitive to progress to more advanced topics. Concrete examples and exercises show you FP in the real world and reveal how it can improve your everyday coding practices. This second edition comes packed with the latest standards of FP, as well as full code updates to Scala 3, and its new language features.

About the Technology
Functional code is easy to test, reuse, and parallelize, and it’s practically immune to whole categories of state-related bugs. With its strong functional features, familiar syntax, and seamless interoperability with Java, there’s no better place to start learning functional programming than the flexible Scala language.

About the Book
In Functional Programming in Scala, Second Edition you’ll learn functional programming from first principles. Hands-on exercises and examples make it easy to start thinking and coding functionally. This revised edition contains extensive exercise annotations to help you explore FP in depth, along with steps to build your own functional libraries in Scala. Once the functional lightbulb goes on, you’ll never look at coding the same way again.

What's Inside

Recognize and write purely functional code
Work with errors without using exceptions
Work with state and concurrency
Interact with functional structures that define common behaviors

About the Reader
For Java or Scala programmers. No knowledge of functional programming required.

About the Authors
Michael Pilquist is the lead maintainer of FS2, a functional streaming library, and contributes to the Typelevel ecosystem. Paul Chiusano and Rúnar Bjarnason are recognized experts in functional programming and authors of the first edition of Functional Programming with Scala.

Quotes
Functional programming in Scala, both the technique and the book, have entrenched themselves firmly in the landscape of the language and ecosystem….This new edition is an effective companion for the community inventing tomorrow.
- From the Foreword by Daniel Spiewak, Creator of Cats Effect

Deepen your understanding of practical functional programming in Scala with this, the ultimate guide.
- Bill Venners, Artima

The first edition of FPiS was one of the turning points in my journey through the FP rabbit hole. It was eye-opening to be able to prove that one typeclass interface is equivalent to another. The book’s second edition preserves the unique vision of FPiS: to guide readers via practical coding idioms towards a mathematically rigorous approach in FP.
- Sergei Winitzki, Workday