ContentsIndex
Test
Portabilityportable
Stabilityprovisional
Maintainerlibraries@haskell.org
Contents
Type declarations
Data types
Records
Class declarations
Function types
Auxiliary stuff
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 = N1 a
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 :: Int
s :: Int
}
| C2 {
t :: T1 -> (T2 Int Int) -> (T3 Bool Bool) -> (T4 Float Float) -> T5 () ()
u :: Int
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 :: IO a
b :: [a]
class D a where
d :: T a b
e :: (a, a)
class E a
class F a where
ff :: a
a :: C a => IO a
f :: C a => a -> Int
g :: Int -> IO CInt
hidden :: Int -> Int
module Visible
data Ex a
= forall b . C b => Ex1 b
| forall b . Ex2 b
| forall b . C a => Ex3 b
| Ex4 forall a. a -> a
k :: T () () -> T2 Int Int -> T3 Bool Bool -> T4 Float Float -> T5 () () -> IO ()
l :: (Int, Int, Float) -> Int
m :: R -> N1 () -> IO Int
o :: Float -> IO Float
f' :: Int
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 FloatThis 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 adocuments A3
B3 bdocuments B3
data T6
Testing alternative comment styles
Constructors
A4This is the doc for A4
B4This is the doc for B4
C4This is the doc for C4
newtype N1 a
A newtype
Constructors
N1 a
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 bthis 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 bno docs on the datatype or the constructor
newtype N6 a b
Constructors
N6docs on the constructor only
n6 :: a b
newtype N7 a b
docs on the newtype and the constructor
Constructors
N7The 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
C1This is the C1 record constructor, with the following fields:
p :: IntThis comment applies to the p field
q :: forall a. a -> aThis comment applies to the q field
r :: IntThis comment applies to both r and s
s :: IntThis comment applies to both r and s
C2This is the C2 record constructor, also with some fields:
t :: T1 -> (T2 Int Int) -> (T3 Bool Bool) -> (T4 Float Float) -> T5 () ()
u :: Int
v :: Int
data R1
Testing different record commenting styles
Constructors
C3This is the C3 record constructor
s1 :: IntThe s1 record selector
s2 :: IntThe s2 record selector
s3 :: IntThe 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 :: IO a
this is a description of the a method
b :: [a]
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)
class E a
This is a class declaration with no methods (or no methods exported)
class F a where
Methods
ff :: a
Test that we can export a class method on its own:
a :: C a => IO a
this is a description of the a method
Function types
f :: C a => a -> 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
Auxiliary stuff

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
 foo
 bar

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
forall b . C a => Ex3 b
Ex4 forall a. a -> a
Type signatures with argument docs
k
:: T () ()This argument has type T
-> T2 Int IntThis argument has type 'T2 Int Int'
-> T3 Bool Bool -> T4 Float FloatThis argument has type T3 Bool Bool -> T4 Float Float
-> 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
-> Intreturns an Int
m
:: R
-> N1 ()one of the arguments
-> IO Intand the return value
This function has some arg docs
o
:: FloatThe input float
-> IO FloatThe output float
A foreign import with argument docs
A section
A subsection
 a literal line

$ a non literal line $

f' :: Int
a function with a prime can be referred to as f' but f' doesn't get link'd 'f\''
Produced by Haddock version 2.0.0.0