For simple cases, the end result of no typeclasses can be compelling sometimes.
For larger cases, taking away that useful tool to wrangle inherent complexity usually results in more complexity taking the form of gobs more simple code that obsfucates the task at hand.
It is penny-wise in that it saves some code, but pound-foolish in that it makes maintenance harder.
Why? Because when you have an abstraction, your code, possibly in many places, depends on it. Now if you need to make a change, you will need to understand both the abstraction, and your "instance" of it.
Well no rather you need to understand ALL instances of that abstraction, to know that if you change the abstraction you are not breaking ANY of its uses.
Penny-wise and pound-foolish in many cases.
Abstraction is (generally) an investment in the long term health of your system, whether you, the dev, can justify the costs to higher ups or not is usually a pretty big part of the question. But, if there are legitimately abstractable things you can abstract please do abstract them (and add tests over everything).
Don't forget the Opportunity Costs. If you spend much time abstracting, it is less time actually producing something that helps the users of the application.
Now if your business is maintaining an existing application it makes sense you should invest in making its maintenance easier.
But if you are programming a new application you want to get it in production fast, so that you can learn about what needs to be different about it.
I would say that the time to think about maintenance is mostly when you are in the maintenance stage, because of the huge benefit of getting early feedback,
> I want an FP ecosystem that's not rooted in research
Erlang is rooted in practicality. https://www.youtube.com/watch?v=7AJR66p5E4s&t=180s
Elm lacks typeclasses, yet I've found this lack is what keeps a lot of libraries at bay that would have otherwise turned out overly abstract (see any mainstream Haskell library, really). It's the same reasoning behind Go: With great power comes great responsibility. At large, programmers shoot their own feet with powerful languages. Therefore, take away their guns, ie make languages less powerful. I still wish there was something like Elm, but tailored for backend/network programming: https://news.ycombinator.com/item?id=21909087