The document discusses functional programming concepts including pure functions, higher-order functions, composition, and currying. It provides code examples to demonstrate these concepts, such as implementing functions to add numbers, compose functions, and curry functions to partially apply arguments. The document emphasizes that functional code should be predictable, testable, and avoid side effects by favoring pure functions over mutable data structures and methods with side effects.

1. Functional Programming
for the People

2. Christian Gill
HousingAnywhere

3. A monad in X is just a monoid in the category
of endofunctors of X.
Saunders Mac Lane.
Categories for the Working Mathematician

5. What does it mean
to write functional code?

6. code terse, yet easy to reason about
don't reinvent the wheel
represent problems in terms of generic, composable
bits
benefit from laws

7. First class citizens
(functions are values)

8. const add = (a, b) => a + b
const sum = (x, y) => add(x, y)
sum(1, 2) // 3
const sum = add
sum(1, 2) // 3

9. ;[1, 2, 3].reduce((acc, i) => sum(acc, i), 0)
;[1, 2, 3].reduce(sum, 0)

10. const calculations = [
(w) => w + w,
(x) => x + 1,
(y) => y / 2,
(z) => z * z * z,
]

11. const obj = {
f: (x) => x + 1,
g: (y) => y / 2,
h: (z) => z * z * z,
}

12. Higher-Order Functions

13. ;[1, 2, 3].reduce(sum, 0)
const mult = (a) => (b) => a * b
const by2 = mult(2)
typeof by2 // 'function'
by2(2) // 4
mult(2)(2) // 4

14. const fs = require('fs')
fs.readFile('file.txt', (err, text) => {
if (err) {
console.error('Error:', err)
return
}
console.log('File content: ', text)
})

15. fetch(url)
.then((res) => res.json())
.then(({data}) => console.log(data))

16. Pure functions

17. A pure function is a function that, given the same
input, will always return the same output and does
not have any observable side effect.
Brian Lonsdorf
Mostly adequate guide to FP

18. Math.random() // 0.08140343648722337
Date.now() // 1560981656763

19. splice vs. slice

20. const xs = [1, 2, 3, 4, 5]
xs.splice(0, 3) // [1, 2, 3]
xs.splice(0, 3) // [4, 5]
xs.splice(0, 3) // []
xs // []

21. const xs = [1, 2, 3, 4, 5]
xs.slice(0, 3) // [1, 2, 3]
xs.slice(0, 3) // [1, 2, 3]
xs.slice(0, 3) // [1, 2, 3]
xs // [1, 2, 3, 4, 5]

22. Predictability

23. But what if I want to
(write a file|save to databse|fetch from
server) ?!

25. pure functions === easy tests

26. same input -> same output

27. no observable side effects

28. const saveUser = (user) => Db.save(user)
const saveUser = (Db) => (user) => Db.save(user)
const saveUser = (Db) => Db.save

29. // saveUser :: Db -> User -> Promise User
const saveUser = (Db) => Db.save
// production
const db = connect(config)
const saveUserToDB = saveUser(db)
// testing
const testDB = createTestDB({users: []})
const saveUserTest = saveUser(testsDB)

30. const createTestDB = (obj) => ({
save: (user) => {
obj.users.push(user)
return Promise.resolve(obj.users)
},
})
saveUserTest('Carla') //=> Promise(['Carla'])
saveUserTest('Manu') //=> Promise(['Carla', 'Manu'])

31. Also
Cache
Parallel
Portable
Self-documenting

32. React
f(data) -> view

33. Redux
f(state, action) -> state

34. const add = (a) => (b) => a + b
const inc = add(1) // =)
inc(1) // 2
add(1)(3) // 4 =(

35. const add = (a, b) => a + b
const inc = (b) => add(1, b) // =(
inc(1) // 2
add(1, 3) // 4 =)

36. Currying & Partial Application

37. // live coding - implement curry
const add = (a) => (b) => a + b
const inc = add(1)
inc(10)
add(10)(20)

38. Composition
(f ∘ g)(x) = f(g(x))

39. // live codign - implement compose
// (f ∘ g)(x) = f(g(x))
const compose = () => {}
const head = (xs) => xs[0]
const reverse = (xs) => [...xs].reverse()
const tail = (xs) => head(reverse(xs))
const arr = ['Odessa', 'JS', 'Rocks']
tail(arr)

40. live coding - implement compose3
onst compose = (f, g) => (x) => f(g(x))
onst join = (delim) => (xs) => xs.join(delim)
onst toUpper = (str) => str.toUpperCase()
onst exclaim = (str) => str + '!!!'
onst titlelize = (xs) => exclaim(toUpper(join(' ')(xs)
onst arr = ['Odessa', 'JS', 'Rocks']
tlelize(arr)

41. / live coding - implement generic compose
onst compose = (f, g) => (x) => f(g(x))
onst compose3 = (f, g, h) => (x) => f(g(h(x)))
onst join = (delim) => (xs) => xs.join(delim)
onst toUpper = (str) => str.toUpperCase()
onst exclaim = (str) => str + '!!!'
onst h1 = (str) => '<h1>' + str + '</h1>'
onst titlelize = compose3(exclaim, toUpper, join(' ')
onst arr = ['Odessa', 'JS', 'Rocks']
itlelize(arr)

42. Composition is fractal
operation -> service -> use case -> app

43. { coding time -- small CLI example app }

44. What does it mean
to write functional code?

47. Thλnks!