Bug1

From 9c23d5d3a21c8ef36204a4d66da4cdf488a08f72 Mon Sep 17 00:00:00 2001 From: Ben Gamari Date: Mon, 8 Feb 2016 14:32:41 +0100 Subject: html-test: Accept test output --- html-test/ref/Bug1.html | 37 +++++++++++++++++-------------------- 1 file changed, 17 insertions(+), 20 deletions(-) (limited to 'html-test/ref/Bug1.html') diff --git a/html-test/ref/Bug1.html b/html-test/ref/Bug1.html index 28de3c64..ad864e78 100644 --- a/html-test/ref/Bug1.html +++ b/html-test/ref/Bug1.html @@ -1,32 +1,33 @@ - Bug1

data T = = T

data T

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

+> \ No newline at end of file -- cgit v1.2.3 From 8410dd341a1730f708af3f0d96d13f2b5f7b9df5 Mon Sep 17 00:00:00 2001 From: Phil Ruffwind Date: Wed, 30 Sep 2015 03:22:14 -0400 Subject: Update tests for previous commit --- html-test/ref/A.html | 24 +- html-test/ref/B.html | 14 +- html-test/ref/Bold.html | 6 +- html-test/ref/Bug1.html | 6 +- html-test/ref/Bug195.html | 22 +- html-test/ref/Bug2.html | 4 +- html-test/ref/Bug201.html | 12 +- html-test/ref/Bug253.html | 6 +- html-test/ref/Bug26.html | 28 +- html-test/ref/Bug294.html | 32 +- html-test/ref/Bug298.html | 30 +- html-test/ref/Bug3.html | 4 +- html-test/ref/Bug308.html | 18 +- html-test/ref/Bug308CrossModule.html | 6 +- html-test/ref/Bug310.html | 4 +- html-test/ref/Bug313.html | 12 +- html-test/ref/Bug335.html | 12 +- html-test/ref/Bug387.html | 12 +- html-test/ref/Bug4.html | 4 +- html-test/ref/Bug6.html | 36 +- html-test/ref/Bug7.html | 16 +- html-test/ref/Bug8.html | 34 +- html-test/ref/Bug85.html | 18 +- html-test/ref/BugDeprecated.html | 24 +- html-test/ref/BugExportHeadings.html | 24 +- html-test/ref/Bugs.html | 8 +- html-test/ref/DeprecatedClass.html | 20 +- html-test/ref/DeprecatedData.html | 16 +- html-test/ref/DeprecatedFunction.html | 8 +- html-test/ref/DeprecatedFunction2.html | 4 +- html-test/ref/DeprecatedFunction3.html | 4 +- html-test/ref/DeprecatedModule.html | 4 +- html-test/ref/DeprecatedModule2.html | 4 +- html-test/ref/DeprecatedNewtype.html | 12 +- html-test/ref/DeprecatedReExport.html | 4 +- html-test/ref/DeprecatedRecord.html | 10 +- html-test/ref/DeprecatedTypeFamily.html | 8 +- html-test/ref/DeprecatedTypeSynonym.html | 8 +- html-test/ref/Examples.html | 4 +- html-test/ref/Extensions.html | 6 +- html-test/ref/FunArgs.html | 20 +- html-test/ref/GADTRecords.html | 16 +- html-test/ref/Hash.html | 44 ++- html-test/ref/HiddenInstances.html | 32 +- html-test/ref/HiddenInstancesB.html | 14 +- html-test/ref/Hyperlinks.html | 4 +- html-test/ref/IgnoreExports.html | 8 +- html-test/ref/ImplicitParams.html | 22 +- html-test/ref/Instances.html | 434 +++++++++++++++++------ html-test/ref/Math.html | 4 +- html-test/ref/Minimal.html | 138 ++++--- html-test/ref/ModuleWithWarning.html | 4 +- html-test/ref/Nesting.html | 48 ++- html-test/ref/NoLayout.html | 4 +- html-test/ref/NonGreedy.html | 6 +- html-test/ref/Operators.html | 72 ++-- html-test/ref/OrphanInstances.html | 4 + html-test/ref/OrphanInstancesClass.html | 8 +- html-test/ref/OrphanInstancesType.html | 6 +- html-test/ref/PatternSyns.html | 40 ++- html-test/ref/PromotedTypes.html | 32 +- html-test/ref/Properties.html | 4 +- html-test/ref/QuasiExpr.html | 56 ++- html-test/ref/QuasiQuote.html | 4 +- html-test/ref/SpuriousSuperclassConstraints.html | 34 +- html-test/ref/TH.html | 6 +- html-test/ref/TH2.html | 6 +- html-test/ref/Test.html | 286 +++++++++------ html-test/ref/Threaded.html | 4 +- html-test/ref/Threaded_TH.html | 6 +- html-test/ref/Ticket112.html | 6 +- html-test/ref/Ticket61.html | 10 +- html-test/ref/Ticket75.html | 12 +- html-test/ref/TitledPicture.html | 8 +- html-test/ref/TypeFamilies.html | 182 ++++++++-- html-test/ref/TypeFamilies2.html | 32 +- html-test/ref/TypeOperators.html | 64 ++-- html-test/ref/Unicode.html | 4 +- html-test/ref/Visible.html | 4 +- html-test/ref/ocean.css | 15 +- 80 files changed, 1586 insertions(+), 645 deletions(-) (limited to 'html-test/ref/Bug1.html') diff --git a/html-test/ref/A.html b/html-test/ref/A.html index 73534dc7..b58845e5 100644 --- a/html-test/ref/A.html +++ b/html-test/ref/A.html @@ -89,8 +89,10 @@ window.onload = function () {pageLoad();setSynopsis("mini_A.html");}; >

data A #

A
other :: Int #
test2 :: Bool #
data X #
X
reExport :: Int #
test :: Int #
reExport :: Int #
data X #
X Documentation
foo :: a
:: a #
Some
data T #
T
data T #
data A #
DP A = = ProblemCtor' A #
data TP A = = ProblemCtor A #
problemField :: TO A -> A #
problemField' :: DO A -> A #
gadtField :: ({..} -> GADT A) -> A #
data family DP t :: * #
DP A = = ProblemCtor' A #
Documentation
(<^>) :: (a -> a) -> a -> a
:: (a -> a) -> a -> a #
(<^) :: a -> a -> a
:: a -> a -> a #
(^>) :: a -> a -> a
:: a -> a -> a #
(⋆^) :: a -> a -> a
:: a -> a -> a #
f :: ()
:: () #
Links to Documentation
foo :: Int #
Documentation
f :: ()
:: () # startstart followed by middle followed by middle and end and end
g :: ()
:: () # start Documentation h :: () :: () # start type family a a + b :: Natinfixl 6 # Documentation a :: a :: a # Some text. b :: a :: a # Some text. Documentationf :: () :: () # ExF: g :: () :: () # ExG: Section1Section1 test1 :: Int # Section2Section2 test2 :: Int # Documentationfoo :: Int # data A #
A
someField :: ()
someOtherField :: ()
B
someField :: ()
someOtherField :: ()
C
someField :: ()
someOtherField :: ()
Documentation
x :: A #
Documentation
f :: ()
:: () #
This leading whitespace @@ -73,9 +75,11 @@ should be dropped >
g :: ()
:: () #
But this one diff --git a/html-test/ref/Bug253.html b/html-test/ref/Bug253.html index 2d78880b..36640332 100644 --- a/html-test/ref/Bug253.html +++ b/html-test/ref/Bug253.html @@ -73,9 +73,11 @@ window.onload = function () {pageLoad();setSynopsis("mini_Bug253.html" >Documentation
foo :: ()
:: () #
This link should generate Documentation
f :: ()
:: () # Foo g :: () :: () # Bar class C a where # Methods c_f :: a :: a # C () #
c_f :: ()
:: () #

A Int
data B #
B
b :: Int
data C #
C
c1 :: Int
c2 :: Int
data D #
D Int
newtype E #
E Int
data Foo #
Foo Foo #
class Bar x y
x y #
The Bar class
Foo #
data Typ #
Type (Typ
TFree (Typ
(-->) :: t -> t1 -> Typinfix 9 #
(--->) :: Foldableinfix 9 #
s :: a
:: a #
t :: a
:: a #
main :: a
:: a #
data Foo :: (** where #
Bar :: f x -> Foo
data Baz :: * where #
Baz' :: Baz
data Qux where #
Quux :: QuxDocumentation
foo :: Int #
bar :: Int #
baz :: Int #
one :: Int #
two :: Int #
three :: Int #
Foo
foo :: Int #
Bar
bar :: Int #
Baz
baz :: Int #
One
one :: Int #
Two
two :: Int #
Three
three :: Int #
data A a
a #
Constructors
A a (a -> Int
class SomeClass a where #
Methods
foo :: a -> a
:: a -> a #
class SomeOtherClass a where #
Methods
bar :: a -> a
:: a -> a #
data Foo #
Foo
Bar
data One #
One
Two Documentation
foo :: Int #
bar :: Int #
Documentation
foo :: Int #
Documentation
foo :: Integer #
Documentation
foo :: Int #
Documentation
foo :: Int #
newtype SomeNewType #
SomeNewTypeConst String
newtype SomeOtherNewType #
SomeOtherNewTypeConst StringRe-exported from an other module
foo :: Int #
data Foo #
Foo
fooName :: String
fooValue :: Int
data family SomeTypeFamily k :: * -> * #
data family SomeOtherTypeFamily k :: * -> * #
type TypeSyn = String #
type OtherTypeSyn = String #
Documentation
fib :: Integer -> Integer #
Documentation
foobar :: t
:: t #
Bar
Documentation
f #
g #
h #
i #
j #
data H1 a b where #
Float -> Int #
Int #Int -> Int #
b) => Hash (a, b)#hash :: (a, b) -> Int #
class VisibleClass a
a #
Should be visible
Int #
C1 :: H1
C2 :: Ord
C3 :: {..} -> H1
field :: Int
C4 :: {..} -> H1
field2 :: a
data HashTable key val
key val #
A hash table with keys of type s
new :: (EqIO (HashTable key val)
key val) # Builds a new hash table with a given size insert :: (EqHash key) => key -> val -> IO () () # Inserts a new element into the hash table lookup :: HashIO (Maybe val) val) # Looks up a key in the hash table, returns class Hash a where # Methods hash :: a -> Int # Float #

VisibleData #
data VisibleData #
VisibleData #
VisibleData -> VisibleData #
VisibleData -> VisibleData #
VisibleData -> VisibleData #
VisibleData -> VisibleData #
VisibleData -> VisibleData #
VisibleData -> VisibleData #
Integer -> VisibleData #
VisibleData #
class Foo a
a #
Should be visible
Bar #
data Bar #
Bar #
Documentation
foo :: Int #
Documentation
foo :: Int #
bar :: Int #
data X #
X
c :: (?x :: X) => X #
d :: (?x :: XX, X)
) #
f :: ((?x :: X) => a) -> a
) => a) -> a #
newtype a a <~~ b
b #
Constructors
Int) -> a -> a <~~ a
a #
foo'<~~ Int)
) #
class Foo f where #
Methods
foo :: f Int -> a -> f a
-> a -> f a #
foo' :: f (f a) -> Int -> f (f Int)
) #
Foo [] #
foo :: [Int] -> a -> [a]
] -> a -> [a] #
foo'Int -> [[Int]]
]] #
Maybe #Int -> a -> Maybe a
a #
foo'Maybe Int)
) #
Foo ((->) a)#foo :: (a -> Int) -> a -> a -> a
) -> a -> a -> a #
foo'Int -> a -> a -> Int #
(Either a)#Int -> a -> Either a a
a a #
foo'Either a Int)
) #
((,) (f a))#foo :: (f a, Int) -> a -> (f a, a)
) -> a -> (f a, a) #
foo'Int -> (f a, (f a, Int))
)) #
((<~~) a)#Int) -> a -> a <~~ a
a #
foo'<~~ Int)
) #
((,,) a a)#foo :: (a, a, Int) -> a -> (a, a, a)
) -> a -> (a, a, a) #
foo'Int -> (a, a, (a, a, Int))
)) #
(Quux a b)#Int -> a -> Quux a b a
a b a #
foo'Quux a b Int)
) #
classFoo f => f => Bar f a where#
Methods
bar :: f a -> f Bool -> a
-> a #
bar' :: f (f a) -> f (f (f b))
:: f (f a) -> f (f (f b)) #
bar0, , bar1 :: (f a, f a) -> (f b, f c)
:: (f a, f a) -> (f b, f c) #
Bool #
Bool -> Bool #
Maybe (Maybe b))
b)) #
bar0Maybe b, Maybe c)
c) #
bar1Maybe b, Maybe c)
c) #
Maybe [a]#MaybeBool -> [a]
-> [a] #
bar'Maybe (Maybe b))
b)) #
bar0Maybe b, Maybe c)
c) #
bar1Maybe b, Maybe c)
c) #
Bar [] (a, a)#bar :: [(a, a)] -> [Bool] -> (a, a)
] -> (a, a) #
bar' :: [[(a, a)]] -> [[[b]]]
:: [[(a, a)]] -> [[[b]]] #
bar0 :: ([(a, a)], [(a, a)]) -> ([b], [c])
:: ([(a, a)], [(a, a)]) -> ([b], [c]) #
bar1 :: ([(a, a)], [(a, a)]) -> ([b], [c])
:: ([(a, a)], [(a, a)]) -> ([b], [c]) #
(Either a) (f a)#Either a Bool -> f a
-> f a #
bar'Either a (Either a b))
a b)) #
bar0Either a b, Either a c)
a c) #
bar1Either a b, Either a c)
a c) #
((,,) a b) (a, b, a)#bar :: (a, b, (a, b, a)) -> (a, b, Bool) -> (a, b, a)
) -> (a, b, a) #
bar' :: (a, b, (a, b, (a, b, a))) -> (a, b, (a, b, (a, b, b)))
:: (a, b, (a, b, (a, b, a))) -> (a, b, (a, b, (a, b, b))) #
bar0 :: ((a, b, (a, b, a)), (a, b, (a, b, a))) -> ((a, b, b), (a, b, c))
:: ((a, b, (a, b, a)), (a, b, (a, b, a))) -> ((a, b, b), (a, b, c)) #
bar1 :: ((a, b, (a, b, a)), (a, b, (a, b, a))) -> ((a, b, b), (a, b, c))
:: ((a, b, (a, b, a)), (a, b, (a, b, a))) -> ((a, b, b), (a, b, c)) #
a c) (Quux a b c)#Bool -> Quux a b c
a b c #
bar'Quux a c (Quux a c b))
a c b)) #
bar0Quux a c b, Quux a c c)
a c c) #
bar1Quux a c b, Quux a c c)
a c c) #
class Baz a where #
Methods
baz :: a -> (forall a. a -> a) -> (b, forall c. c -> a) -> (b, c)
c. c -> a) -> (b, c) #
baz' :: b -> (forall b. b -> a) -> (forall b. b -> a) -> [(b, a)]
b. b -> a) -> [(b, a)] #
baz'' :: b -> (forallforall b. b -> a) -> c) -> forall c. c -> b
c. c -> b #
Baz [c] #
forall a. a -> a) -> (b, forall a. a -> [c]) -> (b, c)
a. a -> [c]) -> (b, c) #
baz'forall b. b -> [c]) -> (forall b. b -> [c]) -> [(b, [c])]
b. b -> [c]) -> [(b, [c])] #
baz''forall a. a -> [c]) -> c) -> forall a. a -> b
a. a -> b #
Baz (a -> b)#forall c. c -> c) -> (b, forall c. c -> a -> b) -> (b, c)
c. c -> a -> b) -> (b, c) #
baz'forall c. c -> a -> b) -> (forall c. c -> a -> b) -> [(b, a -> b)]
c. c -> a -> b) -> [(b, a -> b)] #
baz''forall d. d -> a -> b) -> c) -> forall c. c -> b
c. c -> b #
Baz (a, b, c)#forall d. d -> d) -> (b, forall d. d -> (a, b, c)) -> (b, c)
d. d -> (a, b, c)) -> (b, c) #
baz'forall d. d -> (a, b, c)) -> (forall d. d -> (a, b, c)) -> [(b, (a, b, c))]
d. d -> (a, b, c)) -> [(b, (a, b, c))] #
baz''forall e. e -> (a, b, c)) -> c) -> forall d. d -> b
d. d -> b #
(Quux a b c)#forall d. d -> Quux a b c) -> (b, c)
a b c) -> (b, c) #
baz'Quux a b c) -> [(b, Quux a b c)]
a b c)] #
baz''Quux a b c) -> c) -> forall d. d -> b
d. d -> b #
Baz (a, [b], b, a)#forall c. c -> c) -> (b, forall c. c -> (a, [b], b, a)) -> (b, c)
c. c -> (a, [b], b, a)) -> (b, c) #
baz'forall c. c -> (a, [b], b, a)) -> (forall c. c -> (a, [b], b, a)) -> [(b, (a, [b], b, a))]
c. c -> (a, [b], b, a)) -> [(b, (a, [b], b, a))] #
baz''forall d. d -> (a, [b], b, a)) -> c) -> forall c. c -> b
c. c -> b #
data Quux a b c
a b c #
Constructors
Xyzzy (b -> (a, a)) ((<~~) a) #
Int -> a -> Quux a b a
a b a #
foo'Quux a b Int)
) #
a c) (Quux a b c)#Bool -> Quux a b c
a b c #
bar'Quux a c (Quux a c b))
a c b)) #
bar0Quux a c b, Quux a c c)
a c c) #
bar1Quux a c b, Quux a c c)
a c c) #
(Quux a b c)#forall d. d -> Quux a b c) -> (b, c)
a b c) -> (b, c) #
baz'Quux a b c) -> [(b, Quux a b c)]
a b c)] #
baz''Quux a b c) -> c) -> forall d. d -> b
d. d -> b #
Quux a [a] c)
= = Thuud a
| | Thuuud Int
#
class Norf a b where #
type Plugh a c b
a c b #
data Thud a c
a c #
Methods
norf :: Plugh a c b -> a -> (a -> c) -> b
a c b -> a -> (a -> c) -> b #
Bool #
Bool :: *#
Int c :: * #
Int -> c) -> Bool #
Norf [a] [b]#Plugh [a] c [b] :: *#
Thud [a] c :: * #
norf :: Plugh [a] c [b] -> [a] -> ([a] -> c) -> [b]
[a] c [b] -> [a] -> ([a] -> c) -> [b] #
Documentation
f :: Integer #
class Foo a where #
Methods
foo :: a
:: a #
Any two of these are required...
bar :: a
:: a #
bat :: a
:: a #
fooBarBat :: (a, a, a)
:: (a, a, a) #
.. or just this
class Weird a where #
Methods
a :: a
:: a #
b :: a
:: a #
c :: a
:: a #
d :: a
:: a #
e :: a
:: a #
f :: a
:: a #
g :: a
:: a #
class NoMins a where #
Methods
x :: a
:: a #
y :: a
:: a #
z :: a
:: a #
class FullMin a where #
Methods
aaa :: a
:: a #
bbb :: a
:: a #
class PartialMin a where #
Methods
ccc :: a
:: a #
class EmptyMin a where #
Methods
eee :: a
:: a #
fff :: a
:: a #
Documentation
foo :: Int #
Documentation
d :: t
:: t #
e :: t
:: t #
f :: t
:: t #
g :: t
:: t #
h :: t
:: t #
i :: t
:: t #
j :: t
:: t #
k :: t
:: t #
Documentation
g :: Int #
Documentation
f :: a
:: a #
Documentation
(+-) :: a -> a -> a
:: a -> a -> a #
Operator with no fixity
(*/) :: a -> a -> a infixr 7 #
foo :: a -> a -> a infixl 3 #
data Foo #
Qx a
Qux a b
Quux a b c (Quux a b) # Foo `Bar` Foo Foo :- Foo
pattern (:+) :: forallinfixr 3 #
data a a <-> b whereinfixl 6 #
(:<->) :: a -> b -> a <->
type family a a ++ b infix 3 #
data family a a ** b infix 9 #
class a a ><> b | a -> b whereinfixr 1 #
type a a <>< b :: *infixl 2 #
data a a ><< b infixl 3 #
Methods
(>><), , (<<>) :: a -> b -> () infixl 5 <<>infixr 4 >>< #
(**>), , (**<), , (>**), , (<**) :: a -> a -> () infixr 8 **>, >**infixl 8 **<, <** #
type (>-<) a b = a <->infixl 6 #
AType #
AType -> Int #
class AClass a where #
Methods
aClass :: a -> Int #
data AType #
AType Int
data FooType x
x #
FooType doc
FooCtor x
pattern Foo :: forall t. t -> FooType t
t #
Pattern synonym for
pattern Bar :: forallFooType (FooType t)
t) # Pattern synonym for pattern (:<->) :: forallFooType (FooType t)) t)) # Pattern synonym for ( data a a >< b b # Doc for (Empty pattern E :: forall k t t. (><) k t t k t t # Pattern for data RevList a a # Constructors RNil (RevList a) a) :> a data Pattern :: [** where # Nil :: Pattern Cons :: Maybedata RevPattern :: RevList* where # RevNil :: RevPattern RevCons :: Maybedata Tuple :: (** where # Tuple :: a -> b -> TupleDocumentationfib :: Integer -> Integer # data Expr # Expr -> ShowS# Expr -> String # Expr] -> ShowS # data BinOp # IntExpr Integer AntiIntExpr String BinopExpr BinOp AntiExpr String Expr # BinOp -> ShowS# BinOp -> String # BinOp] -> ShowS # eval :: Expr -> Integer # expr :: QuasiQuoter :: QuasiQuoter # parseExprExp :: String -> Q Exp -> Q Exp # Documentationval :: Integer # data SomeType f a f a # Instances (SomeType f) # SomeType f a -> SomeType f b f b # (<$)SomeType f b -> SomeType f a f a # (SomeType f)#pure :: a -> SomeType f a f a # (<*>)SomeType f a -> SomeType f b f b # (*>)SomeType f b -> SomeType f b f b # (<*)SomeType f b -> SomeType f a f a # Documentationdecl :: Q [Dec] :: Q [Dec] # Documentationf :: t -> t :: t -> t # data T a b a b # This comment applies to the AddOp SubOp MulOp DivOp BinOp # A Int B (Tdata T2 a b a b # An abstract data declaration data T3 a b a b # A data declaration with no documentation annotations on the constructors A1 a B1 b data T4 a b a b # Constructors A2 a B2 b data T5 a b a b # Constructors A3 a B3 b data T6 # A4 B4 C4 newtype N1 a a # A newtype N1 a newtype N2 a b a b # A newtype with a fieldname N2 n :: a bnewtype N3 a b a b # A newtype with a fieldname, documentation on the field N3 n3 :: a bdata N4 a b a b # An abstract newtype - we show this one as data rather than newtype because @@ -1014,16 +1034,18 @@ window.onload = function () {pageLoad();setSynopsis("mini_Test.html"); > newtype N5 a b a b # Constructors N5 n5 :: a bnewtype N6 a b a b # Constructors N6 n6 :: a bnewtype N7 a b a b # docs on the newtype and the constructor N7 n7 :: a bdata R # C1 p :: Int q :: forall r, , s :: Int C2 t :: T1 -> T2 u, , v :: Intdata R1 # TFloat b b # eFloat, Float) ) # Int#TInt b b # eInt, Int) ) # class E a a # This is a class declaration with no methods (or no methods exported) class F a where # Methods ff :: a :: a # a :: C a => IO a a # this is a description of the Function types f :: C a => a -> Int # g :: Int -> IO CInt CInt # we can export foreign declarations too A hidden modulehidden :: Int -> Int # data Ex a a # A data-type using existential/universal types C3 s1 :: Int s2 :: Int s3 :: Intclass D a => a => C a where # Methods a :: IO a a # this is a description of the method b :: [a] :: [a] # this is a description of the class D a where # Methods d :: T a b a b # e :: (a, a) :: (a, a) # Float # C b => b => Ex1 b Ex2 b C a => a => Ex3 b Ex4 (forallType signatures with argument docsk # l # m # o # f' :: Int # withType :: Int # withoutType :: a :: a # Comment on a definition without type signature Documentationf :: Integer # Documentation forkTH :: Q Exp :: Q Exp # forkOS requires the threaded RTS, so this TH fails if haddock was diff --git a/html-test/ref/Ticket112.html b/html-test/ref/Ticket112.html index 42e9cf13..6f42cff6 100644 --- a/html-test/ref/Ticket112.html +++ b/html-test/ref/Ticket112.html @@ -57,9 +57,11 @@ window.onload = function () {pageLoad();setSynopsis("mini_Ticket112.html&qu >Documentation f :: a :: a # ...given a raw class C a where # Methods f :: a :: a # A comment about f data a a :- b b # Constructors Q f :: Int # Documentation foo :: Integer # bar :: Integer # data X # X# = X#*X = = AssocX#X#X= = BatX X | | BatXX { aaa :: X bbb :: Y } # a = X#data Y # Y # *Y = = AssocY#Y#*Y = = BatYY#Y a = a#data Z # X XX XXX XXX # X) :: * # X) :: * # X # = Y # = Y # Y) :: * # Y) :: * # Y # Y # = X # = Y#data family Bat a :: * # where BatZ1 :: BatZA BatZ2 :: Bat # Y a = a# a = X#class a a >< b b # Instances XXX # data W # Bar W = = BarX Z # type family Foo a a # Exported type family W # = Y#data family Bar a a # Exported data family Bar W = = BarX Z # data a a :-: b b # data (a (a :+: b) c b) c # data Op a b a b # newtype O g f a g f a # Constructors ZA ZB whereBatZ1 :: BatZA BatZ2 :: Bat # class Test a a # Doc for: class Test a Y # X # type family Foo a :: k a :: k # Doc for: type family Foo a = X # * Y = = BatY Y # X = = BatX X | | BatXX { aaa :: X bbb :: Y } # class Assoc a a # Doc for: class Assoc a data AssocD a :: * # type AssocT a :: * # Y # Y) :: * # Y) :: * # X # X) :: * # X) :: * # type family Bar b b # Doc for: type family Bar b type family a a <> b :: k b :: k # Instances = X # W # Y # O unO :: g (f a)class a a <=> b b # biO :: (g `O` f) a f) a # f :: a ~ b => a -> b :: a ~ b => a -> b # g :: (a ~ b, b ~ c) => a -> c :: (a ~ b, b ~ c) => a -> c # x :: (a :-:<=> (a `Op` a) => a a) => a # y :: (a <=>`Op` a) <=> a) => a a) => a # Documentationx :: Int # Documentation visible :: Int -> Int #

ExF:

ExG:

Section1Section1

Section2Section2

Bar

Baz

One

data Ex a a #A data-type using existential/universal types

data Ex a
a #
A data-type using existential/universal types