A

[Remove html files in the tests/output/ directory which have been accidentally added David Waern **20090207135804] { hunk ./tests/output/A.html 1 - - -A

Documentation

data A

Constructors

Produced by Haddock version 2.4.2

rmfile ./tests/output/A.html hunk ./tests/output/B.html 1 - - -B

Documentation

module A

Produced by Haddock version 2.4.2

rmfile ./tests/output/B.html hunk ./tests/output/Bug1.html 1 - - -Bug1

Contents

Index

Bug1

Synopsis

data T = T

Documentation

data T

We should have different anchors for constructors and types/classes. This - hyperlink should point to the type constructor by default: T. -

Constructors

Produced by Haddock version 2.4.2

rmfile ./tests/output/Bug1.html hunk ./tests/output/Bug2.html 1 - - -Bug2

Bug2

Documentation

x :: A

Produced by Haddock version 2.4.2

rmfile ./tests/output/Bug2.html hunk ./tests/output/Bug3.html 1 - - -Bug3

Bug3

Synopsis

foo :: Int

Documentation

foo :: Int

/multi-line - emphasis/ -

Produced by Haddock version 2.4.2

rmfile ./tests/output/Bug3.html hunk ./tests/output/Bug4.html 1 - - -Bug4

Bug4

Synopsis

foo :: Int

Documentation

foo :: Int

don't use apostrophe's in the wrong place's -

Produced by Haddock version 2.4.2

rmfile ./tests/output/Bug4.html hunk ./tests/output/Bug6.html 1 - - -Bug6

Bug6

Description

Exporting records. -

Synopsis

data A = A Int

data B = B {

b :: Int

}

b :: B -> Int

data C = C {

c1 :: Int

c2 :: Int

}

data D = D Int Int

newtype E = E Int

Documentation

data A

This record is exported without its field -

Constructors

A Int

data B

.. with its field, but the field is named separately in the export list - (should still be visible as a field name) -

Constructors

b :: Int

b :: B -> Int

data C

.. with fields names as subordinate names in the export -

Constructors

c1 :: Int
c2 :: Int

data D

.. with only some of the fields exported (we can't handle this one - - how do we render the declaration?) -

Constructors

D Int Int

newtype E

a newtype with a field -

Constructors

E Int

Produced by Haddock version 2.4.2

rmfile ./tests/output/Bug6.html hunk ./tests/output/Bug7.html 1 - - -Bug7

Bug7

Description

This module caused a duplicate instance in the documentation for the Foo - type. -

Synopsis

data Foo = Foo

class Bar x y

Documentation

data Foo

The Foo datatype -

Constructors

Foo

Instances

Bar Foo Foo

class Bar x y

The Bar class -

Instances

Bar Foo Foo

Produced by Haddock version 2.4.2

rmfile ./tests/output/Bug7.html hunk ./tests/output/Bug8.html 1 - - -Bug8

Bug8

Documentation

data Typ

Constructors

Type (String, [Typ])
TFree (String, [String])

Produced by Haddock version 2.4.2

rmfile ./tests/output/Bug8.html hunk ./tests/output/Bugs.html 1 - - -Bugs

Bugs

Documentation

data A a

Constructors

A a (a -> Int)

Produced by Haddock version 2.4.2

rmfile ./tests/output/Bugs.html hunk ./tests/output/Hash.html 1 - - -Hash

Contents

Index

Hash

Contents

The HashTable type -

Operations on HashTables -

The Hash class -

Description

Implementation of fixed-size hash tables, with a type - class for constructing hash values for structured types. -

Synopsis

data HashTable key val

new :: (Eq key, Hash key) => Int -> IO (HashTable key val)

insert :: (Eq key, Hash key) => key -> val -> IO ()

lookup :: Hash key => key -> IO (Maybe val)

class Hash a where

hash :: a -> Int

The HashTable type -

data HashTable key val

A hash table with keys of type key and values of type val. - The type key should be an instance of Eq. -

Operations on HashTables -

new :: (Eq key, Hash key) => Int -> IO (HashTable key val)

Builds a new hash table with a given size -

insert :: (Eq key, Hash key) => key -> val -> IO ()

Inserts a new element into the hash table -

lookup :: Hash key => key -> IO (Maybe val)

Looks up a key in the hash table, returns Just val if the key - was found, or Nothing otherwise. -

The Hash class -

class Hash a where

A class of types which can be hashed. -

Methods

hash :: a -> Int

hashes the value of type a into an Int -

Instances

Hash Float

Hash Int

(Hash a, Hash b) => Hash ((,) a b)

Produced by Haddock version 2.4.2

rmfile ./tests/output/Hash.html hunk ./tests/output/NoLayout.html 1 - - -NoLayout

NoLayout

Synopsis

g :: Int

Documentation

g :: Int

the class C -

Produced by Haddock version 2.4.2

rmfile ./tests/output/NoLayout.html hunk ./tests/output/Test.html 1 - - -Test

Contents

Index

Test

Portability	portable
Stability	provisional
Maintainer	libraries@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 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

n :: a b

newtype N3 a b

A newtype with a fieldname, documentation on the field -

Constructors

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 :: a b

no docs on the datatype or the constructor -

newtype N6 a b

Constructors

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 :: Int	This comment applies to both `r` and `s` -
s :: Int	This comment applies to both `r` and `s` -

C2 This 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

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

D Float

D Int

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

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 -

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

:: (Int, Int, Float)	takes a triple -
-> Int	returns an `Int` -

:: R
-> N1 ()	one of the arguments -
-> IO Int	and the return value -
This function has some arg docs -

:: 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\'' -

Produced by Haddock version 2.4.2

rmfile ./tests/output/Test.html hunk ./tests/output/TypeOperators.html 1 - - -TypeOperators

TypeOperators

Contents

stuff -

Synopsis

data a :-: b

data (a :+: b) c

data Op a b

newtype O g f a = O {

unO :: g (f a)

}

biO :: (g `O` f) a

newtype Flip (~>) b a = Flip {

unFlip :: a ~> b

}

stuff -

data a :-: b

data (a :+: b) c

data Op a b

newtype O g f a

Constructors

unO :: g (f a)

biO :: (g `O` f) a

newtype Flip (~>) b a

Constructors

Flip

unFlip :: a ~> b

Produced by Haddock version 2.4.2

rmfile ./tests/output/TypeOperators.html hunk ./tests/output/Visible.html 1 - - -Visible

Visible

Documentation

visible :: Int -> Int

Produced by Haddock version 2.4.2

rmfile ./tests/output/Visible.html }