How to contribute to the Haskell ecosystem
haskellforall.com
haskellforall.com
But you can write an API wrapper without enabling any of them if you'd like, which I guess is what you are saying.
[The analogy is, of course, not precise. Please don't respond as though I am implying it is.]
Many extensions (ExistentialQuantification, Rank2Types, RankNTypes, ScopedTypeVariables, TemplateHaskell) are necessary for writing certain types of code in Haskell. I would not be surprised at all to see them folded into the next official version of the Haskell language.
Others are very convenient but relatively benign syntax sugar (RecordWildCards, TupleSections, OverloadedStrings, LambdaCase, DeriveFoldable, DeriveFunctor, DeriveGeneric, DeriveTraversable). These extensions can obliterate huge amounts of boilerplate that you'd need to write otherwise.
Others are more experimental and will remain as extensions for a while.
I believe I heard that the Haskell Prime effort is going to start again, and a new version of the language will integrate the most important and mature extensions, but I'm not following very closely. https://prime.haskell.org/
Personally I don't have a strong opinion one way or another, but it looks to me like it's contentious enough that it won't be added.
It's also GHC specific so if you're one of those weirdos using a different Haskell compiler you can't use any library that requires TH.
I don't know if this is written down anywhere; it came up in conversation with a committee member.
It's one of those things that you'd probably do if you were starting with a blank slate, but it's not worth breaking existing code for when you can instead get the functionality through an opt-in extension. GHC Haskell's language extensions are pretty nice that way, but it would be nice to standardize the extensions to open the (extended) language back up to alternative implementations.
In this case it's worth noting that the issue is ameliorated by the fact that ScopedTypeVariables can only change the meaning of code that already uses other extensions, since it only affects type variables explicitly listed in a forall, and by default you can't have explicit foralls.
Most of the commonly used extensions are in this vein, similar to Python's "import from future".
While some extensions will get folded into the language, others never will. For a few extensions, it's useful to have an explicit flag telling the compiler that yes, you actually want to do it: some things (like UndecideableInstances and OverloadedInstances) are sometimes useful and sometimes mistakes, so getting people to opt-in explicitly is useful. A few other extensions are too complex and GHC-specific (TemplateHaskell) or usually not used but kept around for backwards compatibility (Rank2Types, ImplicitParameters).
At the same time, I think it's also not as big an issue as people seem to think. For better or for worse, Haskell in practice is currently defined by GHC rather than a formal standard—not too different from other non-standardized languages. From this point of view, language extensions are part of the language proper, just hidden behind a flag. This is useful since de facto Haskell is a living, fast-changing language, so some way of managing the changes in your own code makes it much easier to keep up. I think of extensions as more like libraries that just happen to need access to the compiler than language extensions per se.
The barest of C bindings, too. A minimal wrapper for memory management is a much better binding than one that hides the raw API behind an abstraction that may or may not be suitable for every use.