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

Types

val and var

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

Data Types

	Data Type	Possible Values
	Boolean	true or false
	Byte	8-bit signed two’s complement integer (-2^7 to 2^7-1, inclusive) -128 to 127
	Short	16-bit signed two’s complement integer (-2^15 to 2^15-1, inclusive) -32,768 to 32,767
	Int	32-bit two’s complement integer (-2^31 to 2^31-1, inclusive) -2,147,483,648 to 2,147,483,647
	Long	64-bit two’s complement integer (-2^63 to 2^63-1, inclusive) (-2^63 to 2^63-1, inclusive)
	Float	32-bit IEEE 754 single-precision float 1.40129846432481707e-45 to 3.40282346638528860e+38
	Double	64-bit IEEE 754 double-precision float 4.94065645841246544e-324d to 1.79769313486231570e+308d
	Char	16-bit unsigned Unicode character (0 to 2^16-1, inclusive) 0 to 65,535
	String	a sequence of Char

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

Functions

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")
}

Error Handling

Null Handling

Maybe tired of typing this but like Ruby, Scala supports the Option approach to null handling i.e. you can return an Option[String]. From here use getOrElse and write

val result = employees.find(_=="Value Not Found).getOrElse("Nobody home")

Exception

Standard languages support try/catch/finally approoach.

try {
} catch(Exception e) {
} finally {
}

Scala can use pattern matching so examine the result.

val outcome = Try(10/0)
outcome match {
   case Success(value) => println("Time for bed")
   case Failure(er) => println("Computation failed, " + e.getMessage)
}

Either

Either works like Option except it is a tuple where you can place the result in one side and the error in the other.

def stringToInt(in: String): Either[String, Int] = {
   try {
      Right(in.toInt)
   } catch {
      case e: NumberFormatException => Left("Error: " + e.getMessage)
   }
}

Pattern Matching

Introduction

Just like Ruby sigh!! Switch statements without breaks.

val number = 5
number match {
   case 0 => "zero"
   case 5 => "five"
   case 9 => "nine"
   case _ => "default" // Must be last
}

Matching On Attributes

We can have attributes as matches and ignore some content

case class Track(title: String, artist: String, trackLength: Int)
myTrack match {
   case Track(_,_, 100) => "Long Track"
   case Track(_,"Bowie", _) => "Bowie"
   case _ => "No Track"
}

Matching On Sequence

We can match on sequences by using wildcards to denote we do not card about data beyond a certain value

val numbers = List(1,2,3,4,5,6,7)
numbers match {
   case List(_, second, _*) => second
   case _ => -1
}

Matching On Type

We can of course match on type too

myThing match {
   case t1: ThingType1 => println(s"You have won a ${t.getReadableName()}")
   case t2: ThingType2 => println(s"You have won a ${t2.getReadableName()}")
   case a1: AnotherType => println(s"You have won a ${a1.getName()}")
   case _ => "Nought"
}

Matching On With Filtering

We can add expression to our filters too provided they are a Boolean

myThing match {
   case t1: ThingType1 if t1.getName().contains('Ice") => println(s"You have won a ${t.getReadableName()}")
...
   case _ => "Nought"
}

Scala Collections

Introduction

All the collections have a mutable and immutable version where immutable is imported by default. Here is the class hierarchy.

• Seq
  • Indexed can access by the index
  • Linear only access by the head or tail
• Set
  • Sorted You can have ordering and uniqueness
  • BitSet A set of non-negative integers depicted as arrays.
• Map
  • Sorted Map This is Unique Key and Sorted

List

• head gets first element
• tail gets the inverse of head e.g. [1,2,3,4] return [2,3,4]
• last gets the last element
• init gets the inverse of last e.g. [1,2,3,4] return [1,2,3]
• numbers :+5 adds to the end
• 0 +: numbers adds to the start
• numbers ++ List(5,6,7) combines at the end
• List(-1,0) ++ numbers combines at the beginning
• numbers.drop(2) will drop 2 from the left
• numbers.dropRight(3) will drop 3 from the right
• numbers.dropWhile(_ < 3) will drop if less than 3

Sets

These are similar to list except the duplicates are combined

Maps

Not many surprises

• weekDays(1) returns the value of key 1
• weekDays + (4 -> "Wednesday") adds a key/value
• weekDays -1 removes a adds a key/value from the left
• weekDays.foreach(entry => println(s"${entry._1} => ${entry._2}"))) iterates

Numerical Ops

For numbers we can call function which act on all members.

• min
• max
• sum

We can filter easily with predicate remembering we can drop the name in anonymous functions where used once gives a nice syntax to get the filtered values.

peadeLoadTimesInSeconds.filter(_ >= 10).min

Conversion

We can call functions on the collection to convert from one type to another. E.g. mySet.toList() will convert to a set to a list

Map operator (Transform)

Map is provide in scala and works like many map functions in other languages

Flatten and FlatMap

We can use flat map to flatten results

val nestedList = List(List(1,2,3), List(4,5,6,7))

// With flatten we can combine and add 1
nestedList,map(aList => aList.map(_ + 1)).flatten
// List(2,3,4,5,6,7,8)

// With flatMap we can do this more efficiently with
nestedList,flatMap(aList => aList.map(_ + 1))
// List(2,3,4,5,6,7,8)

Concurrency

Concurrency and Parallelism

Just in case we have forgotten Concurrancy is when we do many things across a processor, timeslicing and Parallelism is when we do thing in parallel

Currying

Currying is the technique of transforming a function with multiple arguments into a function with just one argument. The single argument is the value of the first argument from the original function and the function returns another single argument function. This allows lazy evaluation of the code

Java Example

public static int add(int a, int b) {
    return a + b;
}

into something like this (where Function<A, B> defines a single method B apply(A a)).

public static Function<Integer, Function<Integer, Integer>> add() {
    return new Function<Integer, Function<Integer, Integer>>() {
        @Override
        public Function<Integer, Integer> apply(final Integer x) {
            return new Function<Integer, Integer>() {
                @Override
                public Integer apply(Integer y) {
                    return x + y;
                }
            };
        }
    };
}

This evaluates to

add();                  // gives back a instance of Function<[A, B]>
add().apply(1);         // gives back a instance of Function<[A, B]>
add().apply(1).apply(1) // gives 2

Scala Example

In Scala, the regular uncurried function would look like this.

def add(x: Int, y: Int): Int = {
  x + y
}

As Scala supports curried functions, you can turn this into it’s curried version simply by separating out the arguments.

// shorthand
def add(x: Int)(y: Int): Int = {
  x + y
}

Which is shorthand for writing it out like this.

// longhand
def add(x: Int): (Int => Int) = {
  (y: Int) => {
    x + y
  }
}

VS Code

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