Get Programming with Scala

inside front cover

Comparison of the object-oriented and functional programming styles and how they handle different programming tasks

Get Programming with Scala

Daniela Sfregola

To comment go to liveBook

Manning

Shelter Island

For more information on this and other Manning titles go to

www.manning.com

Copyright

For online information and ordering of these  and other Manning books, please visit www.manning.com. The publisher offers discounts on these books when ordered in quantity.

For more information, please contact

Special Sales Department

Manning Publications Co.

20 Baldwin Road

PO Box 761

Shelter Island, NY 11964

Email: [email protected]

©2021 by Manning Publications Co. All rights reserved.

No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form or by means electronic, mechanical, photocopying, or otherwise, without prior written permission of the publisher.

Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in the book, and Manning Publications was aware of a trademark claim, the designations have been printed in initial caps or all caps.

♾ Recognizing the importance of preserving what has been written, it is Manning’s policy to have the books we publish printed on acid-free paper, and we exert our best efforts to that end. Recognizing also our responsibility to conserve the resources of our planet, Manning books are printed on paper that is at least 15 percent recycled and processed without the use of elemental chlorine.

ISBN: 9781617295270

dedication

To Marco, the best lockdown buddy I could ever ask for.

Contents

Preface

Acknowledgments

About this book

About the author

Unit 0. Hello Scala!

Lesson   1. Why Scala?

Why Scala?

Scala and the JVM

Scala’s key features

Summary

Lesson   2. The Scala environment

The REPL installation

The REPL commands

The REPL code evaluation

Other development tools

Summary

Lesson   3. Scala Build Tool (sbt)

Why sbt?

sbt installation

sbt commands

Your first sbt project

sbt project structure

Summary

Unit 1. The Basics

Lesson   4. Values and variables

Values

Variables

Summary

Answers to quick checks

Lesson   5. Conditional constructs and loops

If-else construct

While loop

For loop

Summary

Answers to quick checks

Lesson   6. Function as the most fundamental block of code

Functions

Summary

Answers to quick checks

Lesson   7. Classes and subclasses to represent the world

Class

Subclass

Abstract class

Summary

Answers to quick checks

Lesson   8. The vending machine

Setting up the vending machine

Possible improvements to our solution

Summary

Unit 2. Object-oriented fundamentals

Lesson   9. Import and create packages

Import an existing package

Create a package

Summary

Answers to quick checks

Lesson 10. Scope your code with access modifiers

Public, the default access modifier

Private

Protected

Which access level to use?

Summary

Answers to quick checks

Lesson 11. Singleton objects

Object

Executable object

Companion object

The apply method

Summary

Answers to quick checks

Lesson 12. Traits as interfaces

Defining traits

Extending traits

Sealed traits

Enumeration in Scala 3

Summary

Answers to quick checks

Lesson 13. What time is it?

What time is it?

Possible improvements to our solution

Summary

Unit 3. HTTP server

Lesson 14. Pattern matching

If-else construct vs. pattern matching

Sealed pattern matching

Summary

Answers to quick checks

Lesson 15. Anonymous functions

Function vs. anonymous function

Concise notation for anonymous functions

Summary

Answers to quick checks

Lesson 16. Partial functions

Partial functions

Use case: Exception handling

Summary

Answers to quick checks

Lesson 17. HTTP API with http4s

An overview of http4s

A ping server using http4s

Summary

Answers to quick checks

Lesson 18. The time HTTP server

What time is it?

Possible improvements to our solution

Summary

Unit 4. Immutable data and structures

Lesson 19. Case classes to structure your data

Case class

Pattern matching and case classes

Case object

Summary

Answers to quick checks

Lesson 20. Higher order functions

Functions as parameters

Functions as return values

Summary

Answers to quick checks

Lesson 21. What is purity?

A definition of purity

Differentiating between pure and impure functions

Summary

Answers to quick checks

Lesson 22. Option

Why Option?

Creating an Option

Pattern matching on Option

Summary

Answers to quick checks

Lesson 23. Working with Option: map and flatMap

Transforming an Option

Summary

Answers to quick checks

Lesson 24. Working with Option: For-comprehension

For-comprehension on Option

Other operations on Option

Summary

Answers to quick checks

Lesson 25. Tuple and unapply

Tuples

Implementing the unapply method

Summary

Answers to quick checks

Lesson 26. Rock, Paper, Scissors, Lizard, Spock!

Implementing Rock, Paper, Scissors, Lizard, Spock!

Possible improvements to our solution

Summary

Unit 5. List

Lesson 27. List

Creating a list

Adding elements to a list

Pattern matching on a list

Summary

Answers to quick checks

Lesson 28. Working with List: map and flatMap

The map, flatten, and flatMap operations

For-comprehension

Summary

Answers to quick checks

Lesson 29. Working with List: Properties

Size of a list

Properties of the elements in a list

Summary

Answers to quick checks

Lesson 30. Working with List: Element selection

Selecting an element by its position

Finding an element with given features

Picking the minimum or maximum item

Summary

Answers to quick checks

Lesson 31. Working with List: Filtering

Dropping and taking elements

Filtering Items of a list

Removing duplicates

Summary

Answers to quick checks

Lesson 32. Working with List: Sorting and other operations

Sorting elements

Converting a list to a string

Sum elements of numerical sequences

Grouping elements by feature

Summary

Answers to quick checks

Lesson 33. The movies dataset

Download the base project

Parsing a movie entity

Printing query results

Querying the movie data set

Summary

Unit 6. Other collections and error handling

Lesson 34. Set

Creating a set

Adding and removing elements

The map, flatten, and flatMap operations

For-comprehension

Summary

Answers to quick checks

Lesson 35. Working with Set

The Union, Intersection, and Difference operations

Other operations on Set

Summary

Answers to quick checks

Lesson 36. Map

Creating Map

Adding and removing elements

Merge and remove multiple entries

The map and flatMap operations

For-comprehension

Summary

Answers to quick checks

Lesson 37. Working with Map

Retrieving a value for a given key

Getting all keys and values

Other operations on Map

Summary

Answers to quick checks

Lesson 38. Either

Why Either?

Creating an Either

Pattern matching on Either

The map and flatMap operations

For-comprehension

Summary

Answers to quick checks

Lesson 39. Working with Either

Retrieving an Either value

Properties of an Either value

Summary

Answers to quick checks

Lesson 40. Error handling with Try

Creating a Try

Pattern matching on Try

The map, flatten, and flatMap operations

For-comprehension

Other operations on Try

Summary

Answers to quick checks

Lesson 41. The library application

Download the base project

Parsing a book entity

The business logic layer

Let’s give it a try!

Possible improvements to our solution

Summary

Unit 7. Concurrency

Lesson 42. Implicit and type classes

Implicit parameters and values

Implicit resolution

Type classes

Summary

Answers to quick checks

Lesson 43. Future

Why Future?

Creating an instance of Future

Processing Future on completion

Summary

Answers to quick checks

Lesson 44. Working with Future: map and flatMap

The map, flatten, and flatMap operations

Summary

Answers to quick checks

Lesson 45. Working with Future: For-comprehension and other operations

For-comprehension

Retrieving the first Future to complete

Summary

Answers to quick checks

Lesson 46. Database queries with Quill

Project setup

Connecting to the PostgreSQL server

Executing queries

Running generated queries

Summary

Answers to quick checks

Lesson 47. The quiz application: Part

Download the base project

Health check queries

Category queries

Question and answer queries

Let’s give it a try!

Summary

Unit 8. JSON (de)serialization

Lesson 48. JSON (de)serialization with circe

Project setup

JSON serialization: From instance to JSON

JSON deserialization: From JSON to instance

Summary

Answers to quick checks

Lesson 49. Lazy evaluation

By-name parameters

Lazy values

Summary

Answers to quick checks

Lesson 50. The IO type

Why IO?

Project setup

Synchronous side effect

Asynchronous side effect

Summary

Answers to quick checks

Lesson 51. Working with the IO type

The map and flatMap operations

For-comprehension

Parallel execution

Summary

Answers to quick checks

Lesson 52. Testing with ScalaTest

Project setup

Your first test

Asynchronous testing

Summary

Answers to quick checks

Lesson 53. The quiz application: Part

Download the base project

Generic endpoints

Displaying the available categories

Creating a quiz

Answering a quiz

The HTTP server

Writing tests

Let’s give it a try!

Summary

Index

front matter

Preface

When I first heard of Scala almost 10 years ago, I was immediately intrigued: a language that combines object-oriented programming (OOP) with functional programming (FP) sounded very interesting! And of course, at the time, I had no idea of what FP really meant or why I should care about it. When I decided to give this new language a try, I was lucky enough to work with great mentors who guided me in the learning process.

As I was learning new features of the language, I decided to start writing down my discoveries to further cement my understanding of them. After one or two months, I started writing my blog. My original motivation was to force myself to keep studying and improving my skills, but I soon realized that other people were finding my blog posts useful. In particular, readers of my blog enjoyed my writings because they were tackling practical problems that were explained with simple terms and that avoided unnecessary complexity.

Around the same time, I also started engaging with the Scala community by attending conferences and local meetups. By talking to fellow developers, I have recognized a similar pattern: folks were really intrigued by the language but surprised by a steep learning curve that was daunting for many newcomers due to the amount of complex and technical concepts that were assumed as common knowledge. Within six months, somebody nudged me into giving a presentation about a Scala library called Akka. When delivering the presentation, I decided that the best course of action was to offer my insights in a beginner-friendly fashion—helping several developers learn Scala one-on-one and sharing my knowledge of the Scala language and ecosystem in talks and workshops for beginners.

This book distills what I have learned about Scala and FP over the years and applies the lessons learned while teaching it to newcomers, trying to present the topic in a simple and accessible way so that you can learn the basics in a quick and pragmatic manner.

Learning new technologies can be overwhelming and intimidating, but it doesn’t have to be. I hope this book will make you fall in love with Scala, a powerful yet approachable language that can be fun and increase your productivity at the same time.

Acknowledgments

This book has been the most exciting and ambitious challenge of my career so far, and it would have not been possible without the constant help and support of many people.

I’d like to show my gratitude to the reviewers and the MEAP readers: your invaluable feedback has made this book much better.

Thanks to the Manning team, for their guidance and mentoring, particularly to Rebecca Rinehart, Michael Stephens, and Bert Bates for their precious advice during development of this book. Special thanks also go to my development editor, Katherine Olstein, for helping me continue focusing on its progress and get to the finishing line. I’d also like to thank my technical development editor, Arthur Zubarev, for his enthusiastic encouragement and my technical proofreader, Jean-François Morin, for his invaluable and detailed feedback.

To all the reviewers: Andrew Jennings, Anto Aravinth, Bonnie Malec, Chad Davis, Damian Esteban, Dan Sheikh, David Clements, Dr. Davide Cadamuro, Edward G. Prentice, Emanuele Origgi, Evyatar Kafkafi, George Onofrei, George Thomas, Igor Karp, Jeff Smith, Jens Christian, B. Madsen, Jon Guenther, Kai Gellien, Kelvin Johnson, Kevin Orr, Michelle Williamson, Mike Jensen, Rambabu Posa, Ronald Tischliar, Sam Zaydel, Sanket Naik, Scott Dierbeck, William Wheeler, and Yvan Phelizot, your suggestions helped make this a better book.

I’d like to show my gratitude to my mentors and colleagues, particularly to Bruno Filippone for introducing me to Scala, and ScalaItaly for inviting me to speak at a conference for the first time. Thanks to the Scala Community for your engagement and appreciation of this project and the Scala Center, particularly to Darja Jovanovic for her enthusiasm and support. Thanks to Professor Martin Odersky for creating such a beautiful language and for his invaluable feedback.

Last but surely not least, thanks to my life partner, Marco, for his unconditional support during every stage of this book and for encouraging me during the countless nights and weekends spent writing this book.

About this book

Object-oriented programming (OOP) has been the mainstream programming paradigm for the past couple of decades. More recently, the growing need for handling concurrency and multi-core processing has encouraged developers to explore functional programming (FP) thanks to its concepts of immutability and purity, which allow you to safely share data and design applications that are composable and easy to test. We are currently in a transition period where developers are familiar with the OOP paradigm but would like to learn more about FP.

Scala is a beautiful and powerful language that combines the OOP and FP coding styles to offer the best of both worlds and hence appeal to a broad set of developers.

Get Programming with Scala gives you an overview of its core features and guides you through several exercises to consolidate your understanding. It also teaches you how to develop more and more complex real-life Scala applications. It aims to make you productive in Scala as quickly and easily as possible, making it an ideal book when diving in for the first time.

Who should read this book

This book is for anyone with some programming experience using any OOP language, who is looking for a practical introduction to the Scala language and FP. You do not need any experience developing on the Java Virtual Machine (although it will certainly not hurt you) or any prior FP knowledge; you’ll learn about these subjects in this book.

How this book is organized: A roadmap

The structure of Get Programming with Scala is different from most of the programming books you may have read before. The book is divided into units, each containing bite-sized, easy-to-understand lessons. Each lesson has several quick check questions to help you verify your understanding (all of the answers are at the end of each lesson) and a final Try This exercise to help you consolidate the topic (solutions can be found on the book’s GitHub repository). At the end of each unit, its capstone project shows you how to apply what you have learned so far in a real-life application. The units cover the following content:

Unit 0 discusses why Scala is a great language to learn and the tools you need to install on your machine to start coding. You’ll learn about the Scala REPL, which helps you discover the language by evaluating Scala expressions, and sbt, the Scala Build Tool you’ll use for your Scala applications.

Unit 1 introduces you to the fundamental code components of the language. In particular, you’ll learn to define values and variables, conditional statements, functions, and classes.

Unit 2 shows you how to code in Scala using classic OOP concepts you have used in other languages. You’ll see how to create and import packages, use access modifiers that limit your code’s visibility, and define interfaces and singletons.

Unit 3 starts your FP journey by teaching you about pattern matching, one of the most powerful and versatile tools of the Scala language. You’ll learn about anonymous and particular functions and how the library http4s uses them to define an HTTP server.

Unit 4 discusses immutability by introducing you to case classes. It then introduces you to higher order functions and the concept of purity. Option is presented as a tool to indicate that a value may be missing and to avoid those annoying and unpredictable NullPointerExceptions.

Unit 5 introduces you to List collection as an ordered group of elements of the same kind. It shows you how to perform on it, such as picking, filtering, and sorting its items.

Unit 6 discusses some of the other collections in the Scala library. You’ll learn about Set as an unordered group of unique elements and Map for key-value structures. You’ll also see how to use Either for validation and Try for error handling.

Unit 7 shows you how to code using concurrent asynchronous computations. You’ll see how to use Future to represent an asynchronous operation that runs in the background and use the library Quill to connect and query to a Postgres database.

Finally, Unit 8 teaches you how to use the library circe for JSON serialization and ScalaTest to write tests. It also introduces you to the concept of laziness and IO from the cats-effect library as a tool to control side effects.

Each unit builds on top of the concepts introduced by the previous one, so you should consider reading each of them in succession. Depending on your OOP experience, you may want to skim the first lessons of the book. I strongly recommend not to skip the Quick Check and Try This exercises, even if they may seem easy, because they are designed to consolidate your understanding and highlight unexpected behavior that newcomers to the language tend to struggle with.

About the code

Throughout the book, you will see lots of code examples and quizzes to help you master the topics of each unit. The source code is formatted in a fixed-width font like this to separate it from ordinary text. Sometimes code is also in bold to highlight code that has changed from previous steps in the chapter, such as when a new feature adds to an existing line of code.

In many cases, the original source code has been reformatted; we’ve added line breaks and reworked indentation to accommodate the available page space in the book. In rare cases, even this was not enough, and listings include line-continuation markers (➥). Additionally, comments in the source code have often been removed from the listings when the code is described in the text. Code annotations accompany many of the listings, highlighting important concepts.

Source code, exercises, and solutions are available for download from the Manning website at https://www.manning.com/books/get-programming-with-scala and from GitHub at https://github.com/DanielaSfregola/get-programming-with-scala.

liveBook discussion forum

Purchase of Get Progamming with Scala includes free access to a private web forum run by Manning Publications where you can make comments about the book, ask technical questions, and receive help from the author and from other users. To access the forum, go to https://livebook.manning.com/book/get-programming-with-scala/welcome/v-10/. You can also learn more about Manning's forums and the rules of conduct at https://livebook.manning.com/#!/discussion.

Manning’s commitment to our readers is to provide a venue where a meaningful dialogue between individual readers and between readers and the author can take place. It is not a commitment to any specific amount of participation on the part of the author, whose contribution to the forum remains voluntary (and unpaid). We suggest you try asking the author some challenging questions lest her interest stray! The forum and the archives of previous discussions will be accessible from the publisher’s website as long as the book is in print.

About the author

Unit 0. Hello Scala!

Welcome to Get Programming with Scala! In Unit 0, you’ll have an overview of Scala and everything you need to know to set up your development environment and start coding. In particular, you’ll see the following subjects:

Lesson 1 illustrates the key Scala features and why it is such a great programming language to learn. You’ll discover the typical execution flow of a Scala program, and you’ll get a glance at some Scala code.

Lesson 2 shows you how to install and run the Scala REPL, a crucial tool to play and experiment with. You’ll write code snippets and see how the compiler interprets them.

Lesson 3 introduces you to sbt—the Scala Build Tool. You’ll install it and write your first Scala program by organizing your folders and source files according to the sbt standard.

After setting your environment up, you’ll continue with unit 1, where you’ll review the basics of object-oriented programming in Scala.

1 Why Scala?

After reading this lesson, you’ll be able to

Discuss the advantages of adopting Scala

Describe the execution flow of a typical Scala program

Define the key features of the Scala language

In this lesson, you’ll discover why Scala is an excellent language to learn and why its adoption is increasing so rapidly. You’ll see how Scala relates to the JVM and the key features that make it unique. You’ll also start looking at snippets of Scala code to get an idea of its appearance. After giving you an overview of the Scala language, you’ll continue with the next lesson, in which you’ll install the Scala REPL and use it to interpret snippets of code.

1.1 Why Scala?

Why should you spend time and effort in learning Scala? Why is it becoming so popular? What are the advantages of adopting it? Let’s discuss its main selling points.

The JVM The

JVM is the standard platform for running Scala programs. Sun Microsystems introduced it in 1994—more than 25 years ago. Since then, the industry has been extensively relying on it. The Java community has also been extremely active, and it has produced an impressive amount of libraries. Thanks to its integration with Java, you can use all these libraries in your Scala programs; this is also true for any Java legacy code you or your company may have.

A Hybrid Language Scala

manages to combine two programming techniques that are considerably different: the object-oriented style with the functional one. When executing code on the JVM, the object-oriented approach can be more performant but prone to errors. When using mutable state, your program will re-allocate its memory: every time a change occurs, it will change the data in place. However, sharing state can cause your application to suffer from data inconsistency issues due to multiple processes accessing and modifying the same portion of data.

A functional approach can be more readable and reusable but not as performant. Thanks to immutable data and structures, you can guarantee your program’s correctness when dealing with concurrency: your data never changes, so it is safe to share it. Your code will also be easier to understand and reuse because all its components will be independent of external factors outside its control. But recreating data rather than updating could be a memory-expensive operation, even though it has massively improved thanks to numerous optimizations and efficient garbage collection strategies in recent years.

In Scala, you do not have to stick to a particular style, but you can take advantage of one or the other paradigm depending on the specific task you are solving. Look at figure 1.1 for a comparison of how the two approaches tackle different programming tasks.

Figure 1.1 Comparison of the object-oriented and functional programming styles and how they handle different programming tasks

Concise Syntax Scala’s

programming style is relatively concise, particularly when compared to other languages like Java. Having a compact syntax can increase both the productivity and readability of your program. At the beginning of your journey with Scala, you may find it quite overwhelming. In this book, syntax diagrams will help you master new topics and make your learning path smoother.

Flexibility Scala is extremely flexible: you can achieve the same goal in more than one way, making the language extremely fun and exciting to use. The opportunity to choose between different programming paradigms allows you to gradually shift your mindset from one approach to another without committing to a specific style since day one. For example, you can dip your toe in the functional programming world without any long-term commitment. In this book, you’ll start writing Scala code using an object-oriented style and then gradually move to a more functional one.

Concurrency Thanks to its use of immutable data structures and expressive type system, dealing with concurrency is less prone to errors than in other languages. As a result, Scala programs tend to utilize resources more efficiently, and they usually perform better under pressure.

Big Data and Spark Thanks

to Scala’s features and optimizations at its compile level, the community has developed new performant tools for big data processing. Apache Spark is the most popular of these tools. Thanks to Scala’s lazy evaluation, which is a topic you are going to discover in unit 8, Spark can perform optimizations at compile time that have huge impacts on its runtime performance:

"Run programs up to 100× faster than Hadoop MapReduce in memory, or 10× faster on disk.”.

Source: https://spark.apache.org

1.2 Scala and the JVM

Scala takes its name from the word scalable. Martin Odersky and his team designed it in 2004 with the intent of creating a language for the Java Virtual Machine (JVM) that can easily handle high volumes of requests.

To understand the execution of a Scala program, let’s compare it with the typical execution flow of a Java program; figure 1.2 provides a visual representation of the two processes. The JVM is a machine to perform tasks by executing a well-defined set of operations, called bytecode. A JVM language aims to translate its code into executable JVM bytecode, usually formed by multiple files with extension *.class. When coding in Java, you save your source files with extension *.java and use the compiler javac to produce a jar file containing the generated bytecode. When writing Scala code, your source files have extension *.scala. The Scala compiler called scalac is in charge of translating the code into bytecode. You can seamlessly add Java sources and depend on Java libraries in your Scala codebase. The Scala compiler fully integrates with the bytecode that the Java compiler produces, making the integration between the two languages straightforward.

Figure 1.2 Comparison between the execution of a Java program with a Scala one. The Java source code has extension *.java, and javac translates it into bytecode files with extension *.class. You save Scala code in files with extension *.scala, and scalac is the compiler responsible for converting them into bytecode. The JVM is now ready to run the bytecode, usually conveniently grouped in a *.jar file.

Scala as a multiplatform language

Odersky and his team designed Scala for the JVM. A few open source projects (some more experimental than others) are trying to develop new compilers so that you can use the language in other platforms too.

scala-js is a well-established open source project that allows you to compile Scala code to JavaScript. It is a framework to build applications that run in your browser. It enables you to share code between the front and the backend of your application. Visit https://www.scala-js.org for more information.

scala-native (see http://www.scala-native.org) is another project targeting Scala for the Low-Level Virtual Machine (LLVM) compiler. Its development is in progress but looks promising; running Scala programs on the LLVM would optimize their speed and memory.

Finally, if you are looking for an alternative (more fun?) way of writing CSS code, look at scalacss (see https://github.com/japgolly/scalacss) for a super type-safe CSS in Scala.

1.3 Scala’s key features

Since 2004, Scala has evolved a lot, but its fundamental features have not changed. In this section, you’ll glance at a few fragments of Scala code, and you’ll learn about each of these topics in this book.

Scala is Object-Oriented An object-oriented programming language has a structure based on classes and subclasses. They have well-defined behaviors, and they exchange information through methods.

Listing 1.1 MyClass example

// our first Scala example              ❶ class MyClass(name: String) {            ❷   def sayHello(otherName: String) =     sHi $otherName, my name is $name!  ❸ }

❶ This is a comment.

❷ This is a class with a parameter name and a method sayHello.

❸ Example of string interpolation: s... is the operator for string interpolation; it replaces $otherName and $name with their value.

In unit 1, you’ll learn how to define classes and subclasses. In unit 4, you’ll also discover case classes to present data in an immutable manner.

Singleton instances are instances that you should initialize at most once. Scala offers a dedicated syntax for them: you usually refer to them as objects. Do not be confused by the term object, as it can refer to an instance rather than a singleton in other languages. In unit 2, you’ll learn about singleton objects in Scala and how not to be confused by the terminology.

Listing 1.2 MySingleton example

object MyObject {                  ❶   val a = new MyClass(Scala)    ❷   println(a.sayHello(Martin)) }

❶ This is a singleton.

❷ This is an instance of the class MyClass.

Exceptions are another typical feature of an object-oriented language. They represent code anomalies: you can throw and catch them to control your program’s execution flow. In Scala, exceptions are similar to those in languages such as Java, Python, and C++.

Listing 1.3 Example of throwing and catching exceptions

try {   throw new IllegalStateException(ERROR!)    ❶ } catch {   case ex: RuntimeException =>                ❷     println(Something went bad...) }

❶ Example of throwing a java.lang.IllegalStateException

❷ Example of catching and handling any RuntimeException. Note that an IllegalStateException is a subclass of RuntimeException.

You’ll learn about try-catch expressions in detail in unit 3, in which you are also going to discover partial functions. In unit 6, you’ll master how to handle errors without throwing exceptions using a more functional and safe approach that uses types.

Mutable data structures and assignments are also part of the language. The language’s design discourages their use, but you can still take advantage of them when needed. In lesson 4, you’ll learn about the difference between a value and a variable. In units 5 and 6, you’ll also discover what the Scala Collections have to offer.

Listing 1.4 Example of mutable assignments

var a = hello println(a)          ❶ a = Scala println(a)          ❷

❶ Prints hello

❷ Prints Scala

Scala is Functional FP languages base their entire structure on functions. Functions play a big part in Scala as its first-class citizens. In lesson 6, you’ll learn their basics and how to define them. In unit 4, you’ll discover functional purity and its several advantages and how you can use functions as parameters or return values: you refer to them as higher order functions. They allow you to create powerful abstractions that simplify and remove code duplication in a way that is usually not so easily achievable in an object-oriented approach.

Listing 1.5 Example of Higher Order Function

def divideByTwo(n: Int): Int = n / 2            ❶ def addOne(f: Int => Int): Int => Int =          ❷   f andThen(_ + 1) def divideByTwoAndAddOne = addOne(divideByTwo)  ❸

❶ A function that takes an Int and returns an Int

❷ A function that takes a function from Int to Int as a parameter and that returns a new function from Int to Int

❸ A function defined by compositing two existing functions

Scala has a Robust Type System Scala is a statically typed language. Types define the acceptable range of values for your computation. Thanks to them, the compiler can check at compile time that your code doesn’t violate any constraints, which makes your code more reliable and less prone to errors at runtime. Scala has a type inference system, so you do not have to specify the intended type for every expression of your program, making your code less verbose. Languages that do not have a type inference system require you to provide types explicitly and tend to be more verbose. Scala’s type system is also quite flexible: you can reuse existing or create custom types to ensure business requirements at the type level. Starting from unit 4, you’ll discover the most common types the language has to offer. In unit 7, you’ll see how to use type classes and define custom types to enforce requirements at compile time.

Scala’s Integration with Java Scala is a JVM language that you can easily integrate Java code into your Scala programs. Most IDEs that provide Scala support, such as IntelliJ IDEA, can even rewrite Java code into Scala code automatically.

Listing 1.6 Java to Scala code example

// file Snippet.java String dateAsString = 22.11.2017; SimpleDateFormat format = new SimpleDateFormat( dd.MM.yyyy ); Date date = format.parse(dateAsString); // file Snippet.scala import java.text.SimpleDateFormat import java.util.Date val dateAsString = 22.11.2017 val format = new SimpleDateFormat(dd.MM.yyyy) val date: Date = format.parse(dateAsString)

Alternatively, you can also add files with extension *.java directly into your Scala project; Scalac will recognize them as Java and compile them accordingly.

Summary

In this lesson, my objective was to give you an overview of the Scala language.

You learned about its unique features and why it is a great language to learn.

You discovered the typical execution flow of a Scala program and looked at Scala code snippets.

2 The Scala environment

After reading this lesson, you’ll be able to

Execute commands on the Scala REPL

Use the REPL to evaluate expressions

Install the git and docker development tools

The Scala REPL (Read-Eval-Print-Loop) is a development tool to interpret Scala code snippets. It will be a crucial tool in learning Scala, and it doesn’t require too much setup or infrastructure: you’ll be able to play and experiment with the language by typing and evaluating fragments of code. You’ll also install the git and docker development tools on your machine, which are not specific to Scala but used in some of the more advanced capstones. In the next lesson, you’ll complete your machine’s setup by installing sbt—a tool to build and run structured Scala programs.

2.1 The REPL installation

In this section, you’ll learn how to install the Scala REPL on Linux, macOS, and Windows using a package manager. Alternatively, you can also download Scala binaries from its official website (visit https://scala-lang.org/download and its Download the Scala binaries section for instructions on how to do this).

First, you need to check that you have installed Java 8+ JDK. Open the terminal and type the command java -version to check your java version. You should see a message similar to the following:

$ java –version openjdk version 15.0.1 2020-10-20 OpenJDK Runtime Environment (build 15.0.1+9-18) OpenJDK 64-Bit Server VM (build 15.0.1+9-18, mixed mode, sharing)

If you need to install or upgrade your JDK, you can find instructions on how to do so on the OpenJDK’s website (https://openjdk.java.net/install).

You are now ready to download and install the Scala REPL; depending on your operating system, you will have different instructions to follow.

LINUX On Ubuntu and other Debian-based distribution, type the following command in the terminal:

$ sudo apt-get install scala

If you are using an RPM-based distribution, such as Red Hat Enterprise, type the following instruction:

$ sudo yum install scala

Use emerge package manager if you are on Gentoo:

$ emerge dev-lang/scala

macOS On macOS, you can install Scala using Homebrew by executing the following command in your terminal:

$ brew install scala

If you prefer, you can also use MacPorts as follows:

$ port install scala

Windows Visit https://scala-lang.org/download to download the MSI installer for Scala and open the file to complete the installation.

Once you have completed the installation, you should be able to execute the command scala and receive a message similar to the following:

$ scala Welcome to Scala 2.13.6 (OpenJDK 64-Bit Server VM, Java 15.0.1). Type in expressions for evaluation. Or try :help. scala>

The symbol scala> indicates that the Scala REPL is running and ready to receive your commands.

2.2 The REPL commands

A REPL tool can receive instructions and interpret snippets of code. Let’s see what the Scala REPL’s main commands.

The Scala REPL identifies commands by the prefix :; it considers any other instruction as Scala code snippets to compile and evaluate. Lots of commands are available, but you usually remember just a few of them. Here’s a list of the most useful commands:

:quit gracefully exits the interpreter:

scala> :quit

:help lists all the commands available with a brief description. Use it to discover new commands or to check the syntax of an existing one:

scala> :help All commands can be abbreviated, e.g., :he instead of :help. :help [command]          print this summary or command-specific help :completions     output completions for the given string //