Intro to functional programming
5 likes3,576 views
The document discusses the limitations of object-oriented programming (OOP) and advocates for a shift to functional programming (FP) due to its mathematical approach, which enhances testability, maintainability, and concurrency handling. It highlights key FP principles such as purity, immutability, and higher-order functions, alongside demonstrating immutable patterns in languages like JavaScript. The document concludes by recommending the use of pure functions, immutable structures, and function composition to create stable and predictable code.
![Simple Immutable
tweaks
arr.push(val) —> [].concat(arr, val)
obj[‘key’] = val —> Object.assign({key: val}, obj)
ImmutableObj = Object.freeze(obj)
** Object assign is limited to shallow cloning and
may produce strange outcomes.
see:
https://developer.mozilla.org/en-US/docs/Web/
JavaScript/Reference/Global_Objects/Object/create](https://image.slidesharecdn.com/introtofunctionalprogramming2-170301075633/85/Intro-to-functional-programming-18-320.jpg)
Intro to functional programming
- 1. Functional Programming by Assaf Gannon
- 2. Why Do We Need to Change The Paradigm?! Object Oriented Programming is Awesome!
- 3. OOP is not cutting it
- 4. Testability Require lots of mocking Extensive environmental setup Hard to maintain as the objects evolve
- 5. Complexity Tendency to over-design Re-Use is often complicated and requires frequent refactoring Often Objects DON’T represent the problem correctly
- 6. Concurrency Objects naturally live in a shared state environment Multiple Objects in a shared state environment handle concurrency poorly
- 8. Why Functional?! Mathematical approach to solving problems More simple and less abstract Easy Reuse, Test and handle Concurrency
- 10. Purity
- 11. Pure Function Pure functions act on their parameters Are not efficient if not returning anything Will always produce the same output for the given parameters Have NO side affects
- 12. Pure Function
- 13. ImPure Functions
- 14. Immutability
- 15. There are no “Variables” in Functional programming - all “variables” should be considered as constants
- 16. When Do we mutate variables? Short living “local” variables Loop flow structures State objects
- 17. Javascript is Not a pure functional programming language - it allows for mutable structures. We need to “tweak” it…
- 18. Simple Immutable tweaks arr.push(val) —> [].concat(arr, val) obj[‘key’] = val —> Object.assign({key: val}, obj) ImmutableObj = Object.freeze(obj) ** Object assign is limited to shallow cloning and may produce strange outcomes. see: https://developer.mozilla.org/en-US/docs/Web/ JavaScript/Reference/Global_Objects/Object/create
- 19. For “real” projects use an immutable library such as ImmutableJS or seamless-immutable
- 21. In Functional Programming, a function is a first-class citizen of the language. In other words: A function is just another value
- 22. Higher Order Functions Take functions as parameters Return functions Both
- 25. A closure is a function’s scope that’s kept alive by a reference to that function.
- 27. newFunc = f(g(x)) Application of one function to the result of another to produce a third function
- 29. A Problem Write a composed function that does text Capitalization: “the FORCE is strong with YOU” —> “The Force Is Strong With You”
- 33. Enhanced Capitalize Problem I want to ignore a list of words: a, is, for, etc. so: “the FORCE is strong with YOU” —> “The Fore is Strong With You”
- 34. This sucks…
- 35. Currying
- 36. A Curried Function is a function that only takes a single parameter at a time.
- 37. Much better :)
- 39. Map Creates a new array with the results of calling a provided function on every element in the array
- 41. Filter Creates a new array with all elements that pass the test implemented by the provided function
- 43. Reduce Applies a function against an accumulator and each value of the array (from left-to-right) to reduce it to a single value
- 45. Summary Use “Pure” functions to create predictable & stable code Use Immutable structs to avoid side effects Compose complex functionality from simple building blocks Use currying for simple composition Avoid “boilerplate” code and loops by using functional functions