Need help with programming-scala-book-code-examples?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

deanwampler
537 Stars 365 Forks Other 713 Commits 4 Opened issues

Description

The code examples used in Programming Scala, 2nd and 3rd Editions (O'Reilly)

Services available

!
?

Need anything else?

Contributors list

Programming Scala, 3rd Edition

README for the Code Examples

| Key Dates | Description | | :---------------- | :---------- | | August 11, 2014 | 2nd edition examples | | May 27, 2019 | Updated for Scala 2.12 and 2.13 | | June 18, 2019 | New support for Maven builds, courtesy of oldbig | | October 12, 2019 | Updated for Scala 2.13.1, sbt 1.3.2, and other dependencies. Also now compiles with JDK 11 | | October 13, 2019 | Renamed the repo from

prog-scala-2nd-ed-code-examples
to
programming-scala-book-code-examples
| | December 31, 2019 | Renamed the
progscala2
package to
progscala3
and reworked most of the
*.sc
scripts for better testability and other improvements | | March 1, 2020 | Completed conversion to Scala 3 | | March 20, 2020 | Started incorporating new Scala 3 syntax, idioms | | November 11, 2020 | First Scala
3.0.0-M1
milestone changes | | November 25, 2020 | First Scala
3.0.0-M2
milestone changes | | December 19, 2020 | First Scala
3.0.0-M3
milestone changes | | February 21, 2021 | Scala
3.0.0-RC1
updates | | April 3, 2021 | Scala
3.0.0-RC2
updates | | April 24, 2021 | Scala
3.0.0-RC3
updates | | May 15, 2021 | Scala
3.0.0
final updates. Almost done! | | May 22, 2021 | Final updates for Programming Scala, Third Edition! | | July 24, 2021 | Scala 3.0.1. Notes on using IntelliJ. |

Join the chat at https://gitter.im/deanwampler/programming-scala-book-code-examples

This repo contains all the code examples in Programming Scala, Third Edition. (The second edition is available here.) There are also many code files in this distribution that aren't included in the book.

The

master
branch and the
3.X.Y
tag releases are for the third edition. The code examples for the second edition are still available. Download the release tagged 2.1.0 or check out the
release-2.1.0
branch. While the second edition was published for 2.11. The latest
2.1.0
release and
release-2.1.0
are updated for 2.12 and 2.13. (No more
release-2.X.Y
releases are planned.)

TIP: Several sections offer troubleshooting tips if you encounter problems.

How the Code Is Used in the Book

In the book's text, when an example corresponds to a file in this distribution, the listing begins with a path in a comment with the following format:

// src/main/scala/progscala3/.../FooBar.scala

Following the usual conventions, tests are in

src/test/...
.

Use these comments to find the corresponding source file. This archive also contains MUnit and ScalaCheck unit tests to validate some of the code.

Naming Conventions

The examples include "scripts" that are intended for interactive use in the

scala
command-line "REPL" (read, eval, print loop), for example using
sbt console
(where
sbt
is the de facto build tool for Scala that I use). Other files are compiled.

To keep these different kinds of files straight and to support building with

sbt
, the following conventions are used for the files:
  • src/main/scala/.../*.scala
    - All Scala 3 source files built with
    sbt
    .
  • src/test/.../*.scala
    - All Scala 3 test source files built and executed with
    sbt
    .
  • src/script/.../*.scala
    - "Script" files that won't compile with
    scalac
    , but can be interpreted with the
    scala
    REPL or used as a worksheet (see below).
  • src/*/scala-2/.../*.scala
    - Some Scala 2 source files that won't compile with Scala 3. They are not built with
    sbt
    .

Other Notes about the Code

You won't find many comments in the code, except of the form

// <1>
, which get converted into markers corresponding to notes in the book. All the descriptions of the code are in the book, so they aren't repeated as code comments.

Some files have sections marked like this:

// tag::section1[]
// end::section1[]

These are used to mark sections that are selectively included in the book. Sometimes the whole file is included in sections, while other times the file has extra bonus content that doesn't appear in the book.

Required and Optional Tools

To build and run the examples, all you need is a recent version of the the JDK and

sbt
. When you run

sbt
, it will bootstrap itself with the correct version of its jar file, Scala, and project dependencies, which are specified in the
build.sbt
file in the root directory and other build files in the
project
directory.

Follow these

sbt
installation instructions.

If you want to install Scala separately and Scala's Scaladocs, go to the scala-lang.org Getting Started guide for details. However, this isn't required.

If you want to play with the Spark example,

src/script/scala-2/progscala3/bigdata/SparkWordCount.scala
, you'll need to download a Spark distribution from https://spark.apache.org. Assuming that
$SPARK_HOME
refers to the root directory of your Spark installation, run the following command in the root directory of this project:
$ $SPARK_HOME/bin/spark-shell
...
scala>

Then copy and paste the content of

src/script/scala-2/progscala3/bigdata/SparkWordCount.scala
at the prompt. After it runs, there will be a new directory,
README.md.wordcount
with the partition files of the output.

Tip: For more on Spark, see my free tutorial on GitHub, spark-scala-tutorial.

Editors, IntelliJ, Visual Studio Code, and Other IDEs

NOTE: Support for Scala 3 may be limited for a while in the following tools.

Most editors and IDEs now have some sort of Scala support:

For other IDEs and text editors, try Scala Metals first (I've used it with Sublime Text, for example) or the older ENSIME project. You may also need additional, third-party tools for syntax highlighting, etc.

After installing the required plugins, load this project in your IDE, which should detect and use the

sbt
project automatically. For eclipse, run the
sbt eclipse
task to generate project files, then import them.

Troubleshooting with IntelliJ

One reader reported a problem when trying to run examples in IntelliJ:

scalac: Flag -encoding set repeatedly
. I could confirm this problem and I fixed it as follows:
  1. Open the preferences ("cmd-," on MacOS)
  2. Search for "scala"
  3. Select "Build, Execution, Deployment > Compiler > Scala Compiler"
  4. Select the "sbt" configuration in the list of Scala build configurations.
  5. Select "Additional compiler options:".
  6. Remove
    -encoding utf-8
    from the text, since it is already in the
    build.sbt
    file.

After that, you should be able to select a type with a

main
and run it.

The same reader also reported errors where multiple occurrences of the same name in a

@targetName
annotation collided. I believe this happens if you use
sbt
in a terminal to compile and then allow IntelliJ to do its own build. There are probably two copies of the class files on the resulting runtime classpath. For example, I saw this error when attempting to run
sbt console
in IntelliJ's
sbt shell
, but not when I used
sbt
in a terminal window.

So, what worked for me was to only use the terminal to run

sbt clean
, then let IntelliJ build the software itself, but when I need to use
sbt console
, I use a terminal window.

Using Scala Worksheets

If you like working with Scala worksheets in your IDE or editor, you may be able to load any of the REPL "script" files under

src/script
as a worksheet. If your environment is more restrictive, for example about the file extension used, then run the included
bash
script
./make-worksheets.sh
to copy all the REPL "script" examples to worksheet files. This command copies the tree
src/script
to
src/worksheet
and changes the
.scala
extension for all the files to
.worksheet.sc
, the VSCode convention. These behaviors are configurable. Use the
--help
option to see the details. If you are using Windows and you don't have
bash
available, e.g., through the Linux subsystem, then modify individual files as you see fit.

See this Dotty documentation page for more information about worksheets.

Building the Code Examples

After installing

sbt
, open a command/terminal window and run the
sbt test
command.

You'll see lots of output as it downloads all the dependencies, compiles the code and runs the tests. You should see

[success]
messages at the end.

sbt
is discussed in more detail in the book and the
sbt
website
, but a few useful commands are worth mentioning here.

If you start

sbt
without any arguments, it puts you into an interactive mode where you can type commands. Use control-D to exit this mode. Once at the
sbt
prompt (
sbt:programming-scala-3rd-ed-code-examples>
), try the following commands, where each
#
starts a comment; don't type those!
help       # help on tasks and settings
clean      # delete all build outputs
compile    # compile the source, but not test code
test       # compile source and test code, if necessary and run the tests.
~test      # continuously compile and test when source changes are saved.
console    # run the Scala REPL; dependencies and code are on the CLASSPATH
tasks      # show the most common tasks (commands).
tasks -V   # REALLY show ALL tasks

The

~
prefix causes the task to be run continuously each time source code changes are saved. This promotes continuous TDD (test-driven development) and is one of my favorite features!

Outside of

sbt
, you could, in principle, run the REPL and load the script files manually at the prompt:
$ scala
scala> :load src/script/scala/.../Foo.scala

However, it's easier to run most of the scripts using

sbt console
, because
sbt
will configure the
CLASSPATH
with the third-party libraries and compiled code examples that a script file might use.

Also, new for the Scala 3 REPL, for those

src/main/...
files that define one (and only one) entry point, meaning a
main
method (Scala 2 compatible) or annotated with
@main
(new Scala 3 technique), you can compile and run them in one step:
$ scala src/main/scala/progscala3/introscala/UpperMain2.scala Hello World!
HELLO WORLD!
$

Build Troubleshooting

Here are tips for issues users have reported.

Internationalization

I didn't check that the tests pass or the scripts work if your language environment isn't English. So, no surprise I guess, a German user reported that three tests failed when running

sbt test
while the
LANG
was set to
de_DE.UTF-8
:
[info] Passed: Total 7, Failed 0, Errors 0, Passed 7
[error] Failed: Total 233, Failed 7, Errors 0, Passed 226
[error] Failed tests:
[error]         progscala3.fp.combinators.PayrollSuite
[error]         progscala3.fp.curry.TupledFuncSuite
[error]         progscala3.dsls.payroll.PayrollSuite
[error] (Test / test) sbt.TestsFailedException: Tests unsuccessful
[error] Total time: 2 s, completed 31.07.2021, 16:56:39

Setting

export LANG="en_US.UTF-8"; sbt test
works. A PR for this is welcome ;) As an interim step, you could wrap this logic (or the more concise single command
LANG="en_US.UTF-8" sbt test
) in a script or just ignore the three failing tests.

Feedback

I welcome feedback on the Book and these examples. Please post comments, corrections, etc. to one of the following places:

There is also my dedicated site for the book where occasional updates, clarifications, corrections, and lame excuses will be posted: programming-scala.org.

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.