book

Functional Programming in Scala, Second Edition

Name: Functional Programming in Scala, Second Edition
ISBN: 9781617299582

by Runar Bjarnason, Michael Pilquist, Paul Chiusano

July 2023

Beginner to intermediate

488 pages

14h

English

Manning Publications

Audiobook available

Read now

Unlock full access

Praise for the First Edition
Functional Programming in Scala, Second Edition
Copyright
contents
front matter
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
Part 1. Introduction to functional programming
1 What is functional programming?
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 Getting started with functional programming in Scala
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 Functional data structures
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 Handling errors without exceptions
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 Strictness and laziness
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 Purely functional state
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
Part 2. Functional design and combinator libraries
7 Purely functional parallelism
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 Property-based testing
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 Parser combinators
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
Part 3. Common structures in functional design
10 Monoids
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 Monads
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 Applicative and traversable functors
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
Part 4. Effects and I/O
13 External effects and I/O
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 Local effects and mutable state
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 Stream processing and incremental I/O
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
index

Content preview from Functional Programming in Scala, Second Edition

2 Getting started with functional programming in Scala

This chapter covers

Introducing the Scala language
Explaining objects and namespaces
Working with higher-order functions (passing functions to functions)
Working with polymorphic functions (abstracting over types)
Following types to implementations

Now that we have committed to using only pure functions, a question naturally emerges: How do we write even the simplest of programs? Most of us are used to thinking of programs as sequences of instructions that are executed in order, where each instruction has some kind of effect. In this chapter, we’ll begin learning how to write programs in the Scala language by just combining pure functions.

This chapter is mainly intended for those readers ...

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: 9781617299582Publisher Support Publisher Website Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Functional Programming in Scala, Second Edition

by Runar Bjarnason, Michael Pilquist, Paul Chiusano

2 Getting started with functional programming in Scala

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.