ContentsIndex
Test
Portability portable
Stability provisional
Maintainer libraries@haskell.org
Contents
Type declarations
Data types
Records
Class declarations
Function types
A hidden module
A visible module
Existential / Universal types
Type signatures with argument docs
A section
A subsection
Description
This module illustrates & tests most of the features of Haddock. Testing references from the description: T, f, g, visible.
Synopsis
data T a b
= A Int (Maybe Float)
| B (T a b, T Int Float)
data T2 a b
data T3 a b
= A1 a
| B1 b
data T4 a b
= A2 a
| B2 b
data T5 a b
= A3 a
| B3 b
data T6
= A4
| B4
| C4
newtype N1 a b = N1 (a b)
newtype N2 a b = N2 {
n :: (a b)
}
newtype N3 a b = N3 {
n3 :: (a b)
}
data N4 a b
newtype N5 a b = N5 {
n5 :: (a b)
}
newtype N6 a b = N6 {
n6 :: (a b)
}
newtype N7 a b = N7 {
n7 :: (a b)
}
data R
= C1 {
p :: Int
q :: (forall a . a -> a)
r, s :: Int
}
| C2 {
t :: (T1 -> T2 -> T3 -> T4 -> T5)
u, v :: Int
}
data R1 = C3 {
s1 :: Int
s2 :: Int
s3 :: Int
}
p :: R -> Int
q :: R -> forall a . a -> a
u :: R -> Int
class (D a) => C a where
a :: Int
b :: Float
class D a where
d :: T a b
e :: (a, a)
class E a
class F a where
ff :: Float
a :: (C a) => Int
f :: (C a) => Int -> Int
g :: Int -> IO CInt
hidden :: Int -> Int
module Visible
data Ex a
= forall b . (C b) => Ex1 b
| forall b . Ex2 b
| (C a) => Ex3 b
| Ex4 (forall a . a -> a)
k :: T -> T2 -> (T3 -> T4) -> T5 -> IO ()
l :: (Int, Int, Float) -> Int
m :: R -> N1 -> IO Int
n :: R -> N1 -> IO Int
o :: Float -> IO Float
Type declarations
Data types
data T a b
This comment applies to the following declaration and it continues until the next non-comment line
Constructors
A Int (Maybe Float) This comment describes the A constructor
B (T a b, T Int Float) This comment describes the B constructor
data T2 a b
An abstract data declaration
data T3 a b
A data declaration with no documentation annotations on the constructors
Constructors
A1 a
B1 b
data T4 a b
Constructors
A2 a
B2 b
data T5 a b
Constructors
A3 a documents A3
B3 b documents B3
data T6
Testing alternative comment styles
Constructors
A4 This is the doc for A4
B4 This is the doc for B4
C4 This is the doc for C4
newtype N1 a b
A newtype
Constructors
N1 (a b)
newtype N2 a b
A newtype with a fieldname
Constructors
N2
n :: (a b)
newtype N3 a b
A newtype with a fieldname, documentation on the field
Constructors
N3
n3 :: (a b) this is the n3 field
data N4 a b
An abstract newtype - we show this one as data rather than newtype because the difference isn't visible to the programmer for an abstract type.
newtype N5 a b
Constructors
N5
n5 :: (a b) no docs on the datatype or the constructor
newtype N6 a b
Constructors
N6 docs on the constructor only
n6 :: (a b)
newtype N7 a b
docs on the newtype and the constructor
Constructors
N7 The N7 constructor
n7 :: (a b)
Records
data R
This is the documentation for the R record, which has four fields, p, q, r, and s.
Constructors
C1 This is the C1 record constructor, with the following fields:
p :: Int This comment applies to the p field
q :: (forall a . a -> a) This comment applies to the q field
r, s :: Int This comment applies to both r and s
C2 This is the C2 record constructor, also with some fields:
t :: (T1 -> T2 -> T3 -> T4 -> T5)
u, v :: Int
data R1
Testing different record commenting styles
Constructors
C3 This is the C3 record constructor
s1 :: Int The s1 record selector
s2 :: Int The s2 record selector
s3 :: Int The s3 record selector
test that we can export record selectors on their own:
p :: R -> Int
This comment applies to the p field
q :: R -> forall a . a -> a
This comment applies to the q field
u :: R -> Int
Class declarations
class (D a) => C a where
This comment applies to the previous declaration (the C class)
Methods
a :: Int
this is a description of the a method
b :: Float
this is a description of the b method
class D a where
This is a class declaration with no separate docs for the methods
Methods
d :: T a b
e :: (a, a)
Instances
D Int
D Float
class E a
This is a class declaration with no methods (or no methods exported)
class F a where
Methods
ff :: Float
Test that we can export a class method on its own:
a :: (C a) => Int
this is a description of the a method
Function types
f :: (C a) => Int -> Int

In a comment string we can refer to identifiers in scope with single quotes like this: T, and we can refer to modules by using double quotes: Foo. We can add emphasis like this.

  • This is a bulleted list
  • This is the next item (different kind of bullet)
  1. This is an ordered list
  2. This is the next item (different kind of bullet)
     This is a block of code, which can include other markup: R
     formatting
               is
                 significant
 this is another block of code

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

g :: Int -> IO CInt
we can export foreign declarations too
This is some documentation that is attached to a name ($aux2)

This is some documentation that is attached to a name ($aux1) rather than a source declaration. The documentation may be referred to in the export list using its name.

 code block in named doc 
This is some documentation that is attached to a name ($aux2)
 code block on its own in named doc 
 code block on its own in named doc (after newline) 

a nested, named doc comment

with a paragraph,

 and a code block 
test
test1
 test2
  test3
test1
test2
test3
test4
test1
test2
test3
test4
test3
test4
test1
test2

aux11:

test3
test4

test1
test2

This is some inline documentation in the export list

 a code block using bird-tracks
 each line must begin with > (which isn\'t significant unless it
 is at the beginning of the line).
A hidden module
hidden :: Int -> Int
A visible module
module Visible
nested-style doc comments
Existential / Universal types
data Ex a
A data-type using existential/universal types
Constructors
forall b . (C b) => Ex1 b
forall b . Ex2 b
(C a) => Ex3 b
Ex4 (forall a . a -> a)
Type signatures with argument docs
k
:: T This argument has type T
-> T2 This argument has type T2
-> (T3 -> T4) This argument has type T3 -> T4
-> T5 This argument has a very long description that should hopefully cause some wrapping to happen when it is finally rendered by Haddock in the generated HTML page.
-> IO () This is the result type
This is a function with documentation for each argument
l
:: (Int, Int, Float) takes a triple
-> Int returns an Int
m
:: R
-> N1 one of the arguments
-> IO Int and the return value
This function has some arg docs
n
:: R one of the arguments, an R
-> N1 one of the arguments
-> IO Int
This function has some arg docs but not a return value doc
o
:: Float The input float
-> IO Float The output float
A foreign import with argument docs
A section
A subsection
 a literal line
 $ a non literal line $
Produced by Haddock version 0.4