Copyright(c) Simon Marlow 2002
LicenseBSD-style
Maintainerlibraries@haskell.org
Stabilityprovisional
Portabilityportable
Safe HaskellSafe-Inferred
LanguageHaskell2010

Test

Description

This module illustrates & tests most of the features of Haddock. Testing references from the description: T, f, g, visible.

Synopsis

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 #

A newtype

Constructors

N1 a 

newtype N2 a b #

A newtype with a fieldname

Constructors

N2 

Fields

  • n :: a b
     

newtype N3 a b #

A newtype with a fieldname, documentation on the field

Constructors

N3 

Fields

  • 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 

Fields

  • n5 :: a b

    no docs on the datatype or the constructor

newtype N6 a b #

Constructors

N6

docs on the constructor only

Fields

  • n6 :: a b
     

newtype N7 a b #

docs on the newtype and the constructor

Constructors

N7

The N7 constructor

Fields

  • 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:

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:

Fields

data R1 #

Testing different record commenting styles

Constructors

C3

This is the C3 record constructor

Fields

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) #

Instances

Instances details
D Float # 
Instance details

Defined in Test

Methods

d :: T Float b #

e :: (Float, Float) #

D Int # 
Instance details

Defined in Test

Methods

d :: T Int b #

e :: (Int, Int) #

class E a #

This is a class declaration with no methods (or no methods exported)

Minimal complete definition

ee

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)
cat
a small, furry, domesticated mammal
pineapple
a fruit grown in the tropics
     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 #

Arguments

:: T () ()

This argument has type T

-> 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 () ()

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 #

Arguments

:: (Int, Int, Float)

takes a triple

-> Int

returns an Int

m #

Arguments

:: R 
-> N1 ()

one of the arguments

-> IO Int

and the return value

This function has some arg docs

o #

Arguments

:: 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 $

f' :: Int #

a function with a prime can be referred to as f' but f' doesn't get link'd 'f''

withType :: Int #

Comment on a definition with type signature

withoutType :: a #

Comment on a definition without type signature