Scala Cookbook: Recipes for Object-Oriented and Functional Programming

1022 Pages·2013·4.95 MB·English

by  Alvin Alexander

Scala Cookbook
Alvin Alexander
Beijing • Cambridge • Farnham • Köln • Sebastopol • Tokyo
For my mom, who loves cookbooks.
Special Upgrade Offer
If you purchased this ebook directly from oreilly.com, you have the following
benefits:
DRM-free ebooks—use your ebooks across devices without restrictions or
limitations
Multiple formats—use on your laptop, tablet, or phone
Lifetime access, with free updates
Dropbox syncing—your files, anywhere
If you purchased this ebook from another retailer, you can upgrade your ebook to
take advantage of all these benefits for just $4.99. Click here to access your
ebook upgrade.
Please note that upgrade offers are not available from sample content.
Preface
This is a cookbook of problem-solving recipes about Scala, the most interesting
programming language I’ve ever used. The book contains solutions to more than
250 common problems, shown with possibly more than 700 examples. (I haven’t
counted, but I suspect that’s true.)
There are a few unique things about this book:
As a cookbook, it’s intended to save you time by providing solutions to the
most common problems you’ll encounter.
Almost all of the examples are shown in the Scala interpreter. As a result,
whether you’re sitting by a computer, on a plane, or reading in your favorite
recliner, you get the benefit of seeing their exact output. (Which often leads
to, “Ah, so that’s how that works.”)
The book covers not only the Scala language, but also has large chapters on
Scala tools and libraries, including SBT, actors, the collections library (more
than 100 pages), and JSON processing.
Just prior to its release, the book was updated to cover Scala 2.10.x and SBT
0.12.3.
1. The Scala Language
My (oversimplified) Scala elevator pitch is that it’s a child of Ruby and Java: it’s
light, concise, and readable like Ruby, but it compiles to class files that you
package as JAR files that run on the JVM; it uses traits and mixins, and feels
dynamic, but it’s statically typed. It uses the Actor model to simplify concurrent
programming so you can keep those multicore processors humming. The name
Scala comes from the word scalable, and true to that name, it’s used to power
the busiest websites in the world, including Twitter, Netflix, Tumblr, LinkedIn,
Foursquare, and many more.
In my opinion, Scala is not a good language for teaching a Programming 101
class. Instead, it’s a power language created for the professional programmer.
Don’t let that scare you, though. If you were my own brother and about to start a
new project and could choose any programming language available, without
hesitation I’d say, “Use Scala.”
Here are a few more nuggets about Scala:
It’s a modern programming language created by Martin Odersky (the father
of javac), influenced by Java, Ruby, Smalltalk, ML, Haskell, Erlang, and
others.
It’s a pure object-oriented programming (OOP) language. Every variable is an
object, and every “operator” is a method.
It’s also a functional programming (FP) language, so you can pass functions
around as variables. You can write your code using OOP, FP, or both.
Scala code runs on the JVM and lets you use the wealth of Java libraries that
have been developed over the years.
You can be productive on Day 1, but the language is deep, so as you go along
you’ll keep learning and finding newer, better ways to write code. Scala will
change the way you think about programming—and that’s a good thing.
Of all of Scala’s benefits, what I like best is that it lets you write concise,
readable code. The time a programmer spends reading code compared to the
time spent writing code is said to be at least a 10:1 ratio, so writing code that’s
concise and readable is a big deal. Because Scala has these attributes,
programmers say that it’s expressive.
Solutions
I’ve always bought O’Reilly cookbooks for the solutions, and that’s what this
book is about: solving problems.
When using a cookbook, I usually think, “I have this problem, I need to iterate
over the elements in an Array, what’s the best way to do that?” I like to look at
the table of contents, find a recipe, implement the solution, and move on. I tried
to write each recipe with this use case in mind.
However, with a modern language like Scala, it may end up that I phrased my
question wrong. Because of my prior programming experience I may have
thought, “I need to iterate over the elements in an Array,” but in reality my
deeper intent was to loop over those elements for a reason, such as to transform
them into a new collection. So it’s nice when a recipe says, “Hey, I know you’re
here to read about how to loop over the elements in an Array, here’s how you do
that”:
for (i <- Array(1,2,3)) println(i)
“But, if what you’re really trying to do is transform those elements into a new
collection, what you want is a for/yield expression or map method”:
// for/yield
scala> for (i <- Array(1,2,3)) yield i * 2
res0: Array[Int] = Array(2, 4, 6)
// map
scala> Array(1,2,3).map(_ * 2)
res1: Array[Int] = Array(2, 4, 6)
(More on that _ character shortly.)
To create the list of problems and solutions, I followed the “Eat your own dog
food” philosophy. The recipes come from my own experience of creating Scala
scripts, web applications, web services, Swing applications, and actor-based
systems. As I developed the applications I needed, I encountered problems like
these:
Scala files tend to be very small; what’s the proper way to organize an
application?
It looks like SBT is the best build tool for Scala, but it’s different than Ant or
Maven; how do I compile and package applications, and work with
dependencies?
Constructors are really different than Java; how do I create them? What code
is generated when I declare constructor parameters and class fields?
Actors are cool; how do I write a complete actor-based application?
What, I shouldn’t use null values anymore? Why not? How do I code
without them?
I can pass a function around like any other variable? How do I do that, and
what’s the benefit?
Why are there so many collections classes, and why does each collection
class have so many methods?
I have all of this legacy Java code; can I still use it in Scala? If so, how?
I’m starting to grok this. Now I need to know, what are the top five or ten
“best practices” of writing Scala code?
Truthfully, I fell fast in love with everything about Scala except for one thing:
the collections library seemed large and intimidating. I really enjoyed using
Scala so I kept using the language, but whenever I needed a collection, I used a
trusty old Java collection.
Then one day I got up the courage to dive into the collections library. I thought
I’d hate it, but after struggling with it for a while, I suddenly “got” it. The light
bulb went on over my head, and I suddenly understood not only the collections,
but several other concepts I had been struggling with as well. I realized the
collections library writers aren’t crazy; they’re brilliant.
Once I understood the collections library, I quit writing so many for loops, and
started using collection methods like filter, foreach, and map. They made
coding easier, and made my code more concise. These days I can’t imagine a
better way to write code like this:
// filter the items in a list
scala> val nums = List(1,2,3,4,5).filter(_ < 4)
nums: List[Int] = List(1, 2, 3)
The _ wildcard character is discussed in several recipes, but as you can infer
from that example, it’s a placeholder for each element in the collection. The
filter method loops through each element in the list, calling your _ < 4
function on each iteration. That Scala one-liner is the equivalent of this Java
code:
Integer[] intArray = {1,2,3,4,5};
List<Integer> nums = Arrays.asList(intArray);
List<Integer> filteredNums = new LinkedList<Integer>();
for (int n: nums) {
if (n < 4) filteredNums.add(n);
}
The next example takes this a step further. It filters the elements as in the
previous example, and then multiplies each element by the number 2 using the
map method:
// filter the items, then double them
scala> val nums = List(1,2,3,4,5).filter(_ < 4).map(_ * 2)
nums: List[Int] = List(2, 4, 6)
If you think about how much code would be required to write this expression in
another language, I think you’ll agree that Scala is expressive.
(If you’re new to Scala, examples like this are broken down into smaller chunks
in the recipes.)
Audience
This book is intended for programmers who want to be able to quickly find
solutions to problems they’ll encounter when using Scala and its libraries and
tools. I hope it will also be a good tool for developers who want to learn Scala.
I’m a big believer in “learning by example,” and this book is chock full of
examples.
I generally assume that you have some experience with another programming
language like C, C++, Java, Ruby, C#, PHP, Python, or similar. My own
experience is with those languages, so I’m sure my writing is influenced by that
background.
Another way to describe the audience for this book involves looking at different
levels of software developers. In the article at scala-lang.org, Martin Odersky
defines the following levels of computer programmers:
Level A1: Beginning application programmer
Level A2: Intermediate application programmer
Level A3: Expert application programmer
Level L1: Junior library designer
Level L2: Senior library designer
Level L3: Expert library designer
This book is primarily aimed at the application developers in the A1, A2, A3,
and L1 categories. While helping those developers is my primary goal, I hope
that L2 and L3 developers can also benefit from the many examples in this book
—especially if they have no prior experience with functional programming, or
they want to quickly get up to speed with Scala and its tools and libraries.
Contents of This Book
The first three chapters in this book cover some of the nuts and bolts of the Scala
language.
Chapter 1, Strings, provides recipes for working with strings. Scala gets its basic
String functionality from Java, but with the power of implicit conversions,
Scala adds new functionality to strings through classes like StringLike and
StringOps, which let Scala treat a String as a sequence of Char. The last recipe
in the chapter shows how to add your own behavior to a String (or any other
class) by creating an implicit conversion.
Chapter 2, Numbers, provides recipes for working with Scala’s numeric types.
There are no ++ and −− operators for working with numbers, and this chapter
explains why, and demonstrates the other methods you can use. It also shows
how to handle large numbers, currency, and how to compare floating-point
numbers.
Chapter 3, Control Structures, demonstrates Scala’s built-in control structures,
starting with if/then statements and for loops, and then provides solutions for
working with for/yield loops (for comprehensions) and for expressions with
embedded if statements (guards). Because match expressions are so important
to Scala, several recipes show how to use them to solve a variety of problems.
The next five chapters continue to cover the Scala syntax, with an emphasis on
organizing your projects with classes, methods, objects, traits, and packaging.
Recipes on classes, methods, objects, and traits place an emphasis on object-
oriented programming techniques.
Chapter 4, Classes and Properties, provides examples related to Scala classes
and fields. Because Scala constructors are very different than Java constructors,
several recipes show the ins and outs of writing both primary and auxiliary
constructors. The chapter also shows how to override the accessor and mutator
methods that Scala automatically generates for your val and var variables.
Several recipes show what case classes are and how to use them, and how to
write equals methods.
Chapter 5, Methods, shows how to define methods to accept parameters, return