Download to read offline
More Related Content
Similar to Teach Yourself some Functional Programming with Scala
Teach Yourself some Functional Programming with Scala
- 1. Teach Yourself some FunctionalProgramming with Scala @DamianJureczko
- 2. Agenda What is FunctionalProgramming? Key concepts of Functional Programming
- 3.
- 4.
- 5. Functional Programming isabout pure functions no side effects
- 6.
- 7. Imperative example ✗ List<User>users = new ArrayList<>(); users.add(new User("John", 35)); users.add(new User("Michael", 27)); int count = 0; for (User user : users) { if (user.getAge() > 30) { count += 1; } }
- 8. Functional example ✓ valusers = List(User("John", 35), User("Michael", 27)) val count = users.count(user => user.age > 30)
- 9. Referential transparency “An expressionis said to be referentially transparent if it can be replaced with its corresponding value without changing the program's behavior.“
- 10. Referentially transparent function returnsthe same value for same arguments has no side effects
- 11. The same resultfor same arguments ✓ def inc(x: Int): Int = x + 1 val two = inc(1)
- 12. Result can bedifferent for same arguments ✗ def crazyInc(x: Int): Int = x + Random.nextInt() val whoKnows = crazyInc(1)
- 13. Result depends onsome global, mutable state ✗ var userCount = ??? def getUserCount: Int = userCount
- 14. Function without sideeffects Result: x = 8 def add(x: Int, y: Int): Int = x + y val x = add(1, 1) * add(2, 2)
- 15. We can changeit to ✓ Result: x = 8 val x = add(1, 1) * 4
- 16. We can changeit to ✓ Result: x = 8 val x = 2 * 4
- 17. Function with sideeffects Result: x = 8, totalSum = 6 var totalSum = 0 def weirdAdd(x: Int, y: Int): Int = { val sum = x + y totalSum += sum sum } val x = weirdAdd(1, 1) * weirdAdd(2, 2)
- 18. We cannot changeit to ✗ Result: x = 8, totalSum = 2 val x = weirdAdd(1, 1) * 4
- 19. We cannot changeit to ✗ Result: x = 8, totalSum = 0 val x = 2 * 4
- 20. Pure functions arereferentially transparent
- 21. Functional Programming What arethe benefits? compositionality (divide & conquer, generalize, reuse) code easier to reason about code easier to parallelize code easier to optimize (memoization) code easier to test
- 22. First-class functions We canuse functions like we use other types assign to variable pass to function (as argument) return from function
- 23. Function type Int =>Int type Transformation = Int => Int
- 24.
- 25. Assigning function tovariable val inc: Int => Int = x => x + 1 val inc: Transformation = x => x + 1 val two = inc(1)
- 26. High-order functions take otherfunctions as argument return functions as result
- 27. Passing function tohigh-order function val count = users.count(user => user.age > 30) def count(p: User ⇒ Boolean): Int
- 28. Returning function fromhigh-order function def makeUserFilterByAge(threshold: Int): User => Boolean = user => user.age > threshold val userOlderThen30: User => Boolean = makeUserFilterByAge(30) val count = users.count(userOlderThen30)
- 29. Summary Functional programming ishere It simplifies your life It makes you a better developer Scala is a good way to start
- 30.