From bed5120c47c7417fc8c371eebc127eb219ac85af Mon Sep 17 00:00:00 2001 From: David Waern Date: Sat, 7 Feb 2009 13:58:04 +0000 Subject: Remove html files in the tests/output/ directory which have been accidentally added --- tests/output/A.html | 122 -- tests/output/B.html | 88 -- tests/output/Bug1.html | 156 -- tests/output/Bug2.html | 94 -- tests/output/Bug3.html | 118 -- tests/output/Bug4.html | 117 -- tests/output/Bug6.html | 512 ------ tests/output/Bug7.html | 250 --- tests/output/Bug8.html | 136 -- tests/output/Bugs.html | 122 -- tests/output/Hash.html | 471 ------ tests/output/NoLayout.html | 117 -- tests/output/Test.html | 3312 --------------------------------------- tests/output/TypeOperators.html | 404 ----- tests/output/Visible.html | 92 -- 15 files changed, 6111 deletions(-) delete mode 100644 tests/output/A.html delete mode 100644 tests/output/B.html delete mode 100644 tests/output/Bug1.html delete mode 100644 tests/output/Bug2.html delete mode 100644 tests/output/Bug3.html delete mode 100644 tests/output/Bug4.html delete mode 100644 tests/output/Bug6.html delete mode 100644 tests/output/Bug7.html delete mode 100644 tests/output/Bug8.html delete mode 100644 tests/output/Bugs.html delete mode 100644 tests/output/Hash.html delete mode 100644 tests/output/NoLayout.html delete mode 100644 tests/output/Test.html delete mode 100644 tests/output/TypeOperators.html delete mode 100644 tests/output/Visible.html (limited to 'tests/output') diff --git a/tests/output/A.html b/tests/output/A.html deleted file mode 100644 index 24f18251..00000000 --- a/tests/output/A.html +++ /dev/null @@ -1,122 +0,0 @@ - - -A
ContentsIndex
A
Documentation
data A
Constructors
A
Produced by Haddock version 2.4.2
diff --git a/tests/output/B.html b/tests/output/B.html deleted file mode 100644 index 304dc9fa..00000000 --- a/tests/output/B.html +++ /dev/null @@ -1,88 +0,0 @@ - - -B
ContentsIndex
B
Documentation
module A
Produced by Haddock version 2.4.2
diff --git a/tests/output/Bug1.html b/tests/output/Bug1.html deleted file mode 100644 index b7589578..00000000 --- a/tests/output/Bug1.html +++ /dev/null @@ -1,156 +0,0 @@ - - -Bug1
ContentsIndex
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
T
Produced by Haddock version 2.4.2
diff --git a/tests/output/Bug2.html b/tests/output/Bug2.html deleted file mode 100644 index 1f27d7c3..00000000 --- a/tests/output/Bug2.html +++ /dev/null @@ -1,94 +0,0 @@ - - -Bug2
ContentsIndex
Bug2
Documentation
x :: A
Produced by Haddock version 2.4.2
diff --git a/tests/output/Bug3.html b/tests/output/Bug3.html deleted file mode 100644 index e350dce8..00000000 --- a/tests/output/Bug3.html +++ /dev/null @@ -1,118 +0,0 @@ - - -Bug3
ContentsIndex
Bug3
Synopsis
foo :: Int
Documentation
foo :: Int
/multi-line - emphasis/ -
Produced by Haddock version 2.4.2
diff --git a/tests/output/Bug4.html b/tests/output/Bug4.html deleted file mode 100644 index 141cc8a6..00000000 --- a/tests/output/Bug4.html +++ /dev/null @@ -1,117 +0,0 @@ - - -Bug4
ContentsIndex
Bug4
Synopsis
foo :: Int
Documentation
foo :: Int
don't use apostrophe's in the wrong place's -
Produced by Haddock version 2.4.2
diff --git a/tests/output/Bug6.html b/tests/output/Bug6.html deleted file mode 100644 index 995bd148..00000000 --- a/tests/output/Bug6.html +++ /dev/null @@ -1,512 +0,0 @@ - - -Bug6
ContentsIndex
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
b :: Int
b :: B -> Int
data C
.. with fields names as subordinate names in the export -
Constructors
C
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
diff --git a/tests/output/Bug7.html b/tests/output/Bug7.html deleted file mode 100644 index 0349e0d0..00000000 --- a/tests/output/Bug7.html +++ /dev/null @@ -1,250 +0,0 @@ - - -Bug7
ContentsIndex
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
show/hide Instances
class Bar x y
The Bar class -
show/hide Instances
Produced by Haddock version 2.4.2
diff --git a/tests/output/Bug8.html b/tests/output/Bug8.html deleted file mode 100644 index 91546839..00000000 --- a/tests/output/Bug8.html +++ /dev/null @@ -1,136 +0,0 @@ - - -Bug8
ContentsIndex
Bug8
Documentation
data Typ
Constructors
Type (String, [Typ])
TFree (String, [String])
Produced by Haddock version 2.4.2
diff --git a/tests/output/Bugs.html b/tests/output/Bugs.html deleted file mode 100644 index 6ad6358a..00000000 --- a/tests/output/Bugs.html +++ /dev/null @@ -1,122 +0,0 @@ - - -Bugs
ContentsIndex
Bugs
Documentation
data A a
Constructors
A a (a -> Int)
Produced by Haddock version 2.4.2
diff --git a/tests/output/Hash.html b/tests/output/Hash.html deleted file mode 100644 index 4cc409ed..00000000 --- a/tests/output/Hash.html +++ /dev/null @@ -1,471 +0,0 @@ - - -Hash
ContentsIndex
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 -
show/hide Instances
Hash Float
Hash Int
(Hash a, Hash b) => Hash ((,) a b)
Produced by Haddock version 2.4.2
diff --git a/tests/output/NoLayout.html b/tests/output/NoLayout.html deleted file mode 100644 index ada600e2..00000000 --- a/tests/output/NoLayout.html +++ /dev/null @@ -1,117 +0,0 @@ - - -NoLayout
ContentsIndex
NoLayout
Synopsis
g :: Int
Documentation
g :: Int
the class C -
Produced by Haddock version 2.4.2
diff --git a/tests/output/Test.html b/tests/output/Test.html deleted file mode 100644 index 8f18f830..00000000 --- a/tests/output/Test.html +++ /dev/null @@ -1,3312 +0,0 @@ - - -Test
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 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 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)
show/hide 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) -
  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.4.2
diff --git a/tests/output/TypeOperators.html b/tests/output/TypeOperators.html deleted file mode 100644 index c9e87c94..00000000 --- a/tests/output/TypeOperators.html +++ /dev/null @@ -1,404 +0,0 @@ - - -TypeOperators
ContentsIndex
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
O
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
diff --git a/tests/output/Visible.html b/tests/output/Visible.html deleted file mode 100644 index dec49dd2..00000000 --- a/tests/output/Visible.html +++ /dev/null @@ -1,92 +0,0 @@ - - -Visible
ContentsIndex
Visible
Documentation
visible :: Int -> Int
Produced by Haddock version 2.4.2
-- cgit v1.2.3