[Use --pretty-html when running the test suite. Makes it easier to compare output David Waern **20101206141735 Ignore-this: a891598e632b62845ce6af6c2f52c2e ] { hunk ./tests/golden-tests/runtests.hs 66 - (["-w", "-o", outdir, "-h", "--optghc=-fglasgow-exts" + (["-w", "-o", outdir, "-h", "--pretty-html", "--optghc=-fglasgow-exts" hunk ./tests/golden-tests/tests/A.html.ref 1 -A

 

A

Documentation

data A

Constructors

A 
+

 

A

Documentation

data A

Constructors

A 
+ hunk ./tests/golden-tests/tests/B.html.ref 1 -B

 

B

Documentation

module A

+

 

B

Documentation

module A

+ hunk ./tests/golden-tests/tests/Bug1.html.ref 1 -Bug1

 

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 
+

 

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 
+ hunk ./tests/golden-tests/tests/Bug2.html.ref 1 -Bug2

 

Bug2

Documentation

x :: A

+

 

Bug2

Documentation

x :: A

+ hunk ./tests/golden-tests/tests/Bug3.html.ref 1 -Bug3

 

Bug3

Synopsis

Documentation

foo :: Int

/multi-line +

Bug3

Synopsis

Documentation

foo :: Int

/multi-line hunk ./tests/golden-tests/tests/Bug3.html.ref 57 -

+

+ hunk ./tests/golden-tests/tests/Bug4.html.ref 1 -Bug4

 

Bug4

Synopsis

Documentation

foo :: Int

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

+

 

Bug4

Synopsis

Documentation

foo :: Int

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

+ hunk ./tests/golden-tests/tests/Bug6.html.ref 1 -Bug6

 

Bug6

Description

Exporting records. -

Synopsis

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 +

Bug6

Description

Exporting records. +

Synopsis

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 hunk ./tests/golden-tests/tests/Bug6.html.ref 141 -

Constructors

B 

Fields

b :: Int
 

data C

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

Constructors

C 

Fields

c1 :: Int
 
c2 :: Int
 

data D

.. with only some of the fields exported (we can't handle this one - +

Constructors

B 

Fields

b :: Int
 

data C

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

Constructors

C 

Fields

c1 :: Int
 
c2 :: Int
 

data D

.. with only some of the fields exported (we can't handle this one - hunk ./tests/golden-tests/tests/Bug6.html.ref 241 -

Constructors

D Int Int 

newtype E

a newtype with a field -

Constructors

E Int 
+

Constructors

D Int Int 

newtype E

a newtype with a field +

Constructors

E Int 
+ hunk ./tests/golden-tests/tests/Bug7.html.ref 1 -Bug7

 

Bug7

Description

This module caused a duplicate instance in the documentation for the Foo +

Bug7

Description

This module caused a duplicate instance in the documentation for the Foo hunk ./tests/golden-tests/tests/Bug7.html.ref 41 -

Synopsis

Documentation

data Foo

The Foo datatype -

Constructors

Foo 

Instances

Bar Foo Foo

Just one instance -

class Bar x y

The Bar class -

Instances

Bar Foo Foo

Just one instance -

+

Synopsis

Documentation

data Foo

The Foo datatype +

Constructors

Foo 

Instances

Bar Foo Foo

Just one instance +

class Bar x y

The Bar class +

Instances

Bar Foo Foo

Just one instance +

+ hunk ./tests/golden-tests/tests/Bug8.html.ref 1 -Bug8

 

Bug8

Documentation

data Typ

Constructors

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

 

Bug8

Documentation

data Typ

Constructors

Type (String, [Typ]) 
TFree (String, [String]) 
+ hunk ./tests/golden-tests/tests/Bugs.html.ref 1 -Bugs

 

Bugs

Documentation

data A a

Constructors

A a (a -> Int) 
+

 

Bugs

Documentation

data A a

Constructors

A a (a -> Int) 
+ hunk ./tests/golden-tests/tests/CrossPackageDocs.html.ref 1 -CrossPackageDocs

 

CrossPackageDocs

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
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]
hunk ./tests/golden-tests/tests/CrossPackageDocs.html.ref 105
-
class  Monad m  where
The Monad class defines the basic operations over a monad,
-a concept from a branch of mathematics known as category theory.
+

class Monad m where

The Monad class defines the basic operations over a monad, +a concept from a branch of mathematics known as category theory. hunk ./tests/golden-tests/tests/CrossPackageDocs.html.ref 129 -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 136 -

Minimal complete definition: >>= and return. -

Instances of Monad should satisfy the following laws: -

 return a >>= k  ==  k a
+
Minimal complete definition: >>= and return.
+
Instances of Monad should satisfy the following laws:
+
 return a >>= k  ==  k a
hunk ./tests/golden-tests/tests/CrossPackageDocs.html.ref 156
-
Instances of both Monad and Functor should additionally satisfy the law:
-
 fmap f xs  ==  xs >>= return . f
-
The instances of Monad for lists, Data.Maybe.Maybe and System.IO.IO
-defined in the Prelude satisfy these laws.
-

Methods

(>>=) :: m a -> (a -> m b) -> m b

Sequentially compose two actions, passing any value produced +

Instances of both Monad and Functor should additionally satisfy the law: +

 fmap f xs  ==  xs >>= return . f
+

The instances of Monad for lists, Data.Maybe.Maybe and System.IO.IO +defined in the 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 193 -

(>>) :: m a -> m b -> m b

Sequentially 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 204 -

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 +

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 224 - failure in a do expression. -

Instances

Monad [] 
Monad IO 
Monad Q 
Monad Maybe 
Monad ((->) r) 
Monad (Either e) 

runInteractiveProcess

Arguments

:: 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 Handles that may be used to communicate - with the process via its 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.
+

Instances

Monad [] 
Monad IO 
Monad Q 
Monad Maybe 
Monad ((->) r) 
Monad (Either e) 

runInteractiveProcess

Arguments

:: 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 Handles that may be used to communicate + with the process via its 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 369
-

The Handles are initially in binary mode; if you need them to be - in text mode then use hSetBinaryMode. -

+

The Handles are initially in binary mode; if you need them to be + in text mode then use hSetBinaryMode. +

+ hunk ./tests/golden-tests/tests/Examples.html.ref 1 -Examples

 

Examples

Synopsis

Documentation

fib :: Integer -> Integer

Fibonacci number of given Integer. -

Examples: -

>>> fib 5
-5
->>> fib 10
-55
-
>>> fib 10
-55
-

One more Example: -

>>> fib 5
-5
-

One more Example: -

>>> fib 5
-5
-

Example with an import: -

>>> import Data.Char
->>> isSpace 'a'
-False
-
+

 

Examples

Synopsis

Documentation

fib :: Integer -> Integer

Fibonacci number of given Integer. +

Examples: +

>>> fib 5
+5
+>>> fib 10
+55
+
>>> fib 10
+55
+

One more Example: +

>>> fib 5
+5
+

One more Example: +

>>> fib 5
+5
+

Example with an import: +

>>> import Data.Char
+>>> isSpace 'a'
+False
+
+ hunk ./tests/golden-tests/tests/FunArgs.html.ref 1 -FunArgs

 

FunArgs

Documentation

f

Arguments

:: forall a . Ord a 
=> Int

First argument -

-> a

Second argument -

-> Bool

Third argument -

-> (a -> a)

Fourth argument -

-> ()

Result -

g

Arguments

:: a

First argument -

-> b

Second argument -

-> c

Third argument -

-> d

Result -

+

 

FunArgs

Documentation

f

Arguments

:: forall a . Ord a 
=> Int

First argument +

-> a

Second argument +

-> Bool

Third argument +

-> (a -> a)

Fourth argument +

-> ()

Result +

g

Arguments

:: a

First argument +

-> b

Second argument +

-> c

Third argument +

-> d

Result +

+ hunk ./tests/golden-tests/tests/GADTRecords.html.ref 1 -GADTRecords

 

GADTRecords

Synopsis

Documentation

data H1 a b where

h1 -

Constructors

C1 :: H1 a b 
C2 :: Ord a => [a] -> H1 a a 
C3 :: Int -> H1 Int Int 

Fields

field :: Int

hello docs -

C4 :: a -> H1 Int a 

Fields

field2 :: a

hello2 docs -

+

 

GADTRecords

Synopsis

Documentation

data H1 a b where

h1 +

Constructors

C1 :: H1 a b 
C2 :: Ord a => [a] -> H1 a a 
C3 :: Int -> H1 Int Int 

Fields

field :: Int

hello docs +

C4 :: a -> H1 Int a 

Fields

field2 :: a

hello2 docs +

+ hunk ./tests/golden-tests/tests/Hash.html.ref 1 -Hash

 

Hash

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

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

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 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) 
+ hunk ./tests/golden-tests/tests/NamedDoc.html.ref 1 -NamedDoc

 

NamedDoc

Synopsis

    Documentation

    bar -

    +

     

    NamedDoc

    Synopsis

      Documentation

      bar +

      + hunk ./tests/golden-tests/tests/NoLayout.html.ref 1 -NoLayout

       

      NoLayout

      Synopsis

      Documentation

      g :: Int

      the function g -

      +

       

      NoLayout

      Synopsis

      Documentation

      g :: Int

      the function g +

      + hunk ./tests/golden-tests/tests/NonGreedy.html.ref 1 -NonGreedy

       

      NonGreedy

      Synopsis

      • f :: a

      Documentation

      f :: a

      url1 url2 -

      +

       

      NonGreedy

      Synopsis

      • f :: a

      Documentation

      f :: a

      url1 url2 +

      + hunk ./tests/golden-tests/tests/QuasiExpr.html.ref 1 -QuasiExpr

       

      QuasiExpr

      Documentation

      data Expr

      Constructors

      IntExpr Integer 
      AntiIntExpr String 
      BinopExpr BinOp Expr Expr 
      AntiExpr String 

      Instances

      data BinOp

      Constructors

      AddOp 
      SubOp 
      MulOp 
      DivOp 

      Instances

      eval :: Expr -> Integer

      parseExprExp :: String -> Q Exp

      +

       

      QuasiExpr

      Documentation

      data Expr

      Constructors

      IntExpr Integer 
      AntiIntExpr String 
      BinopExpr BinOp Expr Expr 
      AntiExpr String 

      Instances

      data BinOp

      Constructors

      AddOp 
      SubOp 
      MulOp 
      DivOp 

      Instances

      eval :: Expr -> Integer

      parseExprExp :: String -> Q Exp

      + hunk ./tests/golden-tests/tests/QuasiQuote.html.ref 1 -QuasiQuote

       

      QuasiQuote

      Documentation

      val :: Integer

      +

       

      QuasiQuote

      Documentation

      val :: Integer

      + hunk ./tests/golden-tests/tests/TH.html.ref 1 -TH

       

      TH

      Documentation

      decl :: Q [Dec]

      +

       

      TH

      Documentation

      decl :: Q [Dec]

      + hunk ./tests/golden-tests/tests/TH2.html.ref 1 -TH2

       

      TH2

      +

       

      TH2

      + hunk ./tests/golden-tests/tests/Test.html.ref 1 -Test

       

      Portabilityportable
      Stabilityprovisional
      Maintainerlibraries@haskell.org

      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 +

      Portabilityportable
      Stabilityprovisional
      Maintainerlibraries@haskell.org

      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 hunk ./tests/golden-tests/tests/Test.html.ref 525 -

      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 +

      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 hunk ./tests/golden-tests/tests/Test.html.ref 884 -

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

      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 -

      Fields

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

      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

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

      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
+

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

      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 +

      Fields

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

      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

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

      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
hunk ./tests/golden-tests/tests/Test.html.ref 1494
-
       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) +

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

       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 1556
-
       test2
+
       test2
hunk ./tests/golden-tests/tests/Test.html.ref 1560
-
      +
      hunk ./tests/golden-tests/tests/Test.html.ref 1567
-
      test3
+
      test3
hunk ./tests/golden-tests/tests/Test.html.ref 1573
-
      +
      hunk ./tests/golden-tests/tests/Test.html.ref 1580
-
      test3
+
      test3
hunk ./tests/golden-tests/tests/Test.html.ref 1584
-
      test3
+
      test3
hunk ./tests/golden-tests/tests/Test.html.ref 1590
-
      +
      hunk ./tests/golden-tests/tests/Test.html.ref 1595
-

      aux11: -

      test3
+

      aux11: +

      test3
hunk ./tests/golden-tests/tests/Test.html.ref 1604
-
      +
      hunk ./tests/golden-tests/tests/Test.html.ref 1609
-
       foo
-
       bar
-

      This is some inline documentation in the export list -

       a code block using bird-tracks
+
       foo
+
       bar
+

      This is some inline documentation in the export list +

       a code block using bird-tracks
hunk ./tests/golden-tests/tests/Test.html.ref 1627
-

      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 +

      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 hunk ./tests/golden-tests/tests/Test.html.ref 1784 -

      -> 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' +

      -> 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' hunk ./tests/golden-tests/tests/Test.html.ref 1956 -

      +

      + hunk ./tests/golden-tests/tests/Ticket112.html.ref 1 -Ticket112

       

      Ticket112

      Synopsis

      • f :: a

      Documentation

      f :: a

      ...given a raw Addr# to the string, and the length of the string. -

      +

       

      Ticket112

      Synopsis

      • f :: a

      Documentation

      f :: a

      ...given a raw Addr# to the string, and the length of the string. +

      + hunk ./tests/golden-tests/tests/Ticket61.html.ref 1 -Ticket61

       

      Ticket61

      Documentation

      class C a where

      Methods

      f :: a

      A comment about f -

      +

       

      Ticket61

      Documentation

      class C a where

      Methods

      f :: a

      A comment about f +

      + hunk ./tests/golden-tests/tests/Ticket75.html.ref 1 -Ticket75

       

      Ticket75

      Synopsis

      Documentation

      data a :- b

      Constructors

      Q 

      f :: Int

      A reference to :- -

      +

       

      Ticket75

      Synopsis

      Documentation

      data a :- b

      Constructors

      Q 

      f :: Int

      A reference to :- +

      + hunk ./tests/golden-tests/tests/TypeFamilies.html.ref 1 -TypeFamilies

       

      TypeFamilies

      Synopsis

      • type family G a :: *
      • class A a where
        • data B a :: * -> *
        • f :: B a Int
      • type family F a

      Documentation

      type family G a :: *

      Type family G -

      class A a where

      A class with an associated type -

      Associated Types

      data B a :: * -> *

      An associated type -

      Methods

      f :: B a Int

      A method -

      Instances

      A Int 

      type family F a

      Doc for family -

      +

       

      TypeFamilies

      Synopsis

      • type family G a :: *
      • class A a where
        • data B a :: * -> *
        • f :: B a Int
      • type family F a

      Documentation

      type family G a :: *

      Type family G +

      class A a where

      A class with an associated type +

      Associated Types

      data B a :: * -> *

      An associated type +

      Methods

      f :: B a Int

      A method +

      Instances

      A Int 

      type family F a

      Doc for family +

      + hunk ./tests/golden-tests/tests/TypeOperators.html.ref 1 -TypeOperators

       

      TypeOperators

      Contents

      Synopsis

      stuff -

      data a :-: b

      data (a :+: b) c

      data Op a b

      newtype O g f a

      Constructors

      O 

      Fields

      unO :: g (f a)
       

      biO :: (g `O` f) a

      newtype Flip (~>) b a

      Constructors

      Flip 

      Fields

      unFlip :: a ~> b
       
      +

       

      TypeOperators

      Contents

      Synopsis

      stuff +

      data a :-: b

      data (a :+: b) c

      data Op a b

      newtype O g f a

      Constructors

      O 

      Fields

      unO :: g (f a)
       

      biO :: (g `O` f) a

      newtype Flip (~>) b a

      Constructors

      Flip 

      Fields

      unFlip :: a ~> b
       
      + hunk ./tests/golden-tests/tests/Visible.html.ref 1 -Visible

       

      Visible

      Documentation

      visible :: Int -> Int

      +

       

      Visible

      Documentation

      visible :: Int -> Int

      + }