The document discusses functional programming in Scala within an object-oriented context, highlighting concepts like pure functions, immutability, and static typing. It provides code examples illustrating the syntax, data types, pattern matching, and higher-order functions, comparing them with traditional object-oriented languages like Java. It also touches on practical programming techniques such as using options, recursion, and quicksort algorithms.

1. Scala
Functioneel programmeren
in een object geörienteerde wereld
Werner Hofstra

2. Over mij
• Werner Hofstra
• Software dev @ Enshore
• Java, Scala, Clojure, …

3. Wie is bekend met
• Java
• Object georiënteerd programmeren
• Functioneel programmeren
• Scala

4. Functioneel programmeren
• Focus op (pure) functies
• Vermijden van side effects
• Immutability
• Vermijden van (re)assignment

5. Scala
• Static typing
• Object georiënteerd
• Functioneel
• Compileert naar Java bytecode
• Pattern matching

6. Beloftes
• Elegant
• Expressief
• Concurrency
• Samensmelten OO en FP

7. Wie gebruikt Scala?

8. Syntax
object Sounds extends App {
Animal dog = new Dog("Beike")
println(s"Dog: ${dog.name}")
println(dog.makeSound)
}
trait Animal {
def makeSound: String
}
class Dog(val name: String) extends Animal {
override def makeSound: String =
s"$name says WOOF!"
}
public class Sounds {
public static void main(String[] args) {
Animal dog = new Dog("Beike");
System.out.println("Dog: " + dog.getName());
System.out.println(dog.makeSound());
}
}
interface Animal {
String makeSound();
}
class Dog extends Animal {
private String name;
public Dog(String name) {
this.name = name;
}
@Override public String makeSound() {
return getName() + " says WOOF!";
}
public String getName() {
return name;
}
}

9. Basis
• var
• val
• def
• if
• for
• while
val fordTColor = "Black"
var peugeotColor = "Blue"
peugeotColor = "Gray"
val ferrariColor =
if (ferrari.isRed) "Red"
else "Yellow"
val colors = Array(
"Blue",
"Black",
"Gray",
"White",
)
def printAllColors: Unit = {
for (color <- colors) {
println(color)
}
}

10. Waarden en
variabelen
• variable
• value
val one = 1
one = 2 // Compileert niet
val oneToFive = 1 to 5
val twoToSix = oneToFive map { _ + 1 }
var two = 2
two = 1 // Ok, maar raar

11. Immutability
• 4 + 5 = 9
• 4 += 1
• Math.pi = 0
• werner = peter
• Time.now() += 2 hours

12. Object
Oriented
Programming
• Alles is een object
1 + 2
1.+(2)
"hello".endsWith("lo")
"hello" endsWith "lo"

13. Object Oriented
Programming
• Alles is een object
• Classes
class Person(val name: String, val age: Int)

14. Object Oriented
Programming
• Alles is een object
• Classes
• Traits
class Person(val name: String, val age: Int)
trait InsaneSkills {
def listSkills: List(String)
}

15. Object Oriented Programming
• Alles is een object
• Classes
• Traits
• Inheritance
class Person(val name: String, val age: Int)
trait InsaneSkills {
def listSkills: List(String)
}
class Programmer(
override val name: String,
override val age: Int,
language: String)
extends Person(name, age)
with InsaneSkills {
def listSkills = List(
s"Programming ${language}",
"Giving talks")
}

16. Traits
• Interfaces
• Implementaties
• Mixins
trait Logger {
def log(msg: String): Unit = {}
}
trait PrintLogger extends Logger {
override def log(msg: String): Unit =
println(msg)
}
class CoffeeMaker extends Logger {
def brew(kind: String): Unit =
log(s"Brewing coffee: $kind")
}
val silently = new CoffeeMaker
silently brew "espresso"
// (geen output)
val loudly = new CoffeeMaker with PrintLogger
loudly brew "espresso"
// Brewing coffee: espresso

17. Singletons
• Slechts 1 instantie
• Voor static methoden
• Geen constructor args
object MyRandom {
import scala.util.Random
def nextIntBetween(from: Int, to: Int): Int =
Random.nextInt(to - from) + from
}

18. Types
• Type inference
• Static types
// hello :: String
val hello = "Hello"
// world :: String
val world: String = "World"
// strings :: List[String]
val strings = List(hello, world)
// werner :: Programmer
val werner = new Programmer(
"werner",
28,
"Scala")

19. Tuples
// tuple :: (Int, String)
val tupleOne = (1, "one")
// tupleTwo :: (Programmer, (Int, String))
val tupleTwo = (werner, tupleOne)

20. Functies
• ‘First class citizens’
• Hebben ook types
// addOne :: Int => Int
def addOne(x: Int) = x + 2
// addLengths :: (String, String) => Int
def addLengths(s1: String, s2: String) =
s1.length + s2.length
// addLengths2 :: String => (String => Int)
def addLengths2(s1: String)(s2: String) =
s1.length + s2.length

21. Anonieme
functies
• Functies zonder naam
• Handig voor HOF
val add =
(x: Int, y: Int) => x + y
add(1, 2)
// 3

22. Hogere orde
functies
• Functies in argumenten
• Functies uit functies

23. Hogere orde functies
• Functies uit functies
// makeAdder :: Int => (Int => Int)
val makeAdder = {
x: Int => {
y: Int => x + y
}
}
// add5 :: Int => Int
val add5 = makeAdder(5)
// eleven :: Int
val eleven = add5(6)
// 11

24. Hogere orde functies
• Functies uit functies
• Functies in argumenten
def foreach(fn: Int => Unit, xs: List[Int]) =
for (x <- xs) fn(x)
foreach(println, List(1, 2, 3))

25. Hogere orde functies
val strings = List("one", "two", "three")
strings map { str => str.toUpperCase }
// List("ONE", "TWO", "THREE")
strings filter { _.length == 3 }
// List("one", "two")
strings.foldLeft("zero") { _ + " " + _ }
// "zero one two three"
strings foreach println
// ()

26. Hogere orde functies
val strings = List("one", "two", "three")
val numbers = List(1, 2, 3)
(numbers zip strings).toMap
// Map(1 -> "one", 2 -> "two", 3 -> "three")
strings partition { _.length < 4 }
// (List("one", "two"), List("three"))
strings takeWhile { _.length < 4 }
// List("one", "two")
strings dropWhile { _.length < 4 }
// List("three")

27. Pattern
matching
• Switch on steroids
1 match {
case 1 => "one"
case 2 => "two"
}
// "one"
(1, "one") match {
case (2, string) => "first"
case (1, string) => "second"
case (_, "one") => "third"
case (1, "one") => "fourth"
case _ => "no match"
}

28. Pattern matching
sealed trait Job
case object Sales extends Job
case object Boss extends Job
case class Programmer(lang: String) extends Job
case class Employee(name: String, job: Job)
val henry = Employee("Henry", Programmer("Scala"))
val james = Employee("James", Boss)
val peter = Employee("Peter", Sales)
henry.job match {
case Boss => "bossing around"
case Sales => "selling stuff"
case Programmer(lang) => s"programming $lang"
}

29. null
new Garage().getCar(“Ferrari”)
.navigationSystem()
.routeTo("Berlin")
.plan();

30. null
RoutePlan plan = null;
Car car = new Garage().getCar("Ferrari");
if (car != null) {
NavSystem nav = ferrari.navSystem();
if (nav != null) {
Route route = nav.routeTo("Berlin");
if (route != null) {
plan = route.plan();
}
}
}

31. Option
• Geeft aan dat iets optioneel is
• Trait
• Case classes: Some(x: Any), None

32. null vs Option
val garage = new Garage()
val routePlan = for {
//Car <- Option[Car]
car <- garage.getCar("Ferrari")
//NavSystem <- Option[NavSystem]
nav <- car.navigationSystem
//Route <- Option[Route]
route <- nav.routeTo("Berlin")
//RoutePlan <- Option[RoutePlan]
plan <- route.plan
//RoutePlan -> Option[RoutePlan]
} yield plan

33. null vs Option
val garage = new Garage()
val routePlan = for {
car <- garage.getCar("Ferrari")
nav <- car.navigationSystem
route <- nav.routeTo("Berlin")
plan <- route.plan
} yield plan

34. QuickSort
• Sorteeralgoritme
• O(n log n) performance

35. QuickSort
• Neem een lijst met getallen
• Neem een getal ‘x’ uit deze lijst
• Uit de rest van de lijst:
• Zet de getallen lager dan ‘x’ voor ‘x’ en sorteer
• Zet de getallen hoger dan ‘x’ na ‘x’ en sorteer

36. QuickSort
• Recursieve functie
• Base case: Lege lijst
• Andere cases: Niet-lege lijst
• Manier om lijst op te delen o.b.v. predikaat
• Hogere orde functies!

37. QuickSort
• Lijst: [5, 3, 10, 7, 1]
• x: 5, rest: [3, 10, 7, 1]
• sort([3, 1]) 5 sort([10, 7])

38. QuickSort
• [3, 1]
• x: 3, rest: [1]
• sort([1]) 3 sort([])

39. QuickSort
• [1]
• x: 1, rest: []
• sort([]) 1 sort([])
• [] 1 []
• [1]

40. QuickSort
• [3, 1]
• x: 3, rest: [1]
• sort([1]) 3 sort([])
• [1] 3 []
• [1, 3]

41. QuickSort
• Lijst: [5, 3, 10, 7, 1]
• x: 5, rest: [3, 10, 7, 1]
• sort([3, 1]) 5 sort([10, 7])
• [1, 3] 5 sort([10, 7])
• [1, 3] 5 [7, 10]
• [1, 3, 5, 7, 10]

42. QuickSort
def qsort(ints: List[Int]): List[Int] =
ints match {
case Nil => Nil
case head :: tail => {
val (lower, higher) = tail partition { _ < head }
qsort(lower) ++ (head :: qsort(higher))
}
}

43. QuickSort
def qsort(ints: List[Int]): List[Int] =
ints match {
case Nil => Nil
case head :: tail => {
val (lower, higher) = tail partition { _ < head }
qsort(lower) ++ (head :: qsort(higher))
}
}

44. QuickSort
def qsort(ints: List[Int]): List[Int] =
ints match {
case Nil => Nil
case head :: tail => {
val (lower, higher) = tail partition { _ < head }
qsort(lower) ++ (head :: qsort(higher))
}
}

45. QuickSort
def qsort(ints: List[Int]): List[Int] =
ints match {
case Nil => Nil
case head :: tail => {
val (lower, higher) = tail partition { _ < head }
qsort(lower) ++ (head :: qsort(higher))
}
}

46. QuickSort
def qsort(ints: List[Int]): List[Int] =
ints match {
case Nil => Nil
case head :: tail => {
val (lower, higher) = tail partition { _ < head }
qsort(lower) ++ (head :: qsort(higher))
}
}

47. QuickSort
def qsort(ints: List[Int]): List[Int] =
ints match {
case Nil => Nil
case head :: tail => {
val (lower, higher) = tail partition { _ < head }
qsort(lower) ++ (head :: qsort(higher))
}
}

48. Vragen?