Scala stands for Scalable language. Scala is a multi-paradigm programming language built on JVM by the Lightbend (formerly known as Typesafe) team. In Scala, it is easy to write concurrent parallel, distributed, and Reactive applications in a concise, elegant, and type-safe way.

Unlike Java, Scala is a pure OOP and FP language. Java is not a pure OOP language because of the following:

• It supports static members
• It supports primitive data types

Scala does not support static members. Then how do we define utility methods in Scala? We will explore those in the upcoming sections. In Scala, everything is an object only. There are no primitive types in Scala.

Both Scala and Java programming languages run on JVM:

From Java 8 onward, we can write functional-style programming in Java. However, it does not support all FP features.

Scala's latest stable version...

Scala supports all FP features. However, it is not easy to cover them in a single chapter. So we will discuss only the following few important FP features in this chapter:

• Pure functions
• Immutability (Immutable data)
• Referential transparency
• Functions are first-class citizens
• Anonymous functions
• Higher-Order Functions (HOF)
• Currying
• Tail recursion
• Implicit
• Typeclasses

The following three are the most important and frequently used Functional Design Patterns.

• Monoid
• Monad
• Functor (Applicative functor)

Consider the following Scala FP features...

In previous sections, we defined a couple of Scala functions and came to know that each function has a meaningful name. Is it possible to define a function without a name? Yes, in Scala, we can define a function without a name.

An anonymous function is a function without a name. It is also known as a function literal. It works just like a normal function. Let's explore it with some examples now:

def add (a: Int, b: Int) = a + b 

The following diagram shows the syntax of a Scala anonymous function:

As we discussed with the add() function in the previous section, it is a normal Scala function.

We can write the same function as an anonymous function, as shown here:

scala> (a: Int, b: Int) => a + b 
res0: (Int, Int) => Int = <function2> 

Here, we have created an anonymous function of type Int, Int) => Int. It clearly explains what...

Unlike Java, in Scala, everything is an expression. Yes, that's right. Then how about if...else expressions, For-comprehension (for loop), case statements, and more?

In Scala, we can use an if...else as a statement or expression, as shown here:

scala> val x = 10 
x: Int = 10 
 
scala> if (x % 2 == 0) "Even" else "Odd" 
res4: String = Even 
 
scala> val result = if (x % 2 == 0) "Even" else "Odd" 
result: String = Even 
 
scala> result 
res5: String = Even 

In the same way, we can assign anything to a variable, as everything is an expression.

In Scala, referential transparency (RT) means that an expression or a function call may be replaced by its value, without changing the behavior of the application.

A value may be replaced by an expression or a function call without changing the behavior of the application.

We will explore these two points with some simple examples now.

Let's assume that we are using the y = x + 1 expression in our application:

scala> val x = 10 
x: Int = 10 
 
scala> val y = x + 1 
y: Int = 11 
 
scala> val y = 11 
y: Int = 11 

Here, when we replace an expression x+1 with its value 11, it does not change any behavior of the y in our application:

scala> val y = 11 
y: Int = 11 
 
scala> def addOne(a: Int) = a + 1 
addOne: (a: Int)Int 
 
scala> val y = addOne(x) 
y: Int = 11 

Here, the value of y is replaced by a function called addOne(). In this case...

In Scala, functions are first-class citizens because we can do the following things with them:

• We can use functions as values or like normal variables; we can replace a variable or value with a function
• We can assign a function literal to a variable
• We can pass one or more functions as another function's parameters
• We can return a function from another function

We will discuss the last two points in the Scala Higher-Order Functions section. Let's discuss the first two points here.

We can use a function like a normal value or variable, as shown here:

scala> def doubleIt(x: Int) = x * x 
doubleIt: (x: Int)Int 
 
scala> def addOne(x: Int) = x + 1 
addOne: (x: Int)Int 
 
scala> val result = 10 + doubleIt(20) + addOne(49) 
result: Int = 460 

We can assign an anonymous function to a variable, as shown in the following code snippet...

Recursion is a technique defined as using a function or method that calls itself again and again, until it solves the problem.

The recursion technique helps us solve simple problems very easily and even makes it possible to solve complex problems. It is easy to reason about and needs a lot less code, as compared to the iterative approach.

What kind of problems can we solve using the recursion technique? Any problem that is defined in terms of itself.

We can implement recursion in different ways. However, we are considering only the following two types:

• Linear recursion
• Tail-recursion

Tail-recursion is one form of recursion technique. We can say a recursive call is tail-recursive,...

In Scala, a Type class defines some behavior in terms of some operations. If a new class (or Type) wants to join as a member of that Type class, it must provide implementation to all operations, which are defined in that Type class.

So in simple words, a Type class is a group of classes which provides implementation to a contract (or an interface).

The main goal of Type classes is to define a contract or interface to its types.

Unlike sub-type polymorphism, which uses OOP inheritance, Type classes follow ad hoc polymorphism, using composition and support DRY (Do NOT Repeat Yourself) and SRP (Single Responsibility Principle).

Like generics or Type parameters, Type classes are resolved at compile time. The following diagram shows the main goal of Scala Type class:

Types of polymorphism in brief:

• Parametric polymorphism—using generics:

      trait Json...

The Scala language supports a very rich Collection API. It supports two sets of Collections—one to support immutability (immutable Collections) and another to support mutability (mutable Collections).

It requires almost an entire book to explain each and every Collection API in depth. As we have only one subsection in this chapter for Collections, we will discuss only the most important and frequently used Collections here.

In the Scala Collection API, List is a LIFO-based immutable Collection which represents an ordered linked list (where LIFO stands for Last In First Out). It is available as scala.collection.immutable.List.

It has two implementation case classes, scala.Nil and...

As a Java or Scala-experienced developer, I guess you are already familiar with some of the OOP design patterns. You may be not aware of Scala Functional Design Patterns.

Scala source code or applications use the following Functional Design Patterns extensively:

• Monoid
• Functor
• Monad

All these three terminologies come from Mathematics Category Theory (MAT). Let's delve into each of these, one by one in the following sections:

• Monoid: In Scala, Monoid is a type class or data structure with the following two rules:
  • Associative rule:

              (A1 Op A2) Op A3 == A1 Op (A2 Op A3)

• • Identity rule: This rule states that, suppose we make a call to a function with two elements. This Identity rule states if that function returns a second element as is, without any change, then that first element is known as an Identity element:

Left...

Scala Traits are somewhat similar to Java 8's interface, but they do more. We can use a Scala Trait as an interface (contract), abstract class, class, Mixin, and more.

In Scala, a Trait can contain abstract code, concrete code, or both. We can create a trait using the trait keyword, as shown here:

Trait Syntax: 
 
trait <Trait-Name> { 
 
  // Abstract members (Data and Functions) 
 
  // Non-Abstract (Concrete) members (Data and Functions) 
 
}  

Let's explore them, one by one, now.

We can define a Trait only with abstract members, as shown here:

rambabuposa@ram$ scala -cp joda-time-2.9.6.jar
Welcome to Scala 2.12.3 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_121...

In this chapter, we discussed some Scala Basics and how to use the Scala app to execute standalone applications. We also discussed what is Scala REPL and how to access it.

We discussed a couple of Scala Functional Programming concepts with some simple examples, and gave an introduction to the Scala Collection API.

We discussed Scala FP Design Patterns such as Monoid, Functor, and Monad, and finally discussed a couple of Scala Source Code Monads.

Finally, we explored one of the greatest features of Scala—Traits. Java does not have a similar programming construct. We also explored linearization rules with one simple example.

In the next chapter, we will discuss the Scala asynchronous programming API.