Disclaimer: just browsed, didn't do the coding.
- Pure functions and lambdas are mentioned, but I failed to find the word "closure" around.
- Currying is mentioned, but not partial application.
- Surprised to find a chapter on recursion at all. Because:
- It's anything but a distinguishing feature of FP
- Does JS have TCO now? Else I'd consider the claim they're "more powerful than loops" dangerous.
- At any rate, the claim a problem could be "unsolvable using only loops" is downright wrong. Especially in a language as untyped as JS where even mutual recursion is trivial to convert.
- The Tuple as a Functor example features a container-like implementation. It kind of works because the terms and typing are fuzzy, but please be aware it's not the standard one.
- The Functor/Monad intro uses what I jokingly call "the Scala approach" (map/flatMap-based). It's not wrong, but it's a very container-centric intuition, which makes the following less obvious:
- What's the "map" intuition on a promise?
- How could a Functor not be a Monad? (why have separate terms?) (ironically Tuple could have been a counterexample, if defined in another unusual way)
- Why do we go from duplicating array elements to simulating a gambler? Using a function named "flatMap" to boot. What does that have to do with anything?
Tease: you didn't even pretend to define FP
Summary: mostly complete and good contents. A bit harder to get on board with the "what for"; more generally continuity could be improved. Yet another Monad tutorial, such a double-edged sword.
PS: this didn't make me love JS.