Demystifying functional programming with Scala

An overview of Scala, a brief look at its functional features including higher order functions, monads, currying etc.

Transcript

1. Scala functional 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 - Play 2.0 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: String = { id + ". " + name } } scala> new User(1, "Simon")
13. Objects object User { }
14. Objects object User { def apply(id: Int, name: String): User = new User(id, name) } scala> User.apply(2, "Bob")
15. Objects object User { def apply(id: Int, name: String): User = 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 { implicit 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): Try[String] def store(name: String): Try[Int] for { name <- parse(json) id <- 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.onComplete { case Success(list) => … case Failure(th) => … } scala.concurrent Future[+T]
56. Future def query(q: String): Future[List[String]] def store(l: List[String]): Future[Int] def notify(i: Int): Future[Unit] queryF.flatMap { list => store(list).flatMap { index => notify(index) } } scala.concurrent Future[+T]
57. Future val googleF = Future { query("WTF") } Val bingF = Future { query("WTF") } for { google <- googleF bing <- bingF } yield process(Seq(google, bing)) 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.7 • ScalikeJDBC, MacWire, Akka • Webpack, Sass, React, EcmaScript 6
60. Questions?