This document provides an introduction to functional programming concepts using Scala. It defines functional programming as a programming paradigm focused on pure functions without side effects. It contrasts imperative programming which can contain side effects. Key functional programming concepts discussed include referential transparency, where expressions will always evaluate to the same result given the same inputs; avoiding mutable state; and using functions as first-class citizens that can be assigned to variables or passed as arguments. Benefits highlighted are improved composability, testability, parallelization and optimization of functional code. The document provides examples of functional programming in Scala including using high-order functions and anonymous functions.

1. Teach Yourself some
Functional Programming
with Scala
@DamianJureczko

2. Agenda
What is Functional Programming?
Key concepts of Functional Programming

3. Functional Programming?
Programming Paradigm
Style

4. There are others
Imperative
Object-oriented
...

5. Functional Programming is about
pure functions
no side effects

6. Imperative vs. Functional

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 ✓
val users = List(User("John", 35), User("Michael", 27))
val count = users.count(user => user.age > 30)

9. Referential transparency
“An expression is said to be referentially
transparent if it can be replaced with its
corresponding value without changing
the program's behavior.“

10. Referentially transparent function
returns the same value for same arguments
has no side effects

11. The same result for same arguments ✓
def inc(x: Int): Int = x + 1
val two = inc(1)

12. Result can be different for same arguments ✗
def crazyInc(x: Int): Int = x + Random.nextInt()
val whoKnows = crazyInc(1)

13. Result depends on some global, mutable state ✗
var userCount = ???
def getUserCount: Int = userCount

14. Function without side effects
Result: x = 8
def add(x: Int, y: Int): Int = x + y
val x = add(1, 1) * add(2, 2)

15. We can change it to ✓
Result: x = 8
val x = add(1, 1) * 4

16. We can change it to ✓
Result: x = 8
val x = 2 * 4

17. Function with side effects
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 change it to ✗
Result: x = 8, totalSum = 2
val x = weirdAdd(1, 1) * 4

19. We cannot change it to ✗
Result: x = 8, totalSum = 0
val x = 2 * 4

20. Pure functions are referentially
transparent

21. Functional Programming
What are the 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 can use 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. Function object
Anonymous function
x => x + 1

25. Assigning function to variable
val inc: Int => Int = x => x + 1
val inc: Transformation = x => x + 1
val two = inc(1)

26. High-order functions
take other functions as argument
return functions as result

27. Passing function to high-order function
val count = users.count(user => user.age > 30)
def count(p: User ⇒ Boolean): Int

28. Returning function from high-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 is here
It simplifies your life
It makes you a better developer
Scala is a good way to start

30. Thank You
@DamianJureczko