Scala

Introduction

Some features of the language

• Functional and Object Orientated
• Use of immutable Data Structure
• Rich Collections Library
• Better Concurrency Support

To get this to work I downloaded scala and intellij.

Functional Programming

Some definitions

• Immutability is when we can not allowed to change a variable. Not changing a value means parallelism will work better
• Expression are something yields a value. e.g. x+y and have not side effects
• Statements is code which does something. e.g. do(something) and have side effects
• Function is a a relation between a set of inputs and a set of outputs with the property that each input is related to exactly one output.
  • Pure always has the same output, easier to test, parallelisation
  • Impure may not have the same output

High Order Functions

High Order Functions are function which take functions as an argument High Order functions allow you to provide some of the method as an argument to extract the part which is different
So given the following to get apples

def getApples(basket: List[Fruilt]) = getFruits(fruitBasket,
  (fruit: Fruit) => fruit.name = "apple")

Can be replaced with a more generic

def getFruits(basket: List[Fruilt], filterByFruit: Fruit => Boolean) = 
    for (fruit <- basket if filterByFruit(fruit)) yield fruit

Scala provide many other HOFs not KnightRider such as

• map
• reduce
• filter
• fold

Language Features

val and var

Like Kotlin, scala supports val and var where only vars can be changed

Conditions

If conditions are expressions and not statements. We generally do not need the return statement. I think this is like Ruby from memory e.g.

val arguments = Array("Monday")
val day = if (!arguments.isEmpty) arguments(0) else "Sunday"

Loops

Imperative

Where we do something

val letters = List("a","b","c","d","e")
for(letter <- letters) {
   println(letter)
}

We can add filters on the end e.g. to print even numbers

for(letter <- letters if (number %2) == 0) {
   println(letter)
}

And not just one, many, which I think is looking really really ugly

for(
 letter <- letters 
 if (number %2) == 0) 
 if (number > 2) 
{
   println(letter)
}

We can iterate within an iteration though using the same approach e.g. we could have

for(number <- numbers) {
  for(letter <- letters) {
     println(number + " => " + letter)
  }
}

But with the new way this could be written with curly braces

for{ 
  number <- numbers 
  letter <- letters 
 } println(number + " => " + letter)

Functional

Where we return values. Using the example above we could yield a List[String] of values.

for{ 
  number <- numbers 
  letter <- letters 
 } yield number + " => " + letter

=Introduction

Functions are very similar to other languages

def foo(arg: Type): ReturnType = {
  // Stuff
}

Anonymous Functions

Scala supports this e.g.

val plusOne = (x: Int) => x + 1

We can use the name function above with

plusOne(99)

Weird Option for Arrow Functions

If we use the argument in an arrow function once and only once we can drop replace the argument with an _ and drop the arrow. So

fruitBasket.filter(fruit => fruit.name)
// Can be replaced with
fruitBasket.filter(_.name)

Classes

Introduction

They can contain fields and methods like most languages. Like Kotlin we can initialize on the constructor

class Employee {
   private var salary: Int = 100 
   def getSalary() = salary
   def setSalary(newSalary) = {
      salary = newSalary
   } 
}
var john = new Employee

Companion Objects (Static Functions)

A bit like kotlin but a little different in that they are coded separate and can access the private fields of the class

object MathCompanion {
   def sum(a: Int, b: Int): Int = a + b
   def getPrivateMember: Int = new MathCompanion().max
}

class MathCompanion {
   private val max = 100
}

Apply

We can add a special apply method to the companion object to allow construction without the new keyword. This provides a functional way to create an object I think like Ruby.

object MathCompanion {
   def apply(firstname: String) = new Person(firstname)
}
class Person(firstname: String) {
...
}
val joe = Person("Fred")

Case Classes

This modifier

• Implements apply method
• Creates immutable arguments to the constructor
• Copy method to make modified copies
• Add Hash code, equals and toString()
• Pattern Matching

case class Course(title: String, author: String)
val scalaCourse = Course("Scala Test", "Joe Humanshu")

Traits and Main

A trait encapsulates method and field definitions, which can then be reused by mixing them into classes. Unlike class inheritance, in which each class must inherit from just one superclass, a class can mix in any number of traits.

Traits are used to define object types by specifying the signature of the supported methods. Scala also allows traits to be partially implemented but traits may not have constructor parameters.

A trait definition looks just like a class definition except that it uses the keyword trait. The following is the basic example syntax of trait.

trait Equal {
   def isEqual(x: Any): Boolean
   def isNotEqual(x: Any): Boolean = !isEqual(x)
}

class Point(xc: Int, yc: Int) extends Equal {
   var x: Int = xc
   var y: Int = yc
   
   def isEqual(obj: Any) = obj.isInstanceOf[Point] && obj.asInstanceOf[Point].x == y
}

object Demo {
   def main(args: Array[String]) {
      val p1 = new Point(2, 3)
      val p2 = new Point(2, 4)
      val p3 = new Point(3, 3)

      println(p1.isNotEqual(p2))
      println(p1.isNotEqual(p3))
      println(p1.isNotEqual(2))
   }
}

Whilst learning scala we are directed to use the App trait as it contains the main function e.g.

object Hello extends App {
  println("Fred Was Ere")
}

VS Code

I used https://shunsvineyard.info/2020/11/20/setting-up-vs-code-for-scala-development-on-wsl/ for installing with VS Code.