getDocsBatch for bulk processing

[Anton-Latukha]

A branch from: #2349

Holds a relevant getDocsBatch code to make bulk requests.

TODO:

• error -> exception handling code
• Maps be Strict
• Recompose (functor law & firsts can be flattened)
• Wire it in

Besides that - can not find the better-optimized version, I hope that swap ... swap & tuple passing et al. optimizes/fuses away by GHC (which should).

Also - after functor laws are applied - count the number of traverses through the [] & weigh it for a number of batch requests.

---

Currently in master primary use of getDocsBatch is: getDocumentationTryGhc that runs singleton element doc on: getDocumentationsTryGhc that runs getDocsBatch on singleton.

getDocsBatch internally has a modified (with removed interactive check) copy of GHCs getDocs. If that internal 1-elem non-interactive function is needed - it probably needs to be getDocsNonInteractive & so be module scope.

And then getDocsBatch is designed for what it is intended - a bulk [Name] requests.

Then I went further: if getDocsBatch would be used really in batch mode - why is to do getDocsBatch on getDocsNonInteractive - that searches & loads module interface on each element:

So, currently I do in getDocsBatch:

Load [Name].

For each Name get module it says being part of.

Then group all Names by according Module: [(Module, [Name])].

Then load module interface once & process through it in bulk [Name]s that are in that module.

For current way function is used (singleton retrieval) that would introduce + C steps for retrieval (that may be specialized-away by the compiler).

If HLS starts bulking retrieval from GHC interfaces based on [Name] - that would be optimal way.

[Anton-Latukha]

From https://gitlab.haskell.org/ghc/ghc/-/issues/20831#note_398227:

I looked at the HLS code and you should probably rather use:
initIfaceLoad hsc_env (loadSysInterface "docs" module)
to load the interface rather than calling initTc.
Then that will cache the loaded interface so you don't load it multiple times from disk.

[Anton-Latukha]

(code currently is created so that it loads & opens interfaces once, but if I understand it right - the mentioned method caches interfaces between function runs).