Learning Scala Programming

Book Image

Learning Scala Programming

By : Vikash Sharma

Book Image

Learning Scala Programming

By: Vikash Sharma

Overview of this book

Scala is a general-purpose programming language that supports both functional and object-oriented programming paradigms. Due to its concise design and versatility, Scala's applications have been extended to a wide variety of fields such as data science and cluster computing. You will learn to write highly scalable, concurrent, and testable programs to meet everyday software requirements. We will begin by understanding the language basics, syntax, core data types, literals, variables, and more. From here you will be introduced to data structures with Scala and you will learn to work with higher-order functions. Scala's powerful collections framework will help you get the best out of immutable data structures and utilize them effectively. You will then be introduced to concepts such as pattern matching, case classes, and functional programming features. From here, you will learn to work with Scala's object-oriented features. Going forward, you will learn about asynchronous and reactive programming with Scala, where you will be introduced to the Akka framework. Finally, you will learn the interoperability of Scala and Java. After reading this book, you'll be well versed with this language and its features, and you will be able to write scalable, concurrent, and reactive programs in Scala.

Title Page

Packt Upsell

Contributors

Preface

Free Chapter

Getting Started with Scala Programming

Getting Started with Scala Programming

Introduction to Scala

Scala advantages

Working with Scala

Running our first program

Building Blocks of Scala

Building Blocks of Scala

What is underneath a Scala program?

Operators in Scala

Wrapper classes

String Interpolators

Shaping our Scala Program

Shaping our Scala Program

The for expressions

Conditional statements

Pattern matching

Giving Meaning to Programs with Functions

Giving Meaning to Programs with Functions

Function syntax

Calling a function

Function literals

Evaluation strategies

Partial functions

Getting Familiar with Scala Collections

Getting Familiar with Scala Collections

Immutable and mutable collections

Hierarchy of collections in Scala

Commonly used collections in Scala

Rich operations performed on collections

Parallel collections in Scala

Converting a Java collection into a Scala collection

Choosing a collection

Collection performance

Object-Oriented Scala Basics

Object-Oriented Scala Basics

Abstract classes

Objects as singletons

Companion objects

Next Steps in Object-Oriented Scala

Next Steps in Object-Oriented Scala

Composition and inheritance

Class inheritance

Default and parameterized constructors

Traits as mix-ins

Packaging and importing

Visibility rules

More on Functions

More on Functions

Function literals

Functions versus methods

What are closures?

Higher-order functions

Partially applied functions

Using Powerful Functional Constructs

Using Powerful Functional Constructs

For expressions

Pattern matching

Different ways we can pattern match

Lazy declaration

Tail call optimization

Type parameterization

Advanced Functional Programming

Advanced Functional Programming

Why so serious about types?

Here comes type parameterization

Another way around - generic classes and traits

Type parameter names

Container types

Variance under inheritance

Abstract versus parameterized types

Working with Implicits and Exceptions

Working with Implicits and Exceptions

Exception handling – the old way

Using the Option way

Either left or right

Implicits - what and why

Implicit parameters

The implicitly method

Implicit conversions

Looking for implicits

Type-classes ahead!

Introduction to Akka

Introduction to Akka

Why do we care about Akka?

What's up with the Actor Model?

Understanding the Actor system

Actor references and paths

Selecting existing actorRefs via actorSelection

How the Actor life cycle works

Hello world in Akka

Writing our first Actor

The tell versus ask versus forward method

Stopping Actors

The preStart and postStop hooks

Actor communication via messages and its semantics

Supervising fault in our actors

OneForOne versus AllForOne strategy

Default supervision strategy

Applying the supervision strategy

Concurrent Programming in Scala

Concurrent Programming in Scala

Concurrent programming

Building blocks of concurrency

Asynchronous programming

Parallel collections

Programming with Reactive Extensions

Programming with Reactive Extensions

Reactive programming

Reactive extensions

React to RxScala

Testing in Scala

Testing in Scala

The why and what of TDD

ScalaMock – a native library to mock objects

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Index

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Choosing a collection

Here's the problem: after learning so many ways to make a collection of elements in Scala, it appears that we've got a big dilemma. We have quite a few options to choose from. Almost every collection has higher order functions to operate with. These are high-performing, type parameterized, and immutable collections. So how do we decide which collection to use? Now, we've the answer for that. And the answer is, it depends. Yes, it depends on multiple factors; for example, in which format would you like to have the data. Is it a simple sequence or in pair format? It's obvious that we've been talking about sequences, and maps up to now. In the majority of situations, we come up with Map, Set,List,ArrayBuffer, or a Vector. Let's talk about the factors that matter:

If the requirement is to have a key-value lookup, we use Maps.
We use HashMap when order is of no importance, and ListMap when we want to store the key-value pairs in a sequence. ListMap operations take linear time...