From 9924436acaab976424462eef64be52929d5049e6 Mon Sep 17 00:00:00 2001 From: David Waern Date: Sun, 22 Nov 2009 15:26:41 +0000 Subject: Update test reference output * More links (Int, Float etc) * Stripped link contents --- tests/tests/Bug3.html.ref | 18 +- tests/tests/Bug4.html.ref | 18 +- tests/tests/Bug6.html.ref | 86 +++-- tests/tests/Bugs.html.ref | 12 +- tests/tests/CrossPackageDocs.html.ref | 15 +- tests/tests/GADTRecords.html.ref | 81 ++-- tests/tests/Hash.html.ref | 137 +++---- tests/tests/NoLayout.html.ref | 18 +- tests/tests/QuasiExpr.html.ref | 72 ++-- tests/tests/QuasiQuote.html.ref | 12 +- tests/tests/Test.html.ref | 687 +++++++++++++++------------------- tests/tests/TypeFamilies.html.ref | 42 +-- tests/tests/Visible.html.ref | 13 +- 13 files changed, 509 insertions(+), 702 deletions(-) diff --git a/tests/tests/Bug3.html.ref b/tests/tests/Bug3.html.ref index da2f5291..41d131c0 100644 --- a/tests/tests/Bug3.html.ref +++ b/tests/tests/Bug3.html.ref @@ -23,12 +23,10 @@ >ContentsContentsIndexIndexfoo :: Int
foo :: Int
foo :: Int :: IntProduced by HaddockProduced by Haddock version 2.5.0ContentsContentsIndexIndexfoo :: Int
foo :: Int
foo :: Int :: IntProduced by HaddockProduced by Haddock version 2.5.0ContentsContentsIndexIndexdata A = A Int A = A Intdata B = B B = B {b :: Int
b :: Int
}data C = C C = C {c1 :: Intc2 :: Int
c1 :: Int
c2 :: Int
}data D = D Int Int D = D Int Intnewtype E = E Int E = E IntA Int Intb :: Int :: Intc1 :: Int :: Intc2 :: Int :: IntD Int Int Int IntE Int IntProduced by HaddockProduced by Haddock version 2.5.0ContentsContentsIndexIndexA a (a -> Int) a (a -> Int)Produced by HaddockProduced by Haddock version 2.5.0ContentsIndexIndex
mapmap :: (a -> b) -> [a] -> [b]
class Monad Monad m where
(>>=)(>>=) :: m a -> (a -> m b) -> m b
(>>)(>>) :: m a -> m b -> m b
ContentsContentsIndexIndex
data H1 H1 a b where} -> H1IntInt} -> H1Int a
C1 :: H1C1 :: H1 a b
C2 :: Ord a => [a] -> H1C2 :: Ord a => [a] -> H1 a a
C3C3 :: {field :: Int
field :: Int
} -> H1 Int Int
C4C4 :: {
field2field2 :: a
} -> H1 Int a
C1 :: H1 :: H1 a bC2 :: Ord a => [a] -> H1 :: Ord a => [a] -> H1 a aC3 :: Int -> H1 Int Int :: Int -> H1 Int Intfield :: Int :: Inthello docs C4 :: a -> H1 Int a :: a -> H1 Int aProduced by HaddockProduced by Haddock version 2.5.0ContentsContentsIndexIndex
The The HashTable type
Operations on Operations on HashTables
The The Hash class data HashTable HashTable key valnew :: (Eq key, Hash key) => Int -> IO (HashTablenew :: (Eq key, Hash key) => Int -> IO (HashTable key val)insert :: (Eq key, Hash key) => key -> val -> IOinsert :: (Eq key, Hash key) => key -> val -> IO ()lookup :: Hash key => key -> IO (Maybelookup :: Hash key => key -> IO (Maybe val)class Hash Hash a wherehash :: a -> Int
hash :: a -> Int
key should be an instance of EqEq. new :: (Eq key, Hash key) => Int -> IO (HashTable :: (Eq key, Hash key) => Int -> IO (HashTable key val)insert :: (Eq key, Hash key) => key -> val -> IO :: (Eq key, Hash key) => key -> val -> IO ()lookup :: Hash key => key -> IO (Maybe :: Hash key => key -> IO (Maybe val)Looks up a key in the hash table, returns JustJust val if the key was found, or NothingNothing otherwise. hash :: a -> Int :: a -> Inthashes the value of type a into an IntInt HashFloatHashInt
Hash Float
Hash Int
(Hash a, Hash b) => Hash(Hash a, Hash b) => Hash (a, b)
Produced by HaddockProduced by Haddock version 2.5.0ContentsContentsIndexIndexg :: Int
g :: Int
g :: Int :: IntProduced by HaddockProduced by Haddock version 2.5.0ContentsContentsIndexIndexIntExpr Integer IntegerAntiIntExpr String StringBinopExpr BinOp Expr Expr BinOp Expr ExprAntiExpr String String
Data ExprData Expr
Show ExprShow Expr
Typeable ExprTypeable Expr
Data BinOpData BinOp
Show BinOpShow BinOp
Typeable BinOpTypeable BinOp
eval :: Expr -> Integer :: Expr -> IntegerparseExprExp :: String :: String -> Q ExpProduced by HaddockProduced by Haddock version 2.5.0ContentsContentsIndexIndexval :: Integer :: IntegerProduced by HaddockProduced by Haddock version 2.5.0ContentsContentsIndexIndex
Type declarations +>Type declarations
Data types +>Data types
Records +>Records
Class declarations +>Class declarations
Function types +>Function types
Auxiliary stuff +>Auxiliary stuff
A hidden module +>A hidden module
A visible module +>A visible module
Existential / Universal types +>Existential / Universal types
Type signatures with argument docs +>Type signatures with argument docs
A section +>A section
A subsection +>A subsection
This module illustrates & tests most of the features of Haddock. Testing references from the description: TT, ff, gg, visiblevisible. data T T a b = AInt (MaybeFloat)| B (T a b, TIntFloat)
= A Int (Maybe Float)
| B (T a b, T Int Float)
data T2 T2 a bdata T3 T3 a b
= A1= A1 a
| B1| B1 b
data T4 T4 a b
= A2= A2 a
| B2| B2 b
data T5 T5 a b
= A3= A3 a
| B3| B3 b
data T6 T6
= A4= A4
| B4| B4
| C4| C4
newtype N1 a = N1 N1 a = N1 anewtype N2 a b = N2 N2 a b = N2 {
nn :: a b
newtype N3 a b = N3 N3 a b = N3 {
n3n3 :: a b
data N4 N4 a bnewtype N5 a b = N5 N5 a b = N5 {
n5n5 :: a b
newtype N6 a b = N6 N6 a b = N6 {
n6n6 :: a b
newtype N7 a b = N7 N7 a b = N7 {
n7n7 :: a b
data R R
= C1= C1 {p :: Intr :: Ints :: Int
p :: Int
qq :: forall a. a -> a
r :: Int
s :: Int
}
| C2| C2 {u :: Intv :: Int
t :: T1 -> T2 Int Int -> T3 Bool Bool -> T4 Float Float -> T5t :: T1 -> T2 Int Int -> T3 Bool Bool -> T4 Float Float -> T5 () ()
u :: Int
v :: Int
}		data R1 = C3 R1 = C3 {s1 :: Ints2 :: Ints3 :: Int
s1 :: Int
s2 :: Int
s3 :: Int
}		class D a => C D a => C a where
a :: IOa :: IO a
bb :: [a]
class D D a where
d :: Td :: T a b
ee :: (a, a)
class E E a class F F a where
ffff :: a
f :: C a => a -> Intf :: C a => a -> Intg :: Int -> IOg :: Int -> IO CInthidden :: Int -> Inthidden :: Int -> Intmodule Visiblemodule Visibledata Ex Ex a = forall b . C b => Ex1 b . C b => Ex1 b| forall b . Ex2 b . Ex2 b| forall b . C a => Ex3 b . C a => Ex3 b| Ex4| Ex4 (forall a. a -> a)k :: T () () -> T2 Int Int -> (T3 Bool Bool -> T4 Float Float) -> T5 () () -> IOk :: T () () -> T2 Int Int -> (T3 Bool Bool -> T4 Float Float) -> T5 () () -> IO ()l :: (Int, Int, Float) -> Intl :: (Int, Int, Float) -> Intm :: R -> N1 () -> IO Intm :: R -> N1 () -> IO Into :: Float -> IO Floato :: Float -> IO Floatf' :: Intf' :: IntA Int (Maybe Float) Int (Maybe Float)This comment describes the AA constructor B (T a b, T Int Float) (T a b, T Int Float)This comment describes the BB constructor adocuments A3A3 bdocuments B3B3 This is the doc for A4A4 This is the doc for B4B4 This is the doc for C4C4 :: a bthis is the n3n3 field The N7N7 constructor This is the documentation for the RR record, which has four fields, pp, qq, rr, and ss. This is the C1C1 record constructor, with the following fields: p :: Int :: IntThis comment applies to the pp field a. a -> aThis comment applies to the qq field r :: Int :: IntThis comment applies to both rr and ss s :: Int :: IntThis comment applies to both rr and ss This is the C2C2 record constructor, also with some fields: t :: T1 -> T2 Int Int -> T3 Bool Bool -> T4 Float Float -> T5 :: T1 -> T2 Int Int -> T3 Bool Bool -> T4 Float Float -> T5 () ()u :: Int :: Intv :: Int :: IntThis is the C3C3 record constructor s1 :: Int :: IntThe s1s1 record selector s2 :: Int :: IntThe s2s2 record selector s3 :: Int :: IntThe s3s3 record selector class D D a => This comment applies to the previous declaration (the CC class) a :: IO :: IO athis is a description of the aa method this is a description of the bb method d :: T :: T a bDFloatDInt
D Float
D Int
f :: C a => a -> Int :: C a => a -> Int

In a comment string we can refer to identifiers in scope with single quotes like this: TT, and we can refer to modules by -using double quotes: FooFoo. We can add emphasis like this. @@ -2484,8 +2382,7 @@ using double quotes: 

      This is a block of code, which can include other markup: RR
      formatting
@@ -2496,8 +2393,7 @@ using double quotes:  this is another block of code

We can also include URLs in documentation: http://www.haskell.org/We can also include URLs in documentation: http://www.haskell.org/.

g :: Int -> IO :: Int -> IO CInthidden :: Int -> Int :: Int -> Intmodule Visiblemodule Visibleforall b . C b . C b => forall b . C b . C a => -> T2IntInt-> T3BoolBool -> T4FloatFloat
:: T:: T () ()This argument has type TT
-> T2 Int Int This argument has type 'T2 Int Int'
-> T3 Bool Bool -> T4 Float Float This argument has type T3 Bool Bool -> T4 Float Float
-> T5-> T5 () ()This argument has a very long description that should @@ -2968,8 +2863,7 @@ test2 >
-> IO-> IO ()This is the result type @@ -3002,17 +2896,22 @@ test2 >:: (Int, Int, Float)-> Int
:: (Int, Int, Float)takes a triple
-> Intreturns an IntInt
-> IOInt
:: R:: R
-> N1-> N1 ()one of the arguments @@ -3055,9 +2952,9 @@ test2 >
-> IO Int and the return value
:: Float-> IOFloatf' :: Int :: Int
:: FloatThe input float
-> IO Float The output float
a function with a prime can be referred to as f'f' but f' doesn't get link'd 'f\'' @@ -3183,8 +3081,7 @@ test2 >
Produced by HaddockProduced by Haddock version 2.5.0
ContentsContentsIndexIndex
type family G G a :: *class A A a wheredata B B a :: * -> *f :: B a Intf :: B a Inttype family F F a f :: B a Int :: B a IntAInt
A Int
Produced by HaddockProduced by Haddock version 2.5.0ContentsContentsIndexIndexvisible :: Int -> Int :: Int -> IntProduced by HaddockProduced by Haddock version 2.5.0