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
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://pastebin.com/nHrV8AFn lambda calculus and category theory https://en.wikipedia.org/wiki/J_(programming_language)