Functional Programming in Scala.pdf

This is not a book about Scala. This book introduces the concepts and techniques

of functional programming (FP)—we use Scala as the vehicle, but the lessons

herein can be applied to programming in any language. Our goal is to give you the

foundations to begin writing substantive functional programs and to comfortably

absorb new FP concepts and techniques beyond those covered here. Throughout

the book we rely heavily on programming exercises, carefully chosen and

sequenced to guide you to discover FP for yourself. Expository text is often just

the first chapter, we will explain exactly what this means. From this single idea and

its logical consequences emerges a very different way of building programs, one

with its own body of techniques and concepts. We start by relearning how to write

the simplest of programs in a functional way. From this foundation we will build

the tower of techniques necessary for expressing functional programs of greater

complexity. Some of these techniques may feel alien or unnatural at first and the

exercises and questions can be difficult, even brain-bending at times. This is

normal. Don't be deterred. Keep a beginner's mind, try to suspend judgment, and if

a lot of time and space discussing Scala's syntax and language features. Instead

we'll introduce them as we go, with a minimum of ceremony, mostly using short

examples, and mostly as a consequence of covering other material. These minimal

introductions to Scala should be enough to get you started with the exercises. If

you have further questions about the Scala language while working on the

exercises, you are expected to do some research and experimentation on your own

or follow some of our links to further reading.

The book is organized into four parts, intended to be read sequentially. Part 1

introduces functional programming, explains what it is, why you should care, and

walks through the basic low-level techniques of FP, including how to organize and

them in Part 3. Building on Part 3, Part 4 covers techniques and mechanisms for

writing functional programs that perform I/O (like reading/writing to a database,

files, or the screen) or writing to mutable variables.

Though the book can be read sequentially straight through, the material in Part

3 will make the most sense after you have a strong familiarity with the functional

style of programming developed over parts 1 and 2. After Part 2, it may therefore

be a good idea to take a break and try getting more practice writing functional

programs beyond the shorter exercises we work on throughout the chapters. Part 4

also builds heavily on the ideas and techniques of Part 3, so a second break after

Part 3 to get experience with these techniques in larger projects may be a good idea