Synopsis Documentation map :: (a -> b) -> [a] -> [b]map f xs is the list obtained by applying f to each element
- of xs , i.e.,
-
map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn]
+CrossPackageDocs Documentation map :: (a -> b) -> [a] -> [b]
map f xs is the list obtained by applying f to each element
+ of xs, i.e.,
+
map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn]
hunk ./tests/golden-tests/tests/CrossPackageDocs.html.ref 8
- class Monad m where The Monad monad ,
-a concept from a branch of mathematics known as category theory .
+
class Monad m where
The Monad monad ,
+a concept from a branch of mathematics known as category theory .
hunk ./tests/golden-tests/tests/CrossPackageDocs.html.ref 11
-think of a monad as an abstract datatype of actions.
-Haskell's do expressions provide a convenient syntax for writing
+think of a monad as an abstract datatype of actions.
+Haskell's do expressions provide a convenient syntax for writing
hunk ./tests/golden-tests/tests/CrossPackageDocs.html.ref 14
-
Minimal complete definition: >>= return
Instances of Monad
return a >>= k == k a
+ Minimal complete definition: >>= return
Instances of Monad
return a >>= k == k a
hunk ./tests/golden-tests/tests/CrossPackageDocs.html.ref 19
-Instances of both Monad Functor
fmap f xs == xs >>= return . f
- The instances of Monad Prelude satisfy these laws.
-
Methods (>>=) :: m a -> (a -> m b) -> m bSequentially compose two actions, passing any value produced
+Instances of both Monad Functor
fmap f xs == xs >>= return . f
+The instances of Monad Prelude satisfy these laws.
+
Methods
(>>=) :: m a -> (a -> m b) -> m b
Sequentially compose two actions, passing any value produced
hunk ./tests/golden-tests/tests/CrossPackageDocs.html.ref 25
-
(>>) :: m a -> m b -> m bSequentially compose two actions, discarding any value produced
+(>>) :: m a -> m b -> m b
Sequentially compose two actions, discarding any value produced
hunk ./tests/golden-tests/tests/CrossPackageDocs.html.ref 28
-
return :: a -> m aInject a value into the monadic type.
- fail :: String -> m aFail with a message. This operation is not part of the
+return :: a -> m a
Inject a value into the monadic type.
+
fail :: String -> m a
Fail with a message. This operation is not part of the
hunk ./tests/golden-tests/tests/CrossPackageDocs.html.ref 31
- failure in a do expression.
-
runInteractiveProcess :: FilePath Filename of the executable
- -> [String ] Arguments to pass to the executable
- -> Maybe FilePath Optional path to the working directory
- -> Maybe [(String , String )] Optional environment (otherwise inherit)
- -> IO (Handle , Handle , Handle , ProcessHandle ) Runs a raw command, and returns Handle stdin , stdout and stderr respectively.
-
For example, to start a process and feed a string to its stdin:
-
(inp,out,err,pid) <- runInteractiveProcess "..."
+ failure in a do expression.
+runInteractiveProcess
Runs a raw command, and returns Handle stdin, stdout and stderr respectively.
+
For example, to start a process and feed a string to its stdin:
+
(inp,out,err,pid) <- runInteractiveProcess "..."
hunk ./tests/golden-tests/tests/CrossPackageDocs.html.ref 41
-The Handle hSetBinaryMode
Produced by Haddock version 2.7.2
-
+Description Implementation of fixed-size hash tables, with a type
+Hash Description
Implementation of fixed-size hash tables, with a type
hunk ./tests/golden-tests/tests/Hash.html.ref 9
-
Synopsis 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 HashTable s
- 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 Nothing 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
Produced by Haddock version 2.7.2
-
+Test Portability portable Stability provisional Maintainer libraries@haskell.org
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
+Test Description
This module illustrates & tests most of the features of Haddock.
+ Testing references from the description: T f g visible
Type declarations
+ Data types
+ data T a b
This comment applies to the following declaration
hunk ./tests/golden-tests/tests/Test.html.ref 22
-
Constructors A Int (Maybe Float )This comment describes the A B (T a b, T Int Float )This comment describes the B
data T2 a b An abstract data declaration
-
data T3 a b A data declaration with no documentation annotations on the constructors
- Constructors
data T4 a b data T5 a b Constructors A3 adocuments A3 B3 bdocuments 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 newtype N2 a b A newtype with a fieldname
- Constructors
newtype N3 a b A newtype with a fieldname, documentation on the field
- Constructors N3 n3 :: a bthis is the n3
data N4 a b An abstract newtype - we show this one as data rather than newtype because
+data T2 a b
An abstract data declaration
+
data T3 a b
A data declaration with no documentation annotations on the constructors
+
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 N2 a b
A newtype with a fieldname
+
newtype N3 a b
A newtype with a fieldname, documentation on the field
+
Constructors
N3 Fields
n3 :: a bthis is the n3
data N4 a b
An abstract newtype - we show this one as data rather than newtype because
hunk ./tests/golden-tests/tests/Test.html.ref 38
-
newtype N5 a b Constructors N5 n5 :: a bno docs on the datatype or the constructor
-
newtype N6 a b Constructors N6 docs on the constructor only
-
newtype N7 a b docs on the newtype and the constructor
- Constructors
Records
- data R This is the documentation for the R p q r s Constructors C1 This is the C1 p :: Int This comment applies to the p q :: forall a. a -> aThis comment applies to the q r :: Int This comment applies to both r s s :: Int This comment applies to both r s
C2 This is the C2
data R1 Testing different record commenting styles
- Constructors C3 This is the C3 s1 :: Int The s1 s2 :: Int The s2 s3 :: Int The s3
test that we can export record selectors on their own:
- Class declarations
- class D a => C a where This comment applies to the previous declaration (the C Methods a :: IO athis is a description of the a b :: [a]this is a description of the b
class D a where This is a class declaration with no separate docs for the methods
- Methods
class E a This is a class declaration with no methods (or no methods exported)
-
class F a where Test that we can export a class method on its own:
- Function types
- f :: C a => a -> Int In a comment string we can refer to identifiers in scope with
-single quotes like this: T 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 newtype N5 a b
Constructors
N5 Fields
n5 :: a bno docs on the datatype or the constructor
+
newtype N6 a b
Constructors
N6 docs on the constructor only
+
newtype N7 a b
docs on the newtype and the constructor
+
Records
+ data R
This is the documentation for the R p q r s
Constructors
C1 This is the C1
Fields
p :: Int This comment applies to the p
q :: forall a. a -> aThis comment applies to the q
r :: Int This comment applies to both r s
s :: Int This comment applies to both r s
C2 This is the C2
data R1
Testing different record commenting styles
+
Constructors
C3 This is the C3
Fields
s1 :: Int The s1
s2 :: Int The s2
s3 :: Int The s3
test that we can export record selectors on their own:
+
Class declarations
+ class D a => C a where
This comment applies to the previous declaration (the C
Methods
a :: IO a
this is a description of the a
b :: [a]
this is a description of the b
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)
+
Test that we can export a class method on its own:
+
Function types
+ f :: C a => a -> Int
In a comment string we can refer to identifiers in scope with
+single quotes like this: T 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
+ 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 this is another block of code
- We can also include URLs in documentation: http://www.haskell.org/ .
-
g :: Int -> IO CIntwe can export foreign declarations too
- Auxiliary stuff
- This is some documentation that is attached to a name ($aux1)
+
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)
hunk ./tests/golden-tests/tests/Test.html.ref 86
-
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
+ 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
hunk ./tests/golden-tests/tests/Test.html.ref 91
- test2
+ test2
hunk ./tests/golden-tests/tests/Test.html.ref 93
-
+
hunk ./tests/golden-tests/tests/Test.html.ref 96
- test3
+ test3
hunk ./tests/golden-tests/tests/Test.html.ref 98
-
+
hunk ./tests/golden-tests/tests/Test.html.ref 101
- test3
+ test3
hunk ./tests/golden-tests/tests/Test.html.ref 103
- test3
+ test3
hunk ./tests/golden-tests/tests/Test.html.ref 105
-
+
hunk ./tests/golden-tests/tests/Test.html.ref 108
- aux11:
-
test3
+ aux11:
+
test3
hunk ./tests/golden-tests/tests/Test.html.ref 111
-
+
hunk ./tests/golden-tests/tests/Test.html.ref 114
- foo
- bar
- This is some inline documentation in the export list
-
a code block using bird-tracks
+ This is some inline documentation in the export list
+
a code block using bird-tracks
hunk ./tests/golden-tests/tests/Test.html.ref 120
- 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 bforall b . Ex2 bforall b . C a => Ex3 bEx4 (forall a. a -> a)
Type signatures with argument docs
- k :: 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
+A hidden module
+ A visible module
+ 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
hunk ./tests/golden-tests/tests/Test.html.ref 132
-
-> IO () This is the result type
- This is a function with documentation for each argument
-
l m :: R -> N1 () one of the arguments
- -> IO Int and the return value
- This function has some arg docs
-
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 $
-
f' :: Int a function with a prime can be referred to as f' -> IO () This is the result type
+
This is a function with documentation for each argument
+
m
Arguments
:: R -> N1 () one of the arguments
+
-> IO Int and the return value
+
This function has some arg docs
+
o
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'
Produced by Haddock version 2.7.2
-
+
hunk ./tests/golden-tests/tests/Ticket112.html.ref 1
-
-
-
Instances