Functional

=== currying ===
https://vittorioromeo.info/index/blog/cpp17_curry.html
https://pastebin.com/gUbKVdqX
=== Satire ===
https://elixirforum.com/t/functional-programming-don-t-even-bother-it-s-a-silly-toy/24800
"...t takes at least 20–30 years to get good with OOP. Even then most people with 30 years of OOP experience haven’t truly mastered it. The learning path is rough, filled with uncertainty. A lifetime of learning awaits the OOP developer, how exciting is that?
What about the poor functional programmers? Unfortunately, there’s not much to learn. I have personally taught a few junior developers functional programming in JavaScript, and they became really good at it in about half a year. They simply had to understand a few basic concepts and then learned to apply them pretty quickly. Where’s the thrill of lifetime learning? I wouldn’t envy them..."
=== naildrivin ===
https://naildrivin5.com/blog/2019/07/25/four-better-rules-for-software-design.html#conceptual-overhead-creates-confusion-and-complexity
https://naildrivin5.com/blog/2019/06/29/simple-expressions-only.html
=== dadgum ===
https://prog21.dadgum.com/38.html
http://prog21.dadgum.com/41.html Totals could be switched from a tuple to a tree, which might or might not be better than the setelement code, but there's no way it's in the same ballpark as the C version.
What about a different algorithm? Sort the block of bytes, then count runs of identical values. Again, just the suggestion of sorting means we're already off track.
http://prog21.dadgum.com/36.html It's easy to taint even purely functional languages by reintroducing side-effects. Simply have each function take an additional parameter representing the global state of the world--a tree of key/value pairs, for example--and have each function return a new state of the world. This is not news. It's an intentionally pathological case, not something I'd ever consider implementing. ....Either way, the same side effects possible in imperative languages were accidentally introduced into pure functions.
http://prog21.dadgum.com/189.html If I were writing such a simulation in a functional style, then the fixes listed above would be there from the start. It's a more natural way to work when there aren't mutable data structures. Would it be simpler than the OOP version? Probably not. Even though entity updates are put off until later, there's the question of how to manage all of the change information getting passed around. But at one time I would have thought the functional version a complete impossibility, and now it feels like the obvious way to approach these kinds of problems. 
http://prog21.dadgum.com/131.html
http://prog21.dadgum.com/26.html
=== news ===
https://news.ycombinator.com/item?id=35106340 
https://lawrencecpaulson.github.io/2023/03/08/Fun_Semantics.html
=== links ===
https://www.quora.com/Is-pure-functional-programming-doomed-to-remain-a-niche-esoteric-paradigm-I-know-some-features-of-functional-programming-are-finding-their-way-into-mainstream-languages-e-g-Ruby-Python-but-my-question-refers-to-pure-functional-languages "..4) OOP's underpinning is shared state. Tightly binding code and data and providing subtype polymorphism was an excellent advance in managing complexity. However, it fundamentally depends on having one canonical version of the data (the object) upon which code (methods) operate. .." See https://www.quora.com/Why-dont-pure-functional-programming-languages-provide-a-loop-construct 
----
https://www.quora.com/Why-isnt-functional-programming-that-popular-even-though-its-so-beneficial links to https://www.quora.com/What-are-monads-in-plain-English-Say-for-experienced-imperative-OOP-language-programmers-with-no-or-little-background-in-functional-programming/answer/Max-Fischer-10?ch=10&share=bd7bd3c2&srid=uE9ed and https://www.quora.com/What-is-a-monad/answer/Max-Fischer-10?ch=10&share=d6fcddfb&srid=uE9ed and https://stackoverflow.com/questions/44965/what-is-a-monad/10245311#10245311 What is a monad? The short answer: It's a specific way of chaining operations together. In essence, you're writing execution steps and linking them together with the "bind function". (In Haskell, it's named >>=.) You can write the calls to the bind operator yourself, or you can use syntax sugar which makes the compiler insert those function calls for you. But either way, each by a call to this bind function. So the bind function is like a semicolon; it separates the steps in a process. The bind function's job is to take the output from the previous step, and feed it into the next step. 
https://wiki.haskell.org/IO_inside 
https://homepages.inf.ed.ac.uk/wadler/papers/marktoberdorf/baastad.pdf 
https://stackoverflow.com/questions/2704652/monad-in-plain-english-for-the-oop-programmer-with-no-fp-background/37345315#37345315 Monad is not a datatype. It is a rule of composing functions refs https://wiki.haskell.org/Monad_laws 
https://pastebin.com/nHrV8AFn lambda calculus and category theory 
https://en.wikipedia.org/wiki/J_(programming_language) 
Category:Oop
Category:Pastebin.com