The Scala programming language, its history, design choices, syntax basics, functional concepts, monads

1. Scalafunctional programming demystified
@_denisftw_
http://appliedscala.com

2. Roadmap
1. Introduction
2. Language fundamentals
3. Functional programming

3. Users
Twitter (Ruby)
Foursquare (Java/.NET)
Tumblr (PHP)
Guardian (Java)
Klout (PHP)
Coursera (PHP)
LinkedIn*
Netflix* (JVM)

4. 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

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

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

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

8. 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

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

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

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

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

13. Objects
object User {
}

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

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

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

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

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

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

20. 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]
scala.collection.immutable
List[+T]

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

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

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

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

25. Tail recursion
def concat(l: List[Any]): String =
if (l.isEmpty)
""
else
l.head + concat(l.tail)

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

27. 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)
}

28. Pattern matching
def concat(l: List[Any]): String =
l match {
case Nil =>
case head :: tail =>
}

29. Pattern matching
def concat(l: List[Any]): String =
l match {
case Nil => ""
case head :: tail =>
head + concat(tail)
}

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

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

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

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

34. Higher-order functions
val l = List(1, 2, 3, 4, 5)
l.filter(el => el % 2 == 0)
// List(2, 4)

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

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

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

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

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

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

41. 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

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

43. for expressions
● map
● flatMap
● filter
● foreach*

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

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

46. Stream
val numbers = Stream.from(0)
scala.collection.immutable
Stream[+T]
scala.collection
Traversable[+T]

47. Stream
val numbers = Stream.from(0)
val even = for {
num <- numbers if num % 2 == 0
} yield num

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

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

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

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

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

53. 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]

54. 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]

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

56. 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]

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

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

59. 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

60. Questions?