Demystifying functional programming with Scala

History
2003 - Released in EPFL
2008 - ‘Programming in Scala’
2010 - Version 2.8
2011 - Typesafe Inc. founded
2012 - First course on Coursera
2013 - Version 2.10

Recipe
● Take Java-like syntax
● Remove specifics and
unnecessary limitations
● Mix in functional features*

Complexity
● About 40 reserved words
● Only 2 namespaces vs. 4 in Java (fields, methods,
packages, types)
● Methods instead of operators
● No primitives (AnyVal)

Hierarchy
scala
Double
scala
Unit
scala
AnyVal
scala
Any
scala
AnyRef
java.lang
String
scala.collection.immutable
List
scala
Null
scala
Nothing
scala
Int

Collections
s.c
Seq
s.c
Set
scala.collection
Iterable
scala.collection
Traversable
s.c
Map
s.c
List
s.c
Buffer
s.c
IndexedSeq
● Redesigned in 2.8
● 100500+ methods
● Immutable by default
● Easy conversions
● Buffers

Basics
val a = 123
var b: Int = 124
def increment = (a: Int) => a + 1

Basics
val list = new List[Int](1, 2, 3, 4)
val first = list(0)

Classes
class User (var id: Int, val name: String) {
}

Classes
class User (var id: Int, val name: String) {
override def toString = {
id + ". " + name
}
}
scala> new User(1, "Simon")

Objects
object User {
def apply(id: Int, name: String) =
new User(id, name)
}
scala> User.apply(2, "Bob")

Objects
object User {
def apply(id: Int, name: String) =
new User(id, name)
}
scala> User.apply(2, "Bob")
scala> User(3, "Chris")

Language tricks
val arr = Array[String]("a", "b")
val el = arr(1)
// arr.apply(1)

Language tricks
def abs(a: Int) = if (a >= 0) a else -a
abs(12)
abs{-13}

Language tricks
def greet(implicit name: String) = "Hello" + name
implicit val n = "Joe"
greet

Functional features
● Functional data types
● Tail recursion
● Immutability
● Higher-order functions
● Currying
● Pattern matching
● Lazy evaluation

Functional data types
val l = 1 :: 2 :: 3 :: Nil
// List(1, 2, 3)
l.head // 1
l.tail // List(2, 3)
l.isEmpty // false s.c.i
Nil
s.c.i
::[T]
List[+T]

Functional data types
val l = 1 :: 2 :: 3 :: Nil
val l2 = 0 :: l
1 2 3 Nil
0

Imperative example
def concat(list: List[Any]): String = {
}

Imperative example
def concat(list: List[Any]): String = {
val iter = list.iterator
var result = ""
while (iter.hasNext) {
result += iter.next
}
result
}

Tail recursion
def concat(l: List[Any]): String =
if (l.isEmpty)
else

Tail recursion
if (l.isEmpty)
""
else
l.head + concat(l.tail)

Tail recursion
def concatT(s: String, list: List[Any]): String =
if (list.isEmpty)
s
else
concatT(s + list.head, list.tail)

Tail recursion
def concat(l: List[Any]): String = {
@tailrec
def concatT(s: String, list: List[Any]): String =
if (list.isEmpty)
s
else
concatT(s + list.head, list.tail)
concatT("", l)
}

Pattern matching
l match {
case Nil =>
case head :: tail =>
}

Pattern matching
l match {
case Nil => ""
case head :: tail =>
head + concat(tail)
}

Lazy evaluation
lazy val now = new Date // 13:52:24
now // 13:55:05

Lazy evaluation
def debug(on: Boolean, msg:=> String) = {
if (on) {
doSomething(msg)
}
}

Lazy evaluation
val numbers = Stream.from(0)
numbers.take(5).toArray
// Array[Int](0, 1, 2, 3, 4)

Higher-order functions
val l = List(1, 2, 3, 4, 5)
l.map(el => el + 1)
// List(2, 3, 4, 5, 6)

val l = List(1, 2, 3, 4, 5)
l.filter(el => el % 2 == 0)
// List(2, 4)

val l = List(1, 2, 3, 4, 5)
l.foreach{ el => print(el) }
// 12345

Currying
def sum(x: Int)(y: Int) = x + y
sum(4)(5)

Currying
val l = List(1, 2, 3, 4, 5)
list.fold(0) { (a, b) =>
a + b
}

Currying
def tx[A](block: Session => A)
(implicit ctx: Context)

Currying
import scalikejdbc._
val statement = …
DB.tx { session =>
SQL(statement).execute
}

flatMap
class C[T]
def map[R](block: T => R): C[R] = …
def flatMap[R](block: T => C[R]): C[R] = …

flatMap
val l1 = List(1, 2, 3)
val l2 = List("a", "b")
l1.flatMap{ el1 =>
l2.map{ el2 => el1 + el2 }
}
// 1a, 1b, 2a, 2b, 3a, 3b

Monads
A monad is just a monoid
in the category of endofunctors
What's the problem?

for expressions
● map
● flatMap
● filter
● foreach*

for expressions
l1.flatMap { el1 =>
l2.map { el2 => el1 + el2 }
}

for expressions
l1.flatMap { el1 =>
l2.map { el2 => el1 + el2 }
}
for {
el1 <- l1
el2 <- l2
} yield el1 + el2

Stream
Stream[+T]
scala.collection
Traversable[+T]

Stream
val even = for {
num <- numbers if num % 2 == 0
} yield num

Option
isDefined: Boolean
get: T
getOrElse[T](default: T): T
scala
None
scala
Some[+T]
scala
Option[+T]

Option
def lookup(login: String, password: String):
Option[User]
val maybeUser: Option[User] = …

Option
maybeUser.map { user =>
user.name
}.map { name =>
"Welcome back," + name
}.getOrElse("Hi")
Option[User]
Option[String]
Option[String]
String
map
map
getOrElse

Option
for {
user <- maybeUser
name <- Some(user.name)
} yield
"Welcome back," + name

Try
def parse(json: Js): String
try {
parse(js)
}
catch {
case e: Exception => …
}

Try
def parse(js: Js): String
val nameT = Try {
parse(js)
}
val maybeName = nameT.toOption
scala.util
Failure[+T]
scala.util
Success[+T]
scala.util
Try[+T]

Try
def parse(js: Js): String
def store(name: String): Int
for {
name <- Try(parse(json))
id <- Try(store(name))
} yield id
scala.util
Failure[+T]
scala.util
Success[+T]
scala.util
Try[+T]

Future
def query(q: String): List[String]
val resF = Future { query(q) }
resF.onSuccess {
case list => …
}
resF.onFailure {
case ex => …
}
scala.concurrent
Future[+T]

Future
def query(q: String): List[String]
def store(l: List[String]): Int
queryF.onSuccess {
case list => {
val storeF = Future { store(list) }
storeF.onSuccess { case id => … }
}
}
scala.concurrent
Future[+T]

Future
val resultsF = Future{ query("WTF") }
for {
results <- resultsF
id <- Future{ store(results) }
} yield id
scala.concurrent
Future[+T]

Wait... there’s more!
● object-oriented programming
● arcane things
● actors
● ecosystem
● tools and frameworks

The book
● Suited for people with no prior
experience in Scala
● Includes functional programming tutorial
● Focuses on Play 2.5
● ScalikeJDBC, MacWire, Akka
● Webpack, Sass, React, EcmaScript 6

Demystifying functional programming with Scala

More Related Content

What's hot

Similar to Demystifying functional programming with Scala

Recently uploaded

Demystifying functional programming with Scala