Introduction to programming in scala

Introduction to Programming in
Scala
May 4th, 2017

Hungai Amuhinda
@hungai
hungaikev
hungaikev.in
hungaikevin@gmail.com

Agenda
❖ Introduction
❖ Scala Concepts
❖ OOP
❖ FP
❖ Collections

Scala:
Scala is a Java like programming
language which unifies object - oriented
and functional programming.

Scala Concepts
● Scala is an object oriented language in pure form: every
value is an object and every operator is a method.
● “ + ”, “ - ”, “ * ”, “ / ” are all methods
SCAVANNAH 2017

Scala Concepts
● Everything is an expression
● Expression is an instruction to execute something that
will return a value.
● An expression evaluates to a result or results in a value
SCAVANNAH 2017

Scala Class Hierarchy
scala.Any
scala.AnyVal scala.AnyRef
scala.Int
scala.Byte
scala.Boolean
scala.Char
scala.Stringscala.List
scala.Seq
scala.Map

Scala Data Types
● Boolean
● Byte
● Short
● Int
● Long
SCAVANNAH 2017
● Float
● Double
● Char
● String

Scala
Concepts(Advanced
Type System)
● Static
● Inferred (Type Inference)
● Structural
● Strong
SCAVANNAH 2017

Program with Scala (REPL)
Read Evaluate Print Loop
$ scala
Demo 03 SCAVANNAH 2017

Program with Scala (REPL)
Read Evaluate Print Loop
$ scala -Dscala.color

Program with Scala
(Worksheet)
Work with worksheets
● IntelliJ
● Scala IDE or Eclipse
with Scala Plugin
● Ensime

Program with Scala (Main)
object Demo1 {
def main (args: Array[String]): Unit = {
println(“Hello Everyone”)
println(“Welcome to today's event”)
}
}

Program with Scala (App)
object Demo2 extends App {
val todaysEvent = “Scavannah”
lazy val fun = (0 to 4).map(x => “fun”).mkString(“ ”)
println(“Hello world”)
println(“Welcome to ” + todaysEvent + “! n”)
}

Scala Concepts
SCAVANNAH 2017
❖ var, val
❖ If expressions
❖ def
❖ Block expressions
❖ While - Loops
❖ For - Loops
❖ Nested Function
❖ Recursion vs Tail recursion
❖ Pattern Matching

Scala Concepts
❖ var - variable
Something that is able or
likely to change or be
changed (Mutable)
❖ val - value
A value is an expression
that cannot be changed
any further (Wiki)
(Immutable)
It's similar to final in
Java

Expression with Semicolon?
val x = 5566
val y = 87
val java = “Java” ; val scala = “scala”
If you have multiple expressions in one
line, you will need semicolons(;).
Otherwise you don't need it.

If Expressions
❖ If has return value (expression)
❖ Scala has no ternary operator (? : )
val value = 0
val negative =
If (value < 0 ) true else false
Everything is an expression

def
def max (x: Int, y: Int): Int = {
If (x > y) x else y
}
Function body in Curly braces
Equals sign
Result type of function
Parameters
Function name
“def” starts a function definition

def
def max (x: Int, y: Int): Int = {
If (x > y)
return x
else
return y
}

def
def max (x: Int, y: Int) = {
If (x > y)
x
else
y
}
No Result type

def
def max (x: Int, y: Int) =
If (x > y)
x
else
y
No Curly brackets

Summary of def
❖ You don't need a return statement
- Last expression of a block will be the return value
❖ You don't need return type in method or function definition.
- Scalac will infer your return type in most cases. Its a good habit
to have a return type, especially if your API has a public
interface
❖ You don't need curly brackets
- If you have multiple lines of code, using curly brackets ({ }) is a
good habit
SCAVANNAH 2017

Block expressions (Curly brackets)
val n = 5
val factorial = {
var result = 1
for (i <- 1 to n )
result = result * i
result
}
Demo 012 SCAVANNAH
Last expression (result) in block will be the
return value, then it will be assign result to
“factorial”

While Loop
var n = 10
var sum = 0
while (n > 0) {
sum = sum + 1
n = n - 1
}
Demo 013 SCAVANNAH

For - Loop
Demo 014 SCAVANNAH
var sum = 0
for (i <- 1 to 10) {
sum += 1
}
println(sum)

Nested Function
def min (x: Int, y: Int): Int = {
def max (x: Int, y: Int) = {
if (x > y)
x
else
y
}
if (x >= max(x,y)) y else x
}
Demo 015 SCAVANNAH

Recursion vs Tail - recursion
def factorial(n : Int): BigInt = {
If (n == 0) 1
else
n * factorial(n - 1)
}
factorial (15)
factorial (150)
factorial(15000) // java.lang.StackOverflowError
Demo 016 SCAVANNAH

def helpFunction(acc : Int, n: Int) : BigInt = {
If (n == 0)
acc
else
helpFunction(acc * n , n -1 )
}
helpFunction(1,n)
}
factorial(15000)
Demo 017 SCAVANNAH
“Tail - Recursion”

import scala.annotation.tailrec
@tailrec
def helpFunction(acc : Int, n: Int) : BigInt = {
If (n == 0)
acc
else
helpFunction(acc * n , n -1 )
}
helpFunction(1,n)
}
factorial(15000)
Demo 018 SCAVANNAH
“You have to add a return type, when the
function is recursive”
“Add annotation is a good habit. Compiler
can check whether or not it can be
optimised. ”

Pattern Matching
❖ Pattern matching is a feature that is very common in functional
languages
❖ It matches a value against an expression
❖ Each pattern points to an expression
❖ It's similar to “switch case” but its more general. There are some
differences:
- No fall through
- Each condition needs to return a value(Everything in scala is an
expression)
- It can match anything
SCAVANNAH 2017

Pattern Matching
def matchString(x : String): String = {
x match {
case “Dog” => x
case “Cat” => “Not a cat person”
case _ => “Neither Dog or Cat”
}
matchString(“Dog”)
matchString(“Human”)
Demo 019 SCAVANNAH

Scala (Object Oriented)
SCAVANNAH 2017
❖ Classes
❖ Extends , with, override
❖ Abstract classes
❖ Objects, Companion
objects
❖ Traits
❖ Case classes

Classes
class Employee(id : Int, val name: String, address: String, var salary: Long
)
val employee = new Employee(1,”Hungai”,”Kakamega”,40L)
Demo 020 SCAVANNAH
Primary Constructor val in constructor will give you a getter
var in constructor will give you a getter and setter

Extends, with, override.
❖ Scala is single inheritance like Java.
❖ Scala - extends = Java - extends
❖ Scala - with = Java - implements
❖ Scala - override = Java - @Override
SCAVANNAH
Single inheritance enables a derived class to inherit
properties and behaviour from a single parent class

Abstract classes.
❖ Abstract classes are just like normal classes but can have abstract
methods and abstract fields
❖ In scala, you don't need the keyword abstract for methods and fields
in an abstract class
SCAVANNAH

Abstract classes.
abstract class Animal (val name: String) {
val footNumber: Int
val fly : Boolean
def speaks : Unit
}
class Dog(name: String) extends Animal (name) {
override val footNumber : Int = 4
override val fly = false
override def speak : Unit = println(“Spark”)
}
class Bird(name : String) extends Animal(name) {
override val footNumber : Int = 2
override val fly = true
override def speaks: Unit = println(“chatter”)
}
Demo 021 SCAVANNAH
Subclasses should be in the same file.

Objects.
❖ A singleton object is declared using the object keyword.
❖ When a singleton object shares the same name with a class it's
referred to as a Companion object.
❖ A companion object and its classes can access each others private
methods or fields
SCAVANNAH

Singleton Object.
object MathUtil {
def doubleHalfUp(precision: Int, origin: Double): Double {
val tmp = Math.pow(10,precision)
Math.round(origin * tmp)/ tmp
}
}
Demo 022 SCAVANNAH

Case Classes.
Case classes are just regular classes that are :
➔ Immutable by default
➔ Decomposable through pattern matching
➔ Compared by structural equality instead of by reference.
When you declare a case class the scala compiler does the following for you:
➔ Creates a class and its companion object
➔ Implements the ‘apply’ method that you can use a factory. This lets you
create instances of the class without the ‘new’ keyword
SCAVANNAH

Case classes.
abstract class Notification
case class Email(sourceEmail: String, title: String, body: String) extends Notification.
case class SMS (sourceNumber: String, message: String) extends Notification.
case class VoiceRecording(contactName: String, link: String) extends Notification.
val emailNotification = Email(“h@hungaikev.in”,”Scavannah”,”Todays lesson”)
println(emailNotification)
Demo 023 SCAVANNAH

The Lambda Calculus.
Demo 012 SCAVANNAH
Alonzo Church 1930
❖ Theoretical foundation
❖ Pure functions - no state
❖ Not a programming language

Lambda Calculus.
ƛx . x + 1
SCAVANNAH
ExpressionsVariable
Function Application

Lambda Calculus.
ƛx . x + 1
// Scala Translation
{ x : Int => x + 1 }
Demo 024 SCAVANNAH

Scala (Functional)
SCAVANNAH 2017
❖ Functional Concepts
❖ First class functions
❖ Anonymous functions
❖ Higher order functions

Functional Concepts.
❖ Immutability (Referential Transparency - Expressions always evaluates to
the same result in any context)
- No side effects (Modifies state, Not predictable)
❖ Functions as values
- Functions as objects
❖ Higher order functions - Input: Takes one or more functions as parameters,
Output: Returns a function as result
Demo 012 SCAVANNAH

Anonymous functions (Lambdas).
Demo 012 SCAVANNAH

Anonymous functions.
((x : Int ) => x * x)
(0 until 10).map ((value: Int) => value * value)
(0 until 10).map (value => value * value )
(0 until 10).map (value => value + 1)
(0 until 10).map (_ + 1)
Demo 025 SCAVANNAH

High-order Functions.
def calculateTax(rate: BigDecimal => BigDecimal, salary: BigDecimal) : BigDecimal = {
rate(salary)
}
val kenyaTax = (salary: BigDecimal) => {
if (salary > 413201) salary * 0.396 else salary * 0.3
}
val tzTax: BigDecimal => BigDecimal = _ * 0.25
calculateTax(kenyaTax,413201)
calculateTax(tzTax,100)
Demo 026 SCAVANNAH

def calculateTax(rate: BigDecimal => BigDecimal, salary: BigDecimal) : BigDecimal = {
rate(salary)
}
def kenyaTax (salary: BigDecimal) = {
calculateTax(x =>
if (salary > 413201) salary * 0.396 else salary * 0.3, salary )
}
def tzTax(salary: BigDecimal ) =
calculateTax( _ * 0.25, salary)
kenyaTax(413202)
tzTax(100)
Demo 027 SCAVANNAH

def calculateTax(rate: BigDecimal => BigDecimal) : (BigDecimal ) => BigDecimal = {
rate
}
def kenyaTax = calculateTax(x => if (x > 413201) x * 0.396 else x * 0.3 )
def tzTax = calculateTax( x => x * 0.25)
kenyaTax(413202)
tzTax(100)
calculateTax(kenyaTax)(413202)
calculateTax(tzTax)(100)
Demo 028 SCAVANNAH

High-order Functions - Curry.
def calculateTax(rate: BigDecimal => BigDecimal) (salary : BigDecimal ) : BigDecimal =
{
rate (salary)
}
def kenyaTax(salary : BigDecimal) = calculateTax(x => if (x > 413201) x * 0.396 else x *
0.3 )(salary)
def tzTax(salary : BigDecimal) = calculateTax( x => x * 0.25)(salary)
kenyaTax(413202)
tzTax(100)
Demo 029 SCAVANNAH

Collections
❖
SCAVANNAH
❖ Concept of Collections
❖ Hierarchy of Collections
- Immutable
- Mutable
❖ Immutable List

Collections.
❖ Scala supports mutable collections and immutable collections.
❖ A mutable collection can be updated or extended in place. This means you
can change, add or remove elements as a side effect.
❖ Immutable collections never change. You have still operations that stimulate
additions, removals, updates by creating a new collection and leave the old
unchanged.
SCAVANNAH

Collections Hierarchy
SCAVANNAH

Hierarchy of Immutable Collections
SCAVANNAH

Hierarchy of mutable Collections
SCAVANNAH

Immutable List
// Construct a List
val list1 = List(1,2,3)
val list2 = 1 :: 2 :: 3 :: 4 :: 5 :: Nil
val list3 = List(“apples”, “oranges”,”bananas”)
val list4 = List(5,5,6,6) ::: List(8,7)
Demo030 SCAVANNAH
Pronounced “cons”

Immutable List (API)
val list = List(4,3,0,1,2)
➔ list.head
➔ list.tail
➔ list.length
➔ list.max
➔ list.min
➔ list.sum
➔ list.contains(2)
➔ list.drop
➔ list.reverse
Demo031 SCAVANNAH
➔ list.sortWith(_ > _)
➔ list.map(x => x * 2)
➔ list.map(_ * 2)
➔ list.reduce((x,y) => x + y)
➔ list.filter(_ % 2 == 0)
➔ list.groupBy(x => x % 2 == 0)

Summary of Scala.
❖ Keep it simple
❖ Don’t pack too much in one expression
❖ Find meaningful names
❖ Prefer functional
❖ Careful with mutable objects
SCAVANNAH

Further Reading $ References.
❖ Scala Official Docs
❖ Cousera - Martin Odesky
❖ Creative Scala
❖ Scala School by Twitter
❖ Scala 101 by Lightbend
SCAVANNAH

Introduction to programming in scala

Recommended

More Related Content

What's hot (19)

Similar to Introduction to programming in scala (20)

Recently uploaded (20)

Introduction to programming in scala