When trying to understand functional programming it's often easy to get lost in a world of mathematical terminology. This is an admittedly incomplete guide to some practical ways to work with functional programming in JavaScript

1. – https://en.wikipedia.org/wiki/Kleisli_category
“In category theory, a Kleisli category is
a category naturally associated to any monad T. It is
equivalent to the category of free T-algebras. The Kleisli
category is one of two extremal solutions to the
question ‘Does every monad arise from an adjunction?’”

2. – https://en.wikipedia.org/wiki/Kleisli_category
“In category theory, a Kleisli category is
a category naturally associated to any monad T. It is
equivalent to the category of free T-algebras. The Kleisli
category is one of two extremal solutions to the
question ‘Does every monad arise from an adjunction?’”

3. Practical Functional
Programming In JavaScript
Ian Thomas (@anatomic) | December 2017

4. –Paul Graham
“Object-oriented programming offers a sustainable way
to write spaghetti code. It lets you accrete programs as
a series of patches.”

6. Why JS? ?

9. -Crockford’s Law (aka The Monadic Curse)
“The Monadic Curse is that once
someone learns what Monads are
and how to use them, they lose
the ability to explain them to
other people”

11. Why Functional
Programming?

12. –Edsger Dijkstra
“Program testing can be a very effective way to show
the presence of bugs, but is hopelessly inadequate for
showing their absence.”

13. –Simon Peyton Jones
“The most depressing thing about life as a programmer, I
think, is if you’re faced with a chunk of code that either
someone else wrote or, worse still, you wrote yourself
but no longer dare to modify. That’s depressing.”

15. What is a function?

16. A function relates each element of a set
with exactly one element of another set
(possibly the same set).

17. What is a higher-order
function?

18. A higher-order function is a function which operates
on another functions, either by taking them as
arguments or returning them

19. Some principals of
functional programming

20. Purity

21. Purity
or, perhaps, why should we avoid impurity?

22. 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.

26. How many tests would you require to adequately check this function?

27. Would it be more than 6?

28. Immutability

29. Immutability goes hand in hand with purity. Returning
copies of data and not manipulating global state means
you can guarantee certain properties and rules will
always hold in your programs.

30. Composition

31. –Ellen Ullman
“We build our computer (systems) the way we build our
cities: over time, without a plan, on top of ruins.”

32. Imagine if you could just build your application by putting
together well tested, easily understood pieces of code in a
declarative manner. Just like building with lego blocks,
composition of pure functions unlocks this ability.

33. https://drboolean.gitbooks.io/mostly-adequate-guide/ch5.html#category-theory

35. Currying

37. Currying is the process of converting a function that
takes multiple arguments into a function that can
take them one at a time

38. Pointfree Style

40. “Pointfree is a good litmus test for functional code as it lets us know we've got
small functions that take input to output. One can't compose a while loop, for
instance. Be warned, however, pointfree is a double-edged sword and can
sometimes obfuscate intention. Not all functional code is pointfree and that is
O.K. We'll shoot for it where we can and stick with normal functions otherwise.”
–Professor Frisby’s Mostly Adequate Guide To Functional Programming

41. Algebraic Data Types

42. Algebraic Data Types

43. –Greg Nelson
“To keep large programs well structured, you either
need superhuman will power, or proper language
support for interfaces.”

44. https://github.com/fantasyland/fantasy-land

45. https://github.com/fantasyland/fantasy-land

46. https://github.com/fantasyland/fantasy-land

47. https://github.com/fantasyland/fantasy-land

48. Better known as….
Array (Functor)
Maybe (Monad)
Either (Monad)
Task/Future (Monad)
Reader (Monad)
State (Monad)
Product (Monoid)
Sum (Monoid)
First (Monoid)
Any (Monoid)
All (Monoid)
Max (Monoid)
Min (Monoid)
Etc.

49. While the mathematical descriptions and terminology
will ultimately prove useful, in many cases knowing
some basic laws is enough.

50. Identity
u.map(x => x) === u

51. Associativity
a.concat(b.concat(c)) === a.concat(b).concat(c)

52. Composition
u.map(x => f(g(x))) === u.map(g).map(f)

53. Stuff I haven’t
covered…

54. Stuff I haven’t
covered…
Transducers
Observables
Lenses
Foldable
Referential Transparency
Applicative
Traversable Isomorphism
Property based testing

55. Practical Example 1
Creating a pure http client

56. Wrap a promise based API using a Future

57. Use Reader to create an API which can ask for config

58. Use Reader pattern to create an API which can ask for config

59. Compose our application run with config

60. Practical Example 2
Generating RequestABet™ Recommendations

61. Customer selects bets
Request is sent to traders
Nearest matches are calculated
Top 4 recommendations shown

62. Given this as an API Response

63. Encapsulate business logic in pure functions

64. Separate out state based operations

65. Compose functionality to produce pipelines of execution

66. Pure Validation

67. Add some monads to handle IO and control flow

68. Demo

69. –Tom Cargill
“The first 90 percent of the code accounts for the first
90 percent of the development time. The remaining 10
percent of the code accounts for the other 90 percent
of the development time.”

70. Ian Thomas (@anatomic) | December 2017
Practical Functional
Programming In JavaScript
https://drboolean.gitbooks.io/mostly-adequate-guide/
https://github.com/getify/Functional-Light-JS
https://medium.com/@lunde.andrews/easing-into-functional-programming-in-javascript-30056bcc49a9
https://fp-bingotron.ian-thomas.net/
http://www.tomharding.me/
https://github.com/fantasyland/fantasy-land
https://staltz.com/is-your-javascript-function-actually-pure.html
https://egghead.io/courses/quickly-transform-data-with-transducers
https://egghead.io/courses/professor-frisby-introduces-composable-functional-javascript
https://www.youtube.com/watch?v=moAfgDFVLUs