Functional programming basics + building a Maybe monad step by step + JavaScript ES6

1. Functional Programming
for the advanced beginner
By
Luis Atencio (@luijar)
https://joind.in/talk/d4540

2. About me (@luijar)
• Author of:
• Functional Programming in JS
• RxJS in Action
• UXDevSummit2018:
• Workshop on FP
• Videos:
• https://www.udemy.com/functional-php-7/

3. Outline
• Beginner
• FP Primer
• Composition
• Curry
• Advanced
• Functors
• Applicatives
• Monads
• Recursion & pattern matching
• Dealing with effects

4. JavaScript
“OO-ish” “FP-ish”

5. “Not Awesome: ES6 Classes”
-Josh Burgess

6. OOP is dead ONLY if FP is dead

7. Paradigm subtraction (abstraction)
Paradigm Mass adoption Subtraction
Modular 1970s Limitless files
Structured 1980s Removes “goto”
Object Oriented 1990s Removes function pointers for
polymorphism
Functional ? Takes away assignment and mutable
state

8. A Primer

9. Background
• Lambda calculus
• Category Theory
• Categorical properties: identity, composition, and morphisms
(functions)
• Algebraic data types: functors, applicatives, monads

10. Basic Principles
• A function is a mapping from one type (A) to another (B) within the
same category of objects
• f :: A -> B
• Everything is a function
• Functions are the main unit of work
• Functions are first-class citizens
• Functions are of higher-order
• Favor expressions vs statements
• Avoid externally visible side effects
• Avoid mutable state

11. Avoid side effects
• Keep changes from leaking
• If you must, move them to the boundaries of your logic
• Manage effects with declarative, lazy containers (e.g. IO monad)

12. Simplest function possible

13. Things you’ll hardly see in FP
• Counted loops or while statements
• If-else conditions (replaced by pattern-matching)
• Ternary operator accepted <condition> ? <expression> : <expression>
• Exceptions thrown
• Global variables passed around and/or referenced within functions
• Long functions (5+ lines)
• Void functions
• Variable re-assignment (e.g count += i )

14. Composition

15. “Simple ideas combine to form complex ideas”
-John Locke

16. Composition: control flow in FP

17. Composition of 2 functions

18. Example: counting words in a file

19. Example: reading words from a file2
In: string
Out: number

20. compose === assemble

21. Assemble all modules

22. Curry

23. Currying is essential for composition
• Partially evaluate functions
• Never evaluate a function with missing data
• Transform multi-arity in to single-arity functions
• Functional languages use auto-currying + lazy evaluation

24. Simple example

25. Sequences of partial function calls

26. Build abstractions over APIs
OR

27. Functors

28. What are Functors
• Functions are mappings from one object to another
• Functors are mappings from one category to another
• Most common is the endofunctor (same categories)
• Functors define a function named map (fmap)

29. What are Functors
• Functions are mappings from one type to another
• Functors are mappings from one context to another
• Most common is the endofunctor (same context)
• Functors define a function named map (fmap)

30. Well-known functor: Array

31. Maybe functor Rudimentary pattern-matching

32. Workings of Maybe Functor

33. Functor/Composition equivalence
• Define map for function types
• Equivalence: map can be derived from compose

34. Applicatives

35. What is an Applicative (functor)
• Functor with extra laws and operations
• Not just wrap values, wrap functions too!
• Implements the Apply interface: ap

36. Maybe Applicative object

37. Workings of an applicative

38. Applicative examples

39. Monads
Applicative + Functor + Effects

40. What is a monad
• Functors apply a function to a wrapped value
• Applicatives apply a wrapped function to a wrapped value
• Monads apply a function that returns a wrapped value to another
wrapped value. Enter flatMap (bind, chain)

41. Maybe Example: object traversal

42. Maybe Example: object traversal2

43. Maybe Example3

44. Back to composition
Point-free coding

45. What about flatMap?

46. A few more monads in the wild
• Algebraic Data Types:
• Either, Maybe, Try, Validation (sum type)
• Tuples, Records, State (product type)
• State management
• Do, State, IO
• Async
• Promise
• Observable
• Dependency Injection
• Reader
• Many more...

47. Recursion & Pattern
Matching

48. Imperative code

49. List Sum

50. List insert

51. Dealing with effects

52. IO: Monads as computations with effects
Keep effects at the boundaries
Keep effects at the boundaries

53. Parting Thoughts
• FP makes code easier to reason
about
• FP is closer to the maths and
propositional logic
• No need for patterns!