## Summary Haddock bundled with GHC >= 9.8 produces much worse output than it used to. Example taken from the `effectful-core` library. Code: ```haskell -- | Provide access to a mutable value of type @s@. data State s :: Effect where Get :: State s m s Put :: s -> State s m () State :: (s -> (a, s)) -> State s m a StateM :: (s -> m (a, s)) -> State s m a type instance DispatchOf (State s) = Dynamic -- | Run the 'State' effect with the given initial state and return the final -- value along with the final state (via "Effectful.State.Static.Local"). runStateLocal :: HasCallStack => s -> Eff (State s : es) a -> Eff es (a, s) runStateLocal s0 = reinterpret (L.runState s0) localState ``` `cabal haddock effectful-core` with GHC 9.6.6 generates this:  So far so good, the output fully reflects the code. Now, here's the result of the same command with GHC 9.8.4:  Problems: 1. `Effect` type synonym in `State` definition unnecessarily expanded. 2. Not respecting names of type variables in GADT constructors as they are in the code. 3. Quantification of all type variables in GADT definitions as well as `runStateLocal` and showing their kinds even though they aren't present in the code. This can be seen in practice on Hackage since it must've started using newer GHC/haddock for generation recently: - Good: https://hackage.haskell.org/package/effectful-core-2.5.1.0/docs/Effectful-State-Dynamic.html - Bad: https://hackage-content.haskell.org/package/effectful-core-2.6.0.0/docs/Effectful-State-Dynamic.html Due to this change definitions are IMO much harder to read now.