Avoid Haddock-links to the Prelude

If you're generating documenatation that links to the base package, you will see that some links to standard types go to the Prelude and some to the hierarchical libararies. For example, Int goes to Prelude.Int, while Either goes to Data.Either.Either.

This happens because the Prelude imports some types from the hierarchical libraries, while some are imported directly from internal GHC modules (e.g. GHC.Base). In the first case, the hierarchical module is choosen as the best place to link to since it's closer than the Prelude in the topological sort to the original module. In the latter case, the hierarchical module and the Prelude are of equal number of imports away from the original module, so none is considered a better place to link to. In this case one of the modules is arbitrarily chosen and it happens to be the Prelude.

I think it would be nice if the links would always go to the hierarchical libraries. Maybe the best way to achieve that would be to add {-# OPTIONS_HADDOCK NotHome #-} to the Prelude. This flag is not yet documented (I should get around to that). It tells Haddock to prefer linking to another module if one is available.

Desired Home modules

Desired Home Modules

I'm using this format where NEW means the home module doesn't currently export this entity:

Desired.Home.Module
===================
a
b
NEW c

Control.Monad
=============
GHC.Base.=<<


Data.Bool
=========
GHC.Classes.&&
GHC.Classes.not
GHC.Classes.||

NEW Data.Bounded
=============
GHC.Enum.Bounded
  { GHC.Enum.maxBound
  , GHC.Enum.minBound }


NEW Data.Enum
=========
GHC.Enum.Enum
  { GHC.Enum.enumFrom
  , GHC.Enum.enumFromThen
  , GHC.Enum.enumFromThenTo
  , GHC.Enum.enumFromTo
  , GHC.Enum.fromEnum
  , GHC.Enum.pred
  , GHC.Enum.succ
  , GHC.Enum.toEnum }


NEW Data.Error
  * Alternatively Control.Exception (for error, errorWithoutStackTrace, undefined)
==========
GHC.Err.error
GHC.Err.errorWithoutStackTrace
GHC.Err.undefined


Data.Function
=============
GHC.Base.($)
GHC.Base.(.)
GHC.Base.id
GHC.Base.flip
GHC.Base.const
NEW GHC.Base.($!)
  * Similar to ($)
NEW GHC.Base.asTypeOf
  * Similar to `const`
NEW GHC.Base.until
  * Meets the modules description of being functions on pure functions.


Data.List
=========
GHC.Base.++
GHC.Base.map
GHC.List.!!
GHC.List.break
GHC.List.cycle
GHC.List.drop
GHC.List.dropWhile
GHC.List.filter
GHC.List.head
GHC.List.init
GHC.List.iterate
GHC.List.last
GHC.List.lookup
GHC.List.repeat
GHC.List.replicate
GHC.List.reverse
GHC.List.scanl
GHC.List.scanl1
GHC.List.scanr
GHC.List.scanr1
GHC.List.span
GHC.List.splitAt
GHC.List.tail
GHC.List.take
GHC.List.takeWhile
GHC.List.unzip
GHC.List.unzip3
GHC.List.zip
GHC.List.zip3
GHC.List.zipWith
GHC.List.zipWith3


NEW Data.Seq
  * This module seems a bit too empty
=====================================
GHC.Prim.seq


NEW Numeric.Integral
  * Why not Data.Integral?
==========================
GHC.Real.Integral
  { GHC.Real.div
  , GHC.Real.divMod
  , GHC.Real.mod
  , GHC.Real.quot
  , GHC.Real.quotRem
  , GHC.Real.rem
  , GHC.Real.toInteger }
GHC.Real.even
GHC.Real.gcd
GHC.Real.lcm
GHC.Real.odd



TODO pick a home module for these entities
==========================================
GHC.Base.Applicative{GHC.Base.*>, GHC.Base.<*, GHC.Base.<*>, GHC.Base.pure}
GHC.Base.Functor{GHC.Base.<$, GHC.Base.fmap}
GHC.Base.Monad{GHC.Base.>>, GHC.Base.>>=, GHC.Base.return}
GHC.Base.Monoid{GHC.Base.mappend, GHC.Base.mconcat, GHC.Base.mempty}
GHC.Base.otherwise
GHC.Base.Semigroup{GHC.Base.<>}
GHC.Base.String
GHC.Classes.Eq{GHC.Classes./=, GHC.Classes.==}
GHC.Classes.Ord{GHC.Classes.<, GHC.Classes.<=, GHC.Classes.>, GHC.Classes.>=, GHC.Classes.compare, GHC.Classes.max, GHC.Classes.min}
GHC.Float.Floating{GHC.Float.**, GHC.Float.acos, GHC.Float.acosh, GHC.Float.asin, GHC.Float.asinh, GHC.Float.atan, GHC.Float.atanh, GHC.Float.cos, GHC.Float.cosh, GHC.Float.exp, GHC.Float.log, GHC.Float.logBase, GHC.Float.pi, GHC.Float.sin, GHC.Float.sinh, GHC.Float.sqrt, GHC.Float.tan, GHC.Float.tanh}
GHC.Float.RealFloat{GHC.Float.atan2, GHC.Float.decodeFloat, GHC.Float.encodeFloat, GHC.Float.exponent, GHC.Float.floatDigits, GHC.Float.floatRadix, GHC.Float.floatRange, GHC.Float.isDenormalized, GHC.Float.isIEEE, GHC.Float.isInfinite, GHC.Float.isNaN, GHC.Float.isNegativeZero, GHC.Float.scaleFloat, GHC.Float.significand}
GHC.Integer.Type.Integer
GHC.IO.Exception.ioError
GHC.IO.Exception.IOError
GHC.IO.Exception.userError
GHC.IO.FilePath
GHC.Maybe.Maybe{GHC.Maybe.Just, GHC.Maybe.Nothing}
GHC.Num.Num{GHC.Num.*, GHC.Num.+, GHC.Num.-, GHC.Num.abs, GHC.Num.fromInteger, GHC.Num.negate, GHC.Num.signum}
GHC.Num.subtract
GHC.Read.lex
GHC.Read.Read{GHC.Read.readList, GHC.Read.readsPrec}
GHC.Read.readParen
GHC.Real.^
GHC.Real.^^
GHC.Real.Fractional{GHC.Real./, GHC.Real.fromRational, GHC.Real.recip}
GHC.Real.Integral{GHC.Real.div, GHC.Real.divMod, GHC.Real.mod, GHC.Real.quot, GHC.Real.quotRem, GHC.Real.rem, GHC.Real.toInteger}
GHC.Real.Rational
GHC.Real.Real{GHC.Real.toRational}
GHC.Real.RealFrac{GHC.Real.ceiling, GHC.Real.floor, GHC.Real.properFraction, GHC.Real.round, GHC.Real.truncate}
GHC.Real.realToFrac
GHC.Show.Show{GHC.Show.show, GHC.Show.showList, GHC.Show.showsPrec}
GHC.Show.showChar
GHC.Show.showParen
GHC.Show.shows
GHC.Show.ShowS
GHC.Show.showString
GHC.Types.Bool{GHC.Types.False, GHC.Types.True}
GHC.Types.Char
GHC.Types.Double
GHC.Types.Float
GHC.Types.Int
GHC.Types.IO
GHC.Types.Ordering{GHC.Types.EQ, GHC.Types.GT, GHC.Types.LT}
GHC.Types.Word

Trac metadata

Trac field	Value
Version	6.12.1
Type	Bug
TypeOfFailure	OtherFailure
Priority	normal
Resolution	Unresolved
Component	Documentation
Test case
Differential revisions
BlockedBy
Related
Blocking
CC
Operating system
Architecture