Functional programming in Scala

d.jureczko@gmail.com
@DamianJureczko
FUNCTIONAL PROGRAMMING IN
SCALA

AGENDA
Scala - a quick intro
Functional programming
Functional constructions in Scala

SCALA
Created by Martin Odersky
First release in 2004

SUPPORTS OBJECT-ORIENTED
PROGRAMMING
Everything is an object
val x = 10
x.toString

Operators are functions
val y = x + 10
val z = x.+(4)

Functions like operators (infix notation)
names.mkString(",")
names mkString ","

Define your own types
abstract class Vehicle {
def move(): Unit
}
class Car extends Vehicle {
override def move(): Unit = {
println("drive")
}
}

SUPPORTS FUNCTIONAL PROGRAMMING
First-class functions, and more...
// function type
(Int, Int) => Int
// anonymous function
(x: Int, y: Int) => x + y

RUNS ON JVM
Interoperates with Java libraries
import java.time.Instant
val now = Instant.now()
import com.google.common.cache.CacheBuilder
val usersCache: Cache[String, User] = CacheBuilder.newBuilder()
.maximumSize(100).build()

STATICALLY TYPED
Find errors early
var name = "John"
name = "Mark"
name = 2 // compilation error !!!
def abs(x: Int): Int
abs("Adam") // compilation error !!!

SCALA IS ABOUT CONCISENESS
Express more with less code
class User(email: String, password: String)

TYPE INFERENCE
Compiler already knows the type
val firstName: String = "John"
val lastName = "Smith" // better
val age = 30

It's everywhere
val add: (Int, Int) => Int = (x: Int, y: Int) => x + y
// we know the type of x and y
val mul: (Int, Int) => Int = (x, y) => x * y
val sum: Int = add(2, 3)
// we know the type of the result
val product = mul(2, 3)

SCALA GOODIES
Case classes
Pattern matching
Collections

CASE CLASSES
Immutable and easy to use data structures
// declare
case class User(email: String, password: String)
// create
val admin = User("admin@company.com", "buddy")
// access fields
val adminEmail = admin.email
// create copy
val otherAdmin = admin.copy(email = "admin2@company.com")
// compare
assert(admin != otherAdmin)

PATTERN MATCHING
Powerful matching technique
something match {
case "value" => println("it's String equal to 'value'")
case 10 => println("it's Int equal to 10")
case s: String => println("it's String with value: " + s)
case _ => println("it's something else")
}

Does magic with case classes
user match {
case User("admin@company.com", "buddy") =>
println("it's administrator")
case User(email, password) =>
println("it's " + email + ", his password is: " + password)
}

COLLECTIONS
lists, sets, maps, ...
immutable
mutable
functional API

Easy to create
val students = List("Adam", "John", "Andrew")
val studentGrades = Map("Adam" -> 4, "John" -> 3, "Andrew" -> 5)
val cities = Set("London", "Berlin", "Warsaw")

Immutable - for elegance
// new collection
val moreStudents = "Michael" :: students

Mutable - for speed
val students = mutable.ArrayBuffer("Adam", "John", "Andrew")
students += "Michael"

Easy to use functional API
students.find(_ == "John") // Some(John)
students.filter(_.length > 4) // List(Andrew)
students.map(_.length) // List(4, 4, 6)

Programming paradigm
FUNCTIONAL PROGRAMMING

Imperative vs. Functional
statements functions/expressions
side eﬀects no side eﬀects
mutable program state immutable data

IMPERATIVE
How things should be done
List<Student> students;
int counter = 0;
for (Student student : students) {
if (student.getGrade() > 3) {
counter++;
}
}

FUNCTIONAL
What should be done
val counter = students.count(_.grade > 3)

FIRST-CLASS FUNCTIONS
function is a first-class citizen
can be assigned to a variable
can be passed as an argument of a function
can be returned from a function

HIGH-ORDER FUNCTIONS
take other functions as argument
return functions as result

Assign function to a variable
case class Student(name: String, grade: Int)
// function object
val goodStudent: Student => Boolean = student => student.grade > 3
assert(goodStudent(Student("Smith", 3)) == false)
assert(goodStudent(Student("Jones", 4)) == true)

Pass function to a high-order function
// List high-order funtion
def count(predicate: Student => Boolean): Int
val students = List(Student("Smith", 3), Student("Jones", 4))
val counter = students.count(goodStudent)
assert(counter == 1)

Return function from a high-order function
// high-order function
def gradeHigherThen(threshold: Int): Student => Boolean =
student => student.grade > threshold
val above3 = gradeHigherThen(3)
val above4 = gradeHigherThen(4)
val counter = students.count(above3)

PURE FUNCTIONS
No side eﬀects

Computes a result based of its inputs
def add(x: Int, y: Int) = x + y

Referential transparency
expression is referentially transparent if it
can be replaced with is corresponding
value without changing the program's
behavior

Possible replacement
val sum1 = add(2, 2)
val sum2 = add(2, 2)
val sum1 = 4
val sum2 = 4

Impure function
var acc = 0
def impureAdd(x : Int, y: Int) = {
acc = acc + x + y
acc
}

Not referentially transparent
val sum1 = impureAdd(2, 2)
val sum2 = impureAdd(2, 2)
val sum1 = 4 // here it's 4
val sum2 = 4 // here it's 8 and the order matters

Pure functions simplify
reasoning about program behavior
composing programs
proving correctness - testing
optimizing - caching, parallelization, reordering

FUNCTIONAL DATA STRUCTURES
Immutable

Operated by pure functions
val numbers = List(1, 2, 3, 4, 5)
val oddNumbers = numbers.filter(_ % 2 == 0) // new list

Quick copy
val list1 = 1 :: Nil
assert(list1.head == 1)
assert(list1.tail == Nil)
val list2 = 2 :: list1
assert(list2.head == 2)
assert(list2.tail == List(1))

Thread safety
Immutable data can be safely shared between threads
def changeGrade(student: Student): Future[Student] = Future {
student.copy(grade = 5)
}

FUNCTIONAL CONSTRUCTIONS IN
SCALA

Has two subclasses
val someName: Option[String] = Some("John")
val noneName: Option[String] = None

Optional result of a function
def findUser(email: String): Option[User]
better then
def findUser(email: String): User
val user = findUser("john.smith@company.com")
if (user != null) {
...
}

Pattern matching Options
user match {
case Some(User(email, password)) =>
case None =>
}

MONADS
Containers
trait M[T] {
def map(f: T => S): M[S]
def flatMap(f: T => M[S]): M[S]
}

Option is a monad
Option[+A] {
def map[B](f: (A) ⇒ B): Option[B] // only if nonempty
def flatMap[B](f: (A) ⇒ Option[B]): Option[B] // only if nonempty
}

Map Option
val user: Option[User] = findUser("john.smith@company.com")
val password: Option[String] = user.map(u => u.password)

FlatMap Option
val user: Option[User] = findUser("john.smith@company.com")
val password: Option[String] = user.flatMap { u =>
if (u.password.nonEmpty) Some(u.password) else None
}

Transforming collections
val names = List("John", "Mark", "Andrew", "Micheal")
names.map(_.length) // List(4, 4, 6, 7)

Try - catch, the non functional way
try {
val user = findUser("john.smith@company.com") // may fail
user.password // possible NullPointerException
} catch {
case t: Throwable => // handle error
}

Try
Try[+T]
def findUser(email: String): Try[User]
findUser("john.smith@company.com") match {
case Success(User(email, password)) =>
case Failure(exception) =>
}

Try is a monad
val password = user.map(user => user.password)

Either error or correct value
Either[+A, +B]
case class Error(message: String)
def findUser(email: String): Either[Error, User]

Pattern matching Either
findUser("john.smith@company.com") match {
case Right(User(email, password)) =>
case Left(Error(message)) =>
}

Right-biased Either (coming soon in Scala 2.12.0)
val password = user.map(u => u.password) // only if user is Right

TAKEAWAYS
Scala is a powerful programing language
Functional programming simplifies your life

Functional programming in Scala

More Related Content

What's hot

Viewers also liked

Similar to Functional programming in Scala

Recently uploaded

Functional programming in Scala