From 56c0e317093d2e25412cfa7dd10099c1fe729640 Mon Sep 17 00:00:00 2001 From: Alexander Biehl Date: Sun, 17 Dec 2017 11:40:03 +0100 Subject: Treat escaped \] better in definition lists (#717) This fixes #546. --- html-test/ref/Bug546.html | 273 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 273 insertions(+) create mode 100644 html-test/ref/Bug546.html (limited to 'html-test/ref/Bug546.html') diff --git a/html-test/ref/Bug546.html b/html-test/ref/Bug546.html new file mode 100644 index 00000000..1ed6657f --- /dev/null +++ b/html-test/ref/Bug546.html @@ -0,0 +1,273 @@ +Bug546

Safe Haskell	Safe

Bug546

Synopsis

x :: Integer
compile :: String -> String

Documentation

x :: Integer #

Test:

[code with square \ brackets]: lorem ipsum

compile :: String -> String #

[..]: Matches any of the enclosed characters. Ranges of characters can + be specified by separating the endpoints with a '-'. '-' or + ']' can be matched by including them as the first character(s) + in the list. Never matches path separators: [/] matches + nothing at all. Named character classes can also be matched: + [:x:] within [] specifies the class named x, which matches + certain predefined characters. See below for a full list.
[^..] or [!..]: Like [..], but matches any character not listed. + Note that [^-x] is not the inverse of [-x], but + the range [^-x].
<m-n>: Matches any integer in the range m to n, inclusive. The range may + be open-ended by leaving out either number: "<->", for + instance, matches any integer.
**/: Matches any number of characters, including path separators, + excluding the empty string.

Supported character classes:

[:alnum:]: Equivalent to "0-9A-Za-z".
[:alpha:]: Equivalent to "A-Za-z".
[:blank:]: Equivalent to "\t ".
[:cntrl:]: Equivalent to "\0-\x1f\x7f".
[:digit:]: Equivalent to "0-9".
[:graph:]: Equivalent to "!-~".
[:lower:]: Equivalent to "a-z".
[:print:]: Equivalent to " -~".
[:punct:]: Equivalent to "!-/:-@[-`{-~".
[:space:]: Equivalent to "\t-\r ".
[:upper:]: Equivalent to "A-Z".
[:xdigit:]: Equivalent to "0-9A-Fa-f".

\ No newline at end of file -- cgit v1.2.3 From 69b98a99ce4de93ea0e6082bd11edb3baaf2fa6e Mon Sep 17 00:00:00 2001 From: Alexander Biehl Date: Fri, 2 Mar 2018 15:43:21 +0100 Subject: Make testsuite work with haddock-1.19.0 release (#766) --- html-test/Main.hs | 15 + html-test/ref/A.html | 12 +- html-test/ref/Bug1.html | 2 +- html-test/ref/Bug2.html | 2 +- html-test/ref/Bug253.html | 2 +- html-test/ref/Bug26.html | 4 +- html-test/ref/Bug280.html | 2 +- html-test/ref/Bug294.html | 154 +++++- html-test/ref/Bug298.html | 8 +- html-test/ref/Bug3.html | 4 +- html-test/ref/Bug310.html | 16 +- html-test/ref/Bug387.html | 8 +- html-test/ref/Bug4.html | 4 +- html-test/ref/Bug546.html | 12 +- html-test/ref/Bug548.html | 244 +++++----- html-test/ref/Bug6.html | 78 ++-- html-test/ref/Bug613.html | 26 +- html-test/ref/Bug647.html | 2 +- html-test/ref/Bug679.html | 18 +- html-test/ref/Bug7.html | 12 +- html-test/ref/Bug8.html | 16 +- html-test/ref/Bug85.html | 16 +- html-test/ref/BugDeprecated.html | 24 +- html-test/ref/BugExportHeadings.html | 24 +- html-test/ref/Bugs.html | 2 +- html-test/ref/BundledPatterns.html | 64 +-- html-test/ref/BundledPatterns2.html | 98 ++-- html-test/ref/ConstructorPatternExport.html | 18 +- html-test/ref/DeprecatedClass.html | 4 +- html-test/ref/DeprecatedFunction.html | 10 +- html-test/ref/DeprecatedFunction2.html | 4 +- html-test/ref/DeprecatedFunction3.html | 4 +- html-test/ref/DeprecatedModule.html | 2 +- html-test/ref/DeprecatedModule2.html | 2 +- html-test/ref/DeprecatedNewtype.html | 8 +- html-test/ref/DeprecatedReExport.html | 6 +- html-test/ref/DeprecatedRecord.html | 8 +- html-test/ref/DeprecatedTypeFamily.html | 16 +- html-test/ref/DeprecatedTypeSynonym.html | 8 +- html-test/ref/Examples.html | 10 +- html-test/ref/FunArgs.html | 8 +- html-test/ref/GADTRecords.html | 34 +- html-test/ref/Hash.html | 80 ++-- html-test/ref/HiddenInstances.html | 50 +- html-test/ref/HiddenInstancesB.html | 8 +- html-test/ref/Hyperlinks.html | 4 +- html-test/ref/ImplicitParams.html | 14 +- html-test/ref/Instances.html | 566 +++++++++++------------ html-test/ref/Math.html | 4 +- html-test/ref/Minimal.html | 24 +- html-test/ref/ModuleWithWarning.html | 2 +- html-test/ref/NoLayout.html | 6 +- html-test/ref/Operators.html | 40 +- html-test/ref/OrphanInstances.html | 18 +- html-test/ref/OrphanInstancesClass.html | 52 ++- html-test/ref/OrphanInstancesType.html | 50 +- html-test/ref/PatternSyns.html | 72 +-- html-test/ref/PromotedTypes.html | 40 +- html-test/ref/Properties.html | 10 +- html-test/ref/QuasiExpr.html | 54 +-- html-test/ref/QuasiQuote.html | 2 +- html-test/ref/SpuriousSuperclassConstraints.html | 48 +- html-test/ref/Table.html | 2 +- html-test/ref/Test.html | 424 ++++++++++------- html-test/ref/Threaded.html | 4 +- html-test/ref/Ticket112.html | 2 +- html-test/ref/Ticket61.html | 2 +- html-test/ref/Ticket75.html | 6 +- html-test/ref/TitledPicture.html | 12 +- html-test/ref/TypeFamilies.html | 544 +++++++++------------- html-test/ref/TypeFamilies2.html | 50 +- html-test/ref/TypeOperators.html | 14 +- html-test/ref/Unicode.html | 4 +- html-test/ref/Visible.html | 4 +- 74 files changed, 1687 insertions(+), 1536 deletions(-) (limited to 'html-test/ref/Bug546.html') diff --git a/html-test/Main.hs b/html-test/Main.hs index 67dbeec6..d65a5087 100755 --- a/html-test/Main.hs +++ b/html-test/Main.hs @@ -47,7 +47,22 @@ stripIfRequired mdl = preserveLinksModules :: [String] preserveLinksModules = ["Bug253"] +ingoredTests :: [FilePath] +ingoredTests = + [ + -- Currently some declarations are exported twice + -- we need a reliable way to deduplicate here. + -- Happens since PR #688. + "B" + + -- ignore-exports flag broke with PR #688. We use + -- the Avails calculated by GHC now. Probably + -- requires a change to GHC to "ignore" a modules + -- export list reliably. + , "IgnoreExports" + ] checkIgnore :: FilePath -> Bool +checkIgnore file | takeBaseName file `elem` ingoredTests = True checkIgnore file@(c:_) | takeExtension file == ".html" && isUpper c = False checkIgnore _ = True diff --git a/html-test/ref/A.html b/html-test/ref/A.html index 1fbfb371..e4802966 100644 --- a/html-test/ref/A.html +++ b/html-test/ref/A.html @@ -54,13 +54,13 @@ >

other :: :: Int

test2 :: :: Bool

reExport :: :: Int

other :: :: Int #

test2 :: :: Bool #

reExport :: :: Int #

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

x :: :: A #This link should generate #v anchor: fakeFakeFake

Minimal complete definition

c_f

C ()

x :: [ :: [Char] # data DP A

data DP A = ProblemCtor' A

data TP TP A

data TP TP A = ProblemCtor A

problemField :: TO :: TO A -> -> A #

problemField' :: DO :: DO A -> -> A #

gadtField :: ({..} -> GADT :: ({..} -> GADT A) -> ) -> A #

data family TP t :: * #

Instances

data TP A #
Instance details data TP A = ProblemCtor A

data family DP t :: t :: * # data DP A

data DP A = ProblemCtor' A

data family TO' t :: * #

Instances

data TO' a #
Instance details data TO' a = PolyCtor

test1 :: :: Int

test2 :: :: Int

test1 :: :: Int #

test2 :: :: Int #

foo :: :: Int

foo :: :: Int #

x :: :: Integer

compile :: :: String -> -> String

x :: :: Integer #

compile :: :: String -> -> String #newtype WrappedArrow (a :: (a :: * -> -> * -> -> *) b c # Generic1 * ( (WrappedArrow a b) a b :: * -> *)

type Rep1 (WrappedArrow a b) (f :: (WrappedArrow a b -> *) :: k -> a b) :: k -> * #

from1 :: f a0 -> :: WrappedArrow a b a0 -> Rep1 ( (WrappedArrow a b) f a0 a b) a0 #

to1 :: :: Rep1 ( (WrappedArrow a b) a0 -> WrappedArrow a b) f a0 -> f a0 a b a0 #

Arrow a => a => Functor ( (WrappedArrow a b)

fmap :: (a0 -> b0) -> :: (a0 -> b0) -> WrappedArrow a b a0 -> a b a0 -> WrappedArrow a b b0 #

(<$) :: a0 -> :: a0 -> WrappedArrow a b b0 -> a b b0 -> WrappedArrow a b a0 # Arrow a => a => Applicative ( (WrappedArrow a b)

pure :: a0 -> :: a0 -> WrappedArrow a b a0 #

(<*>) :: :: WrappedArrow a b (a0 -> b0) -> a b (a0 -> b0) -> WrappedArrow a b a0 -> a b a0 -> WrappedArrow a b b0 #

liftA2 :: (a0 -> b0 -> c) -> :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> a b a0 -> WrappedArrow a b b0 -> a b b0 -> WrappedArrow a b c #

(*>) :: :: WrappedArrow a b a0 -> a b a0 -> WrappedArrow a b b0 -> a b b0 -> WrappedArrow a b b0 #

(<*) :: :: WrappedArrow a b a0 -> a b a0 -> WrappedArrow a b b0 -> a b b0 -> WrappedArrow a b a0 # ( (ArrowZero a, a, ArrowPlus a) => a) => Alternative ( (WrappedArrow a b)

empty :: :: WrappedArrow a b a0 #

(<|>) :: :: WrappedArrow a b a0 -> a b a0 -> WrappedArrow a b a0 -> a b a0 -> WrappedArrow a b a0 #

some :: :: WrappedArrow a b a0 -> a b a0 -> WrappedArrow a b [a0] #

many :: :: WrappedArrow a b a0 -> a b a0 -> WrappedArrow a b [a0] # Generic ( (WrappedArrow a b c)

type Rep ( (WrappedArrow a b c) :: a b c) :: * -> -> * #

from :: :: WrappedArrow a b c -> a b c -> Rep ( (WrappedArrow a b c) x #

to :: :: Rep ( (WrappedArrow a b c) x -> a b c) x -> WrappedArrow a b c # type Rep1 * ( (WrappedArrow a b) a b :: * -> *)

type Rep1 * ( (WrappedArrow a b) = D1 a b :: * ( -> *) = D1 (MetaData "WrappedArrow" "Control.Applicative" "base" "WrappedArrow" "Control.Applicative" "base" True) () (C1 * ( (MetaCons "WrapArrow" "WrapArrow" PrefixI True) () (S1 * ( (MetaSel ( (Just Symbol "unwrapArrow") "unwrapArrow") NoSourceUnpackedness NoSourceStrictness DecidedLazy) () (Rec1 * (a b))))

type Rep ( (WrappedArrow a b c)

type Rep ( (WrappedArrow a b c) = a b c) = D1 * ( (MetaData "WrappedArrow" "Control.Applicative" "base" "WrappedArrow" "Control.Applicative" "base" True) () (C1 * ( (MetaCons "WrapArrow" "WrapArrow" PrefixI True) () (S1 * ( (MetaSel ( (Just Symbol "unwrapArrow") "unwrapArrow") NoSourceUnpackedness NoSourceStrictness DecidedLazy) () (Rec0 * (a b c))))

A = A Int

B = B {

b :: Int

}

Int

b :: B -> Int

data

c1 :: :: Int

c2 :: :: Int

D = D Int Int

E = E Int

A Int B Int

Fields

b :: Int

b :: B -> Int #

datac1 :: :: Int

c2 :: :: Int

D Int Int E Int

Minimal complete definition

fmap

Functor ( (Either a)

fmap :: (a0 -> b) -> :: (a0 -> b) -> Either a a0 -> a a0 -> Either a b # Functor ( (ThreeVars a0 a)

fmap :: (a1 -> b) -> :: (a1 -> b) -> ThreeVars a0 a a1 -> a0 a a1 -> ThreeVars a0 a b # Functor ( (ThreeVars a0 a)

fmap :: (a1 -> b) -> :: (a1 -> b) -> ThreeVars a0 a a1 -> a0 a a1 -> ThreeVars a0 a b #

Minimal complete definition

Foo ( (Bar a)

foo :: :: Bar a -> a -> Bar a #

Minimal complete definition

foo

Foo ( (Bar a)

foo :: :: Bar a -> a -> Bar a # Bar Foo Foo Bar Foo Foo Type ( (Typ, [, [Typ])TFree ( (Typ, [, [Typ])

(-->) :: p1 -> p2 -> :: p1 -> p2 -> Typ infix 9

(--->) :: :: Foldable t0 => t0 t -> t0 => t0 t -> Typ -> -> Typ infix 9data Foo :: ( :: (* -> -> *) -> ) -> * -> -> * whereBar :: f x -> :: f x -> Foo f (f x)data Baz :: :: * whereBaz' :: :: Baz Quux :: :: Qux

foo :: :: Int

bar :: :: Int

baz :: :: Int

one :: :: Int

two :: :: Int

three :: :: Int

foo :: :: Int #

bar :: :: Int #

baz :: :: Int #

one :: :: Int #

two :: :: Int #

three :: :: Int #

foo :: :: Int

bar :: :: Int

baz :: :: Int

one :: :: Int

two :: :: Int

three :: :: Int

foo :: :: Int #

bar :: :: Int #

baz :: :: Int #

one :: :: Int #

two :: :: Int #

three :: :: Int #A a (a -> a (a -> Int)data Vec :: :: Nat -> -> * -> -> * where

Nil :: :: Vec 0 a

pattern (:>) :: a -> :: a -> Vec n a -> n a -> Vec (n (n + 1) a

data RTree :: :: Nat -> -> * -> -> * wherepattern LR :: a -> :: a -> RTree 0 a

pattern BR :: :: RTree d a -> d a -> RTree d a -> d a -> RTree (d (d + 1) a

data Vec :: :: Nat -> -> * -> -> * whereLists with their length encoded in their type

Vector elements have an subscript starting from 0 and ending at length - 1Nil :: :: Vec 0 apattern (:>) :: a -> :: a -> Vec n a -> n a -> Vec (n (n + 1) a infixr 5data RTree :: :: Nat -> -> * -> -> * wherepattern LR :: a -> :: a -> RTree 0 apattern BR :: :: RTree d a -> d a -> RTree d a -> d a -> RTree (d (d + 1) adata Vec :: :: Nat -> -> * -> -> * wherepattern Empty :: (:>) :: a -> Vec 0 a

n a -> Vec (n + 1) a
pattern (:>) :: a -> Vec n a -> Empty :: Vec (n + 1) a
0 a
data RTree :: :: Nat -> -> * -> -> * wherepattern LR :: a -> :: a -> RTree 0 a
pattern BR :: :: RTree d a -> d a -> RTree d a -> d a -> RTree (d (d + 1) a
data Vec :: :: Nat -> -> * -> -> * whereLists with their length encoded in their type
Vector elements have an subscript starting from 0 and ending at length - 1Bundled Patterns
pattern Empty :: Vec 0 a
pattern (:>) :: a -> :: a -> Vec n a -> n a -> Vec (n (n + 1) a infixr 5
pattern Empty :: Vec 0 a
data RTree :: :: Nat -> -> * -> -> * wherepattern LR :: a -> :: a -> RTree 0 apattern BR :: :: RTree d a -> d a -> RTree d a -> d a -> RTree (d (d + 1) apattern FooCons :: :: String -> a -> Foo a #pattern MyRecCons :: :: Bool -> -> Int -> MyRec #pattern (:+) :: :: String -> a -> MyInfix a #pattern BlubCons :: () => :: () => Show b => b -> Blub #MyGADTCons :: () => forall a. a. Eq a => a -> a => a -> Int -> MyGADT ( -> MyGADT (Maybe String) #
Minimal complete definition
foo
Minimal complete definition
bar
foo :: :: Int
bar :: :: Int
foo :: :: Int #
Deprecated: use bar instead
bar :: :: Int #
foo :: :: Int
foo :: :: Int #
foo :: :: Integer
foo :: :: Integer #
foo :: :: Int #
foo :: :: Int #SomeNewType = SomeNewTypeConst String
SomeOtherNewType = SomeOtherNewTypeConst String
SomeNewTypeConst String SomeOtherNewTypeConst String
foo :: :: Int
foo :: :: Int #
Deprecated: use bar instead
fooName :: :: String
fooValue :: :: Int
fooName :: :: String
fooValue :: :: Int
data family SomeTypeFamily k :: k :: * -> -> *
data family SomeOtherTypeFamily k :: k :: * -> -> *
data family SomeTypeFamily k :: k :: * -> -> * #data family SomeOtherTypeFamily k :: k :: * -> -> * #type TypeSyn = = String
type OtherTypeSyn = = String
type TypeSyn = = String #type OtherTypeSyn = = String #
fib :: :: Integer -> -> Integer
fib :: :: Integer -> -> Integer #
Fibonacci number of given Integer.
foo :: (LiftedRep -> LiftedRep) a :: (a -> Int -> a0 -> (LiftedRep -> LiftedRep) a a0 ) -> a0 -> a -> a0 #
foo' :: (LiftedRep -> LiftedRep) a ((LiftedRep -> LiftedRep) a a0) -> :: (a -> a -> a0) -> Int -> (LiftedRep -> LiftedRep) a ((LiftedRep -> LiftedRep) a -> a -> a -> Int) #
class Foo f => Bar
bar :: f a -> f :: f a -> f Bool -> a # Bar Maybe Bool
bar :: :: Maybe Bool -> -> Maybe Bool -> -> Bool #
bar' :: :: Maybe ( (Maybe Bool) -> ) -> Maybe ( (Maybe ( (Maybe b)) #
bar0 :: ( :: (Maybe Bool, , Maybe Bool) -> () -> (Maybe b, b, Maybe c) #
bar1 :: ( :: (Maybe Bool, , Maybe Bool) -> () -> (Maybe b, b, Maybe c) # Bar Maybe [a]
bar :: :: Maybe [a] -> [a] -> Maybe Bool -> [a] #
bar' :: :: Maybe ( (Maybe [a]) -> [a]) -> Maybe ( (Maybe ( (Maybe b)) #
bar0 :: ( :: (Maybe [a], [a], Maybe [a]) -> ( [a]) -> (Maybe b, b, Maybe c) #
bar1 :: ( :: (Maybe [a], [a], Maybe [a]) -> ( [a]) -> (Maybe b, b, Maybe c) # Bar [] (a, a)
bar :: [(a, a)] -> [ :: [(a, a)] -> [Bool] -> (a, a) # Foo f => f => Bar ( (Either a) (f a)
bar :: :: Either a (f a) -> a (f a) -> Either a a Bool -> f a #
bar' :: :: Either a ( a (Either a (f a)) -> a (f a)) -> Either a ( a (Either a ( a (Either a b)) #
bar0 :: ( :: (Either a (f a), a (f a), Either a (f a)) -> ( a (f a)) -> (Either a b, a b, Either a c) #
bar1 :: ( :: (Either a (f a), a (f a), Either a (f a)) -> ( a (f a)) -> (Either a b, a b, Either a c) # Foo ( ((,,) a b) => a b) => Bar ( ((,,) a b) (a, b, a)
bar :: (a, b, (a, b, a)) -> (a, b, :: (a, b, (a, b, a)) -> (a, b, Bool) -> (a, b, a) # Bar ( (Quux a c) ( a c) (Quux a b c)
bar :: :: Quux a c ( a c (Quux a b c) -> a b c) -> Quux a c a c Bool -> -> Quux a b c #
bar' :: :: Quux a c ( a c (Quux a c ( a c (Quux a b c)) -> a b c)) -> Quux a c ( a c (Quux a c ( a c (Quux a c b0)) #
bar0 :: ( :: (Quux a c ( a c (Quux a b c), a b c), Quux a c ( a c (Quux a b c)) -> ( a b c)) -> (Quux a c b0, a c b0, Quux a c c0) #
bar1 :: ( :: (Quux a c ( a c (Quux a b c), a b c), Quux a c ( a c (Quux a b c)) -> ( a b c)) -> (Quux a c b0, a c b0, Quux a c c0) # Baz [c] Baz (a -> b) Baz (a, b, c) Baz ( (Quux a b c)
baz :: :: Quux a b c -> (forall a0. a0 -> a0) -> (b0, forall c0. c0 -> c0. c0 -> Quux a b c) -> (b0, c1) #baz' :: b0 -> (forall b1. b1 -> b1. b1 -> Quux a b c) -> (forall b2. b2 -> b2. b2 -> Quux a b c) -> [(b0, a b c) -> [(b0, Quux a b c)] #forall b1. (forall b2. b2 -> b2. b2 -> Quux a b c) -> c0) -> forall Baz (a, [b], b, a) Foo ( (Quux a b)
foo :: :: Quux a b a b Int -> a0 -> -> a0 -> Quux a b a0 #
foo' :: :: Quux a b ( a b (Quux a b a0) -> a b a0) -> Int -> -> Quux a b ( a b (Quux a b a b Int) # Bar ( (Quux a c) ( a c) (Quux a b c)
bar :: :: Quux a c ( a c (Quux a b c) -> a b c) -> Quux a c a c Bool -> -> Quux a b c #
bar' :: :: Quux a c ( a c (Quux a c ( a c (Quux a b c)) -> a b c)) -> Quux a c ( a c (Quux a c ( a c (Quux a c b0)) #
bar0 :: ( :: (Quux a c ( a c (Quux a b c), a b c), Quux a c ( a c (Quux a b c)) -> ( a b c)) -> (Quux a c b0, a c b0, Quux a c c0) #
bar1 :: ( :: (Quux a c ( a c (Quux a b c), a b c), Quux a c ( a c (Quux a b c)) -> ( a b c)) -> (Quux a c b0, a c b0, Quux a c c0) # Baz ( (Quux a b c)
baz :: :: Quux a b c -> (forall a0. a0 -> a0) -> (b0, forall c0. c0 -> c0. c0 -> Quux a b c) -> (b0, c1) #baz' :: b0 -> (forall b1. b1 -> b1. b1 -> Quux a b c) -> (forall b2. b2 -> b2. b2 -> Quux a b c) -> [(b0, a b c) -> [(b0, Quux a b c)] #forall b1. (forall b2. b2 -> b2. b2 -> Quux a b c) -> c0) -> forall data Thud Int ( (Quux a [a] c)
data Thud Int ( (Quux a [a] c)
| Thuuud Int Int
norf :: :: Plugh a c b -> a -> (a -> c) -> b # Norf Int Bool
type Plugh Int c c Bool :: :: * #
data Thud Int c :: c :: * #
norf :: :: Plugh Int c c Bool -> -> Int -> ( -> (Int -> c) -> -> c) -> Bool # Norf [a] [b]
type Plugh [a] c [b] :: [a] c [b] :: * #
data Thud [a] c :: [a] c :: * #
norf :: :: Plugh [a] c [b] -> [a] -> ([a] -> c) -> [b] #
f :: :: Integer
f :: :: Integer #
Minimal complete definition
foo, , bar | | bar, , bat | | foo, , bat | | fooBarBat
Minimal complete definition
x, , y
Minimal complete definition
aaa, , bbb
Minimal complete definition
ccc, ddd
foo :: :: Int #
g :: :: Int
g :: :: Int #
the function g
Foo
= = Foo `Bar` Foo
| | Foo :- Foo
(:<->) :: a -> b -> a :: a -> b -> a <-> b
type a <>-<) a b = a a b = a <-> b
:: :: Ord a
=> => Int
-> -> Bool :: forall (b :: ()). d ~ (b :: ()). d ~ ()
C1 :: :: H1 a b
C2 :: :: Ord a => [a] -> a => [a] -> H1 a a
C3 :: {..} -> :: {..} -> H1 Int Int
C4 :: {..} -> :: {..} -> H1 Int a
C1 :: :: H1 a b C2 :: :: Ord a => [a] -> a => [a] -> H1 a a C3 :: {..} -> :: {..} -> H1 Int Int field :: :: Int
C4 :: {..} -> :: {..} -> H1 Int a
new :: ( :: (Eq key, key, Hash key) => key) => Int -> -> IO ( (HashTable key val)
insert :: ( :: (Eq key, key, Hash key) => key -> val -> key) => key -> val -> IO ()
lookup :: :: Hash key => key -> key => key -> IO ( (Maybe val)
key should be an instance of Eq.
new :: ( :: (Eq key, key, Hash key) => key) => Int -> -> IO ( (HashTable key val) #
insert :: ( :: (Eq key, key, Hash key) => key -> val -> key) => key -> val -> IO () #
lookup :: :: Hash key => key -> key => key -> IO ( (Maybe val) #
Looks up a key in the hash table, returns Just val if the key was found, or Nothing otherwise.
Minimal complete definition
hash
hash :: a -> :: a -> Int #hashes the value of type a into an Int
Hash Float
hash :: :: Float -> -> Int # Hash Int
hash :: :: Int -> -> Int # ( (Hash a, a, Hash b) => b) => Hash (a, b)
hash :: (a, b) -> :: (a, b) -> Int # VisibleClass Int VisibleClass VisibleData Num VisibleData
(+) :: :: VisibleData -> -> VisibleData -> -> VisibleData #
(-) :: :: VisibleData -> -> VisibleData -> -> VisibleData #
(*) :: :: VisibleData -> -> VisibleData -> -> VisibleData #
negate :: :: VisibleData -> -> VisibleData #
abs :: :: VisibleData -> -> VisibleData #
signum :: :: VisibleData -> -> VisibleData #
fromInteger :: :: Integer -> -> VisibleData # VisibleClass VisibleData Foo Bar Foo Bar
foo :: :: Int
foo :: :: Int #
c :: (?x :: :: (?x :: X) => ) => X #
d :: (?x :: :: (?x :: X, ?y :: , ?y :: X) => () => (X, , X) #
f :: ((?x :: :: ((?x :: X) => a) -> a # Foo ( ((<~~) a)
foo :: (a :: (a <~~ Int) -> a0 -> a ) -> a0 -> a <~~ a0 #
foo' :: (a :: (a <~~ (a (a <~~ a0)) -> a0)) -> Int -> a -> a <~~ (a (a <~~ Int) #
foo :: f :: f Int -> a -> f a #
foo' :: f (f a) -> :: f (f a) -> Int -> f (f -> f (f Int) # Foo []
foo :: [ :: [Int] -> a -> [a] #
foo' :: [[a]] -> :: [[a]] -> Int -> [[ -> [[Int]] # Foo Maybe
foo :: :: Maybe Int -> a -> -> a -> Maybe a #
foo' :: :: Maybe ( (Maybe a) -> a) -> Int -> -> Maybe ( (Maybe Int) # Foo ( (Either a)
foo :: :: Either a a Int -> a0 -> -> a0 -> Either a a0 #
foo' :: :: Either a ( a (Either a a0) -> a a0) -> Int -> -> Either a ( a (Either a a Int) # ( (Eq a, a, Foo f) => f) => Foo ( ((,) (f a))
foo :: (f a, :: (f a, Int) -> a0 -> (f a, a0) #
foo' :: (f a, (f a, a0)) -> :: (f a, (f a, a0)) -> Int -> (f a, (f a, -> (f a, (f a, Int)) # Foo ( ((<~~) a)
foo :: (a :: (a <~~ Int) -> a0 -> a ) -> a0 -> a <~~ a0 #
foo' :: (a :: (a <~~ (a (a <~~ a0)) -> a0)) -> Int -> a -> a <~~ (a (a <~~ Int) # Foo ( ((,,) a a)
foo :: (a, a, :: (a, a, Int) -> a0 -> (a, a, a0) #
foo' :: (a, a, (a, a, a0)) -> :: (a, a, (a, a, a0)) -> Int -> (a, a, (a, a, -> (a, a, (a, a, Int)) # Foo ( (Quux a b)
foo :: :: Quux a b a b Int -> a0 -> -> a0 -> Quux a b a0 #
foo' :: :: Quux a b ( a b (Quux a b a0) -> a b a0) -> Int -> -> Quux a b ( a b (Quux a b a b Int) # Foo ((->) LiftedRep LiftedRep a) ((->) a :: * -> *) #
Foo `Bar` Foo infixl 3
Foo :- Foo infixr 5 (:<->) :: a -> b -> a :: a -> b -> a <-> b infixr 6
Minimal complete definition
(>><), , (<<>), , (**>), , (**<), , (>**), , (<**)
type a <>-<) a b = a a b = a <-> b infixl 6
Synopsis
Documentation
Orphan instances
AClass AType
aClass :: :: AType -> -> Int #
Minimal complete definition
aClass
aClass :: a -> :: a -> Int #
Instances

AClass AType #
This is an orphan instance.
Instance details
Methods
aClass :: AType -> Int #
AType Int
Instances
AClass AType #
This is an orphan instance.
Instance details
Methods
aClass :: AType -> Int #
Foo :: forall x. x -> x. x -> FooType x
Bar :: forall x. x -> x. x -> FooType ( (FooType x)
(:<->) :: forall x x1. x -> x1 -> ( x x1. x -> x1 -> (FooType x, x, FooType ( (FooType x1))
data BlubType = = Show x => BlubCtorBlub :: () => forall x. x. Show x => x -> x => x -> BlubType
data (a :: (a :: *) ><E :: forall k a (b :: k). (><) k a b
k a (b :: k). a > somex -> somex => somex -> FooType somex
Foo :: forall x. x -> x. x -> FooType x #
Pattern synonym for Foo x
Bar :: forall x. x -> x. x -> FooType ( (FooType x) #
Pattern synonym for Bar x
(:<->) :: forall x x1. x -> x1 -> ( x x1. x -> x1 -> (FooType x, x, FooType ( (FooType x1)) #
Pattern synonym for (:<->)
This module illustrates & tests most of the features of Haddock. Testing references from the description: T, f, g, visible.
= A Int ( (Maybe Float)
| B ( (T a b, a b, T Int Float)
p :: :: Int
r, s :: :: Int
t :: T1 -> :: T1 -> T2 Int Int -> -> T3 Bool Bool -> -> T4 Float Float -> -> T5 () ()
u, v :: :: Int
s1 :: :: Int
s2 :: :: Int
s3 :: :: Int
}
p :: R -> Int
q :: R -> forall a. a -> a
u :: R -> Int
class D a => C
a :: :: C a => a => IO a
f :: :: C a => a -> a => a -> Int
g :: :: Int -> -> IO CInt
hidden :: :: Int -> -> Int
Ex a
= = C b => Ex1Ex2 b
| | C a => Ex3
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
withType :: :: Int
Show x => BlubCtorBlub :: () => forall x. x. Show x => x -> x => x -> BlubType #
Pattern synonym for Blub x
data (a :: (a :: *) ><
Doc for (><)
E :: forall k a (b :: k). (><) k a b k a (b :: k). a > somex -> somex => somex -> FooType somex #
((RevList a) :>data Pattern :: [ :: [*] -> ] -> * where Nil :: :: Pattern '[] Cons :: :: Maybe h -> h -> Pattern t -> t -> Pattern (h ': t) data RevPattern :: :: RevList * -> -> * where RevNil :: :: RevPattern RNil RevCons :: :: Maybe h -> h -> RevPattern t -> t -> RevPattern (t (t :> h) data Tuple :: ( :: (*, , *) -> ) -> * where Tuple :: a -> b -> :: a -> b -> Tuple '(a, b)
fib :: :: Integer -> -> Integer
fib :: :: Integer -> -> Integer #
Fibonacci number of given Integer.
IntExpr Integer AntiIntExpr String BinopExpr BinOp Expr Expr AntiExpr String Show Expr
showsPrec :: :: Int -> -> Expr -> -> ShowS #
show :: :: Expr -> -> String #
showList :: [ :: [Expr] -> ] -> ShowS # Show BinOp
showsPrec :: :: Int -> -> BinOp -> -> ShowS #
show :: :: BinOp -> -> String #
showList :: [ :: [BinOp] -> ] -> ShowS #
eval :: :: Expr -> -> Integer #
parseExprExp :: :: String -> Q Exp #
val :: :: Integer #data SomeType (f :: (f :: * -> -> *) a # Functor ( (SomeType f)
fmap :: (a -> b) -> :: (a -> b) -> SomeType f a -> f a -> SomeType f b #
(<$) :: a -> :: a -> SomeType f b -> f b -> SomeType f a # Applicative f => f => Applicative ( (SomeType f)
pure :: a -> :: a -> SomeType f a #
(<*>) :: :: SomeType f (a -> b) -> f (a -> b) -> SomeType f a -> f a -> SomeType f b #
liftA2 :: (a -> b -> c) -> :: (a -> b -> c) -> SomeType f a -> f a -> SomeType f b -> f b -> SomeType f c #
(*>) :: :: SomeType f a -> f a -> SomeType f b -> f b -> SomeType f b #
(<*) :: :: SomeType f a -> f a -> SomeType f b -> f b -> SomeType f a #
tableWithHeader A Int ( (Maybe Float)
This comment describes the A constructor
B ( (T a b, a b, T Int Float)
This comment describes the B constructor
documents A3
documents B3
This is the doc for A4
This is the doc for B4
This is the doc for C4
this is the n3 field
The N7 constructor
This is the documentation for the R record, which has four fields, p, q, r, and s.
This is the C1 record constructor, with the following fields:
p :: :: Int
This comment applies to the p field
This comment applies to the q field
r, s :: :: Int
This comment applies to both r and s
This is the C2 record constructor, also with some fields:
t :: T1 -> :: T1 -> T2 Int Int -> -> T3 Bool Bool -> -> T4 Float Float -> -> T5 () ()
u, v :: :: Int
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 => CThis comment applies to the previous declaration (the C class)
Minimal complete definition
a, , b
a :: :: IO a #
this is a description of the a method
this is a description of the b method
Minimal complete definition
d, , e
d :: :: T a b # D Float
d :: :: T Float b #
e :: ( :: (Float, , Float) # D Int
d :: :: T Int b #
e :: ( :: (Int, , Int) #
Minimal complete definition
ff
a :: :: C a => a => IO a #
this is a description of the a method
f :: :: C a => a -> 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 @@ -1801,7 +1877,7 @@ using double quotes:
This is a block of code, which can include other markup: R @@ -1821,9 +1897,9 @@ using double quotes:
g :: :: Int -> -> IO CInt #
hidden :: :: Int -> -> Int #
C b => Ex1
C a => Ex3
:: :: T () ()
This argument has type T
-> -> T2 Int Int
-> (-> (T3 Bool Bool -> -> T4 Float Float)
-> -> T5 () ()
-> -> IO ()
:: (:: (Int, , Int, , Float)
-> -> Int
returns an Int
:: :: R
-> -> N1 ()
-> -> IO Int data Bat * X
data Bat * X
= BatX X
aaa :: :: X
bbb :: :: Y
type Foo * X
type Foo * X = = Y
type (<>) * X a <> (a :: *) #
type (<>) * X a = <> (a :: *) = X
Assoc * Y
data AssocD Y (a :: Y) :: :: * #
type AssocT Y (a :: Y) :: :: * # Test * Y data Bar Y
data Bar Y
data AssocD * Y
data AssocD * Y = AssocY type AssocT * Y
type AssocT * Y = = Bat * Y
data Bat * Y
data Bat * Y = BatY Y
type Foo * Y
type Foo * Y = = X
type (<>) * Y a <> (a :: *) #
type (<>) * Y a = a
<> (a :: *) = a
data Bat (z :: Z) #
data Bat (z :: Z ) where
BatZ1 :: :: Bat Z ZA
BatZ2 :: :: Bat Z ZB
Test * Y Test * X type Foo * Y
type Foo * Y = = X
type Foo * X
type Foo * X = = Y
data family Bat (a :: k) :: (a :: k) :: * # data Bat (z :: Z) #
data Bat (z :: Z ) where
BatZ1 :: :: Bat Z ZA
BatZ2 :: :: Bat Z ZB
data Bat * Y
data Bat * Y = BatY Y
data Bat * X
data Bat * X
= BatX X
aaa :: :: X
bbb :: :: Y
data AssocD a :: a :: * #type AssocT a :: a :: * # Assoc * Y
data AssocD Y (a :: Y) :: :: * #
type AssocT Y (a :: Y) :: :: * # Assoc * X
data AssocD X (a :: X) :: :: * #
type AssocT X (a :: X) :: :: * #
:: :: Float
-> -> IO Float
f' :: :: Int #
a function with a prime can be referred to as f' @@ -2283,7 +2359,7 @@ is at the beginning of the line).
withType :: :: Int #
f :: :: Integer
f :: :: Integer #
...given a raw Addr# to the string, and the length of the string.
Minimal complete definition
f
f :: :: Int
f :: :: Int #
A reference to :-
foo :: :: Integer
bar :: :: Integer
foo :: :: Integer #
Picture for foo without a title
bar :: :: Integer #
Picture for bar with title data family Bat (a :: k) :: (a :: k) :: *
data AssocD a :: a :: *
type AssocT a :: a :: *
(><) X XX >< XXX Assoc * X
data AssocD X (a :: X) :: :: * #
type AssocT X (a :: X) :: :: * # Test * X type Foo X
type Foo X = = Y
type (<>) X XXX <> XX
type (<>) X XXX <> XX = = X
data AssocD * X
data AssocD * X = AssocX type AssocT * X
type AssocT * X = = (Foo * X
:: *)

type (<>) * Y a = a
<> (a :: *) = atype(<>)* X a<> (a :: *)#
type (<>) * X a = <> (a :: *) = X
(><) X XX >< XXX data Bar W
data Bar W = BarX type Foo W
type Foo W
type Foo W
type Foo W
type Foo X
type Foo X = = Y
data Bar W
data Bar W = BarX data Bar Y
data Bar Y
biO :: (g :: (g `O` f) a #
x :: (a :: (a :-: a) a) <=> (a (a `Op` a) => a #
y :: (a :: (a <=> a, (a a, (a `Op` a) a) <=> a) => a #
x :: :: Int
x :: :: Int #
visible :: :: Int -> -> Int # Date: Wed, 13 Jun 2018 23:49:52 +0200 Subject: html-test: Accept output --- html-test/ref/A.html | 24 +- html-test/ref/Bug280.html | 4 +- html-test/ref/Bug294.html | 16 +- html-test/ref/Bug3.html | 8 +- html-test/ref/Bug310.html | 46 +-- html-test/ref/Bug387.html | 16 +- html-test/ref/Bug4.html | 8 +- html-test/ref/Bug546.html | 20 +- html-test/ref/Bug548.html | 256 +++------------ html-test/ref/Bug6.html | 60 +--- html-test/ref/Bug613.html | 10 +- html-test/ref/Bug8.html | 4 +- html-test/ref/Bug85.html | 14 +- html-test/ref/BugDeprecated.html | 48 +-- html-test/ref/BugExportHeadings.html | 48 +-- html-test/ref/Bugs.html | 4 +- html-test/ref/BundledPatterns.html | 36 +- html-test/ref/BundledPatterns2.html | 36 +- html-test/ref/ConstructorPatternExport.html | 30 +- html-test/ref/DeprecatedFunction.html | 16 +- html-test/ref/DeprecatedFunction2.html | 8 +- html-test/ref/DeprecatedFunction3.html | 8 +- html-test/ref/DeprecatedModule.html | 4 +- html-test/ref/DeprecatedModule2.html | 4 +- html-test/ref/DeprecatedNewtype.html | 16 +- html-test/ref/DeprecatedReExport.html | 8 +- html-test/ref/DeprecatedRecord.html | 16 +- html-test/ref/DeprecatedTypeFamily.html | 24 +- html-test/ref/DeprecatedTypeSynonym.html | 16 +- html-test/ref/Examples.html | 16 +- html-test/ref/FunArgs.html | 16 +- html-test/ref/GADTRecords.html | 54 ++- html-test/ref/Hash.html | 96 ++---- html-test/ref/HiddenInstances.html | 26 +- html-test/ref/Hyperlinks.html | 8 +- html-test/ref/Instances.html | 398 ++++------------------- html-test/ref/Math.html | 8 +- html-test/ref/ModuleWithWarning.html | 4 +- html-test/ref/NoLayout.html | 8 +- html-test/ref/Operators.html | 8 +- html-test/ref/OrphanInstances.html | 4 +- html-test/ref/OrphanInstancesClass.html | 8 +- html-test/ref/OrphanInstancesType.html | 8 +- html-test/ref/PatternSyns.html | 32 +- html-test/ref/PromotedTypes.html | 28 +- html-test/ref/Properties.html | 16 +- html-test/ref/QuasiExpr.html | 80 +---- html-test/ref/QuasiQuote.html | 4 +- html-test/ref/SpuriousSuperclassConstraints.html | 44 +-- html-test/ref/TH.html | 6 +- html-test/ref/Test.html | 320 ++++-------------- html-test/ref/Threaded.html | 8 +- html-test/ref/Threaded_TH.html | 12 +- html-test/ref/Ticket112.html | 4 +- html-test/ref/Ticket75.html | 8 +- html-test/ref/TitledPicture.html | 16 +- html-test/ref/TypeFamilies.html | 120 +++---- html-test/ref/Unicode.html | 8 +- html-test/ref/Visible.html | 6 +- 59 files changed, 460 insertions(+), 1722 deletions(-) (limited to 'html-test/ref/Bug546.html') diff --git a/html-test/ref/A.html b/html-test/ref/A.html index e4802966..c6965abc 100644 --- a/html-test/ref/A.html +++ b/html-test/ref/A.html @@ -54,15 +54,11 @@ >
other :: Int
:: Int
test2 :: Bool
:: Bool
data
reExport :: Int
:: Int
other :: Int :: Int #
test2 :: Bool :: Bool #
reExport :: Int :: Int #
x :: [Char] :: [Char] #
gadtField :: ({..} -> GADT :: GADT A) -> -> A #data family TP t :: * t :: * #
data family DP t :: * t :: * #
data family TO' t :: * t :: * #
foo :: Int
:: Int
foo :: Int :: Int #
Bug310
Synopsis
type family (a :: Nat) + (b :: Nat) :: Nat where ...
Documentation
type family (a :: Nat) (a :: Nat) + (b :: Nat) :: Nat (b :: Nat) :: Nat where ... infixl 6 #
Addition of type-level naturals.
Since: base-4.7.0.0
+> \ No newline at end of file diff --git a/html-test/ref/Bug387.html b/html-test/ref/Bug387.html index ba2f5c91..da1b1ee5 100644 --- a/html-test/ref/Bug387.html +++ b/html-test/ref/Bug387.html @@ -60,15 +60,11 @@ >
test1 :: Int
:: Int
test2 :: Int
:: Int
test1 :: Int :: Int #
test2 :: Int :: Int #
foo :: Int
:: Int
foo :: Int :: Int #
x :: Integer
:: Integer
compile :: String -> String
:: String -> String
x :: Integer :: Integer #
compile :: String -> String :: String -> String #
newtype WrappedArrow (a :: * -> * -> *) b c (a :: * -> * -> *) b c #
Generic1 ( Generic1 (WrappedArrow a b :: * -> *) a b :: * -> *)
type Rep1 (WrappedArrow a b) :: k -> * #
Rep1 (WrappedArrow a b) :: k -> *
from1 :: WrappedArrow a b a0 -> Rep1 ( a b a0 -> Rep1 (WrappedArrow a b) a0 #
a b) a0
to1 :: Rep1 ( :: Rep1 (WrappedArrow a b) a0 -> WrappedArrow a b a0 #
a b a0
Arrow a => Functor ( Arrow a => Functor (WrappedArrow a b) Arrow a => Applicative ( Arrow a => Applicative (WrappedArrow a b) (ArrowZero a, ArrowPlus a) => Alternative ( (ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) Generic ( Generic (WrappedArrow a b c)
type Rep (WrappedArrow a b c) :: * -> * #
Rep (WrappedArrow a b c) :: * -> *
from :: WrappedArrow a b c -> Rep ( a b c -> Rep (WrappedArrow a b c) x #
a b c) x
to :: Rep ( :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c #
a b c
typeRep1 ( Rep1 (WrappedArrow a b :: * -> *) a b :: * -> *)
type Rep1 ( Rep1 (WrappedArrow a b :: * -> *) = D1 (MetaData "WrappedArrow" "Control.Applicative" "base" True) (C1 (MetaCons "WrapArrow" PrefixI True) (S1 (MetaSel (Just "unwrapArrow") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 (a b))))
a b :: * -> *) = D1 (MetaData "WrappedArrow" "Control.Applicative" "base" True) (C1 (MetaCons "WrapArrow" PrefixI True) (S1 (MetaSel (Just "unwrapArrow") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 (a b))))typeRep ( Rep (WrappedArrow a b c)
type Rep ( Rep (WrappedArrow a b c) = D1 (MetaData "WrappedArrow" "Control.Applicative" "base" True) (C1 (MetaCons "WrapArrow" PrefixI True) (S1 (MetaSel (Just "unwrapArrow") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (a b c))))
a b c) = D1 (MetaData "WrappedArrow" "Control.Applicative" "base" True) (C1 (MetaCons "WrapArrow" PrefixI True) (S1 (MetaSel (Just "unwrapArrow") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (a b c)))) +> \ No newline at end of file diff --git a/html-test/ref/Bug6.html b/html-test/ref/Bug6.html index 15842547..27f73d64 100644 --- a/html-test/ref/Bug6.html +++ b/html-test/ref/Bug6.html @@ -58,9 +58,7 @@ >A = A Int Int
dataB = B Int
Int
b :: B -> Int
-> Int
data
c1 :: Int
:: Int
c2 :: Int
:: Int}
D = D Int Int
Int Int
newtypeE = E Int
Int Int Intb :: B -> Int -> Int #
c1 :: Int :: Int
c2 :: Int :: Int
Int Int IntFunctor (Either a) (Either a)#
fmap :: (a0 -> b) -> Either a a0 -> Either a b :: (a0 -> b) -> Either a a0 -> Either a b #
(--->) :: Foldable t0 => t0 t -> :: Foldable t0 => t0 t -> Typ -> Typdata Foo :: (* -> *) -> * -> * :: (* -> *) -> * -> * where #data Baz :: * :: * where #
foo :: Int
:: Int
bar :: Int
:: Int
baz :: Int
:: Int
one :: Int
:: Int
two :: Int
:: Int
three :: Int
:: Int
foo :: Int :: Int #
bar :: Int :: Int #
baz :: Int :: Int #
one :: Int :: Int #
two :: Int :: Int #
three :: Int :: Int #
foo :: Int
:: Int
bar :: Int
:: Int
baz :: Int
:: Int
one :: Int
:: Int
two :: Int
:: Int
three :: Int
:: Int
foo :: Int :: Int #
bar :: Int :: Int #
baz :: Int :: Int #
one :: Int :: Int #
two :: Int :: Int #
three :: Int :: Int #
a (a -> Int)dataVec :: Nat -> * -> * :: Nat -> * -> * where
data RTree :: Nat -> * -> * :: Nat -> * -> * where
data Vec :: Nat -> * -> * :: Nat -> * -> * where # subscript starting from 0 and ending at lengthlength - 1.
data RTree :: Nat -> * -> * :: Nat -> * -> * where #data Vec :: Nat -> * -> * :: Nat -> * -> * where
data RTree :: Nat -> * -> * :: Nat -> * -> * where
data Vec :: Nat -> * -> * :: Nat -> * -> * where # subscript starting from 0 and ending at lengthlength - 1.
data RTree :: Nat -> * -> * :: Nat -> * -> * where #pattern FooCons :: String -> a -> Foo a :: String -> a -> Foo a #
pattern MyRecCons :: Bool -> Int -> MyRec :: Bool -> Int -> MyRec #
pattern (:+) :: String -> a -> MyInfix a :: String -> a -> MyInfix a #
pattern BlubCons :: () => Show b => b -> Blub :: () => Show b => b -> Blub #
pattern MyGADTCons :: () => forall a. Eq a => a -> Int -> MyGADT (Maybe String) :: a -> Int -> MyGADT (Maybe String) #
foo :: Int
:: Int
bar :: Int
:: Int
foo :: Int :: Int #
bar :: Int :: Int #
foo :: Int
:: Int
foo :: Int :: Int #
foo :: Integer
:: Integer
foo :: Integer :: Integer #
foo :: Int :: Int #
foo :: Int :: Int #
SomeNewType = SomeNewTypeConst String String
newtypeSomeOtherNewType = SomeOtherNewTypeConst String
String String String
Bar X = = X
Bar y = y = Y type (<>) X XXX <> XX
type (<>) X XXX <> XX = = X
type (<>) * Y a <> (a :: *) #

Since: base-2.1
WrappedArrow a b a0 -> WrappedArrow a b b0 #
a b b0
(<$)WrappedArrow a b b0 -> WrappedArrow a b a0 #
a b a0
Since: base-2.1
pure :: a0 -> WrappedArrow a b a0 #
a b a0
(<*>)WrappedArrow a b a0 -> WrappedArrow a b b0 #
a b b0
liftA2WrappedArrow a b b0 -> WrappedArrow a b c #
a b c
(*>)WrappedArrow a b b0 -> WrappedArrow a b b0 #
a b b0
(<*)WrappedArrow a b b0 -> WrappedArrow a b a0 #
a b a0
Since: base-2.1
empty :: WrappedArrow a b a0 #
a b a0
(<|>)WrappedArrow a b a0 -> WrappedArrow a b a0 #
a b a0
someWrappedArrow a b a0 -> WrappedArrow a b [a0] #
a b [a0]
manyWrappedArrow a b a0 -> WrappedArrow a b [a0] #
a b [a0]

A Int
B Int

D Int Int
E Int

A a (a -> Int)

SomeNewTypeConst String
SomeOtherNewTypeConst String
foo :: Int
:: Int
foo :: Int :: Int #
fooName :: String
:: String
fooValue :: Int
:: Int}fooName :: String :: String
some name
fooValue :: Int :: Int
data family SomeTypeFamily k :: * -> * k :: * -> *
data family SomeOtherTypeFamily k :: * -> *
k :: * -> *
data family SomeTypeFamily k :: * -> * k :: * -> * #
data family SomeOtherTypeFamily k :: * -> * k :: * -> * #
type TypeSyn = String = String
type OtherTypeSyn = String
= String
type TypeSyn = String = String #
type OtherTypeSyn = String = String #
fib :: Integer -> Integer
:: Integer -> Integer
fib :: Integer -> Integer :: Integer -> Integer #
Fibonacci number of given IntegerInteger.
Examples:
:: Ord a=> Int-> Bool (b :: ()). d ~ ()
C2 :: Ord a => [a] -> :: Ord a => [a] -> H1 a a
C3 :: {..} -> H1 Int Int
Int Int
C4 :: {..} -> H1 Int a
Int a
:: { field :: Int :: Int
hello docs
} -> H1 Int Int
:: { field2 :: a
hello2 docs
} -> H1 Int a
new :: (Eq key, :: (Eq key, Hash key) => Int -> IO ( key) => Int -> IO (HashTable key val)
insert :: (Eq key, :: (Eq key, Hash key) => key -> val -> IO ()
key) => key -> val -> IO ()
lookup :: Hash key => key -> IO (Maybe val)
key => key -> IO (Maybe val)
class
hash :: a -> Int
:: a -> Intkey should be an instance of EqEq.
new :: (Eq key, :: (Eq key, Hash key) => Int -> IO ( key) => Int -> IO (HashTable key val) #
insert :: (Eq key, :: (Eq key, Hash key) => key -> val -> IO () key) => key -> val -> IO () #
lookup :: Hash key => key -> IO (Maybe val) key => key -> IO (Maybe val) #
Looks up a key in the hash table, returns JustJust val if the key was found, or NothingNothing otherwise.
hash :: a -> Int :: a -> Int #
hashes the value of type a into an IntInt
Hash Float Float#
hash :: Float -> Int :: Float -> Int #
Hash Int Int#
hash :: Int -> Int :: Int -> Int #
hash :: (a, b) -> Int :: (a, b) -> Int #
VisibleClass Int Int# Num Num VisibleDataVisibleData -> VisibleData #
VisibleData -> VisibleData #
VisibleData -> VisibleData #
VisibleData -> VisibleData #
VisibleData -> VisibleData #
VisibleData -> VisibleData #
fromInteger :: Integer -> :: Integer -> VisibleData #
foo :: Int
:: Int
foo :: Int :: Int #
foo :: (a <~~ Int) -> a0 -> a Int) -> a0 -> a <~~ a0 #<~~ (a <~~ a0)) -> Int -> a a0)) -> Int -> a <~~ (a <~~ Int) Int) #
foo :: f Int -> a -> f a :: f Int -> a -> f a #
foo' :: f (f a) -> Int -> f (f Int) :: f (f a) -> Int -> f (f Int) #
foo :: [Int] -> a -> [a] :: [Int] -> a -> [a] #
foo' :: [[a]] -> Int -> [[Int]] :: [[a]] -> Int -> [[Int]] #
Foo Maybe Maybe#
foo :: Maybe Int -> a -> Maybe a :: Maybe Int -> a -> Maybe a #
foo' :: Maybe (Maybe a) -> Int -> Maybe (Maybe Int) :: Maybe (Maybe a) -> Int -> Maybe (Maybe Int) #
Foo (Either a) (Either a)#
foo :: Either a Int -> a0 -> Either a a0 :: Either a Int -> a0 -> Either a a0 #
foo' :: Either a (Either a a0) -> Int -> Either a (Either a Int) :: Either a (Either a a0) -> Int -> Either a (Either a Int) #
(Eq a, (Eq a, Foo f) => Foo ((,) (f a)) ((,) (f a))#
foo :: (f a, Int) -> a0 -> (f a, a0) :: (f a, Int) -> a0 -> (f a, a0) #
foo' :: (f a, (f a, a0)) -> Int -> (f a, (f a, Int)) :: (f a, (f a, a0)) -> Int -> (f a, (f a, Int)) #
foo :: (a <~~Int) -> a0 -> a Int) -> a0 -> a <~~ a0 #<~~ (a <~~ a0)) -> Int -> a a0)) -> Int -> a <~~ (a <~~Int) Int) #
Foo ((,,) a a) ((,,) a a)#
foo :: (a, a, Int) -> a0 -> (a, a, a0) :: (a, a, Int) -> a0 -> (a, a, a0) #
foo' :: (a, a, (a, a, a0)) -> Int -> (a, a, (a, a, Int)) :: (a, a, (a, a, a0)) -> Int -> (a, a, (a, a, Int)) #
foo :: Quux a b Int -> a0 -> a b Int -> a0 -> Quux a b a0 #Quux a b (Quux a b a0) -> Int -> a b a0) -> Int -> Quux a b (Quux a b Int) a b Int) #
Foo ((->) a :: * -> *) ((->) a :: * -> *)#
foo :: (a -> Int) -> a0 -> a -> a0 :: (a -> Int) -> a0 -> a -> a0 #
foo' :: (a -> a -> a0) -> Int -> a -> a -> Int :: (a -> (a -> a0)) -> Int -> a -> (a -> Int) #
bar :: f a -> f Bool -> a :: f a -> f Bool -> a #
Bar Maybe Bool Maybe Bool #
bar :: Maybe Bool -> Maybe Bool -> Bool :: Maybe Bool -> Maybe Bool -> Bool #
bar' :: Maybe (Maybe Bool) -> Maybe (Maybe (Maybe b)) :: Maybe (Maybe Bool) -> Maybe (Maybe (Maybe b)) #
bar0 :: (Maybe Bool, Maybe Bool) -> (Maybe b, Maybe c) :: (Maybe Bool, Maybe Bool) -> (Maybe b, Maybe c) #
bar1 :: (Maybe Bool, Maybe Bool) -> (Maybe b, Maybe c) :: (Maybe Bool, Maybe Bool) -> (Maybe b, Maybe c) #
Bar Maybe [a] Maybe [a]#
bar :: Maybe [a] -> Maybe Bool -> [a] :: Maybe [a] -> Maybe Bool -> [a] #
bar' :: Maybe (Maybe [a]) -> Maybe (Maybe (Maybe b)) :: Maybe (Maybe [a]) -> Maybe (Maybe (Maybe b)) #
bar0 :: (Maybe [a], Maybe [a]) -> (Maybe b, Maybe c) :: (Maybe [a], Maybe [a]) -> (Maybe b, Maybe c) #
bar1 :: (Maybe [a], Maybe [a]) -> (Maybe b, Maybe c) :: (Maybe [a], Maybe [a]) -> (Maybe b, Maybe c) #
bar :: [(a, a)] -> [Bool] -> (a, a) :: [(a, a)] -> [Bool] -> (a, a) #
Foo f => Bar (Either a) (f a) (Either a) (f a) #
bar :: Either a (f a) -> Either a Bool -> f a :: Either a (f a) -> Either a Bool -> f a #
bar' :: Either a (Either a (f a)) -> Either a (Either a (Either a b)) :: Either a (Either a (f a)) -> Either a (Either a (Either a b)) #
bar0 :: (Either a (f a), Either a (f a)) -> (Either a b, Either a c) :: (Either a (f a), Either a (f a)) -> (Either a b, Either a c) #
bar1 :: (Either a (f a), Either a (f a)) -> (Either a b, Either a c) :: (Either a (f a), Either a (f a)) -> (Either a b, Either a c) #
Foo ((,,) a b) => ((,,) a b) => Bar ((,,) a b) (a, b, a) ((,,) a b) (a, b, a)#
bar :: (a, b, (a, b, a)) -> (a, b, Bool) -> (a, b, a) :: (a, b, (a, b, a)) -> (a, b, Bool) -> (a, b, a) #
Quux a b c) -> Quux a c Bool -> a c Bool -> Quux a b c #foo :: Quux a b Int -> a0 -> a b Int -> a0 -> Quux a b a0 #Quux a b (Quux a b a0) -> Int -> a b a0) -> Int -> Quux a b (Quux a b Int) a b Int) #
Quux a b c) -> Quux a c Bool -> a c Bool -> Quux a b c #dataThud Int ( Int (Quux a [a] c)data Thud Int ( Int (Quux a [a] c)
| Thuuud Int Int
Int Int
Norf Int Bool Int Bool#typePlugh Int c Bool :: * Int c Bool :: * #
data Thud Int c :: * Int c :: * #
norf :: Plugh Int c Bool -> Int -> (Int -> c) -> Bool Int c Bool -> Int -> (Int -> c) -> Bool #
typePlugh [a] c [b] :: * [a] c [b] :: * #
data Thud [a] c :: * [a] c :: * #
f :: Integer
:: Integer
f :: Integer :: Integer #
foo :: Int :: Int #
g :: Int
:: Int
g :: Int :: Int #
type a <> Int -> Int #
aClass :: a -> Int :: a -> Int #
aClass :: AType -> Int -> Int #
IntaClass :: AType -> Int -> Int #
dataBlubType = Show x => = Show x => BlubCtor x
Blub :: () => forall x. Show x => x -> x. Show x => x -> BlubType
data (a :: *) (a :: *) > somex -> :: Eq somex => somex -> FooType somex
:: Ord a
=> Int
First argument
-> Bool
Third argument
:: forall (b :: ()). d ~ ()
C2 :: Ord a => [a] -> :: Ord a => [a] -> H1 a a C3 :: {..} -> H1 Int Int C4 :: {..} -> H1 Int a

AType Int

Integer String String Show Show Expr
showsPrec :: Int -> :: Int -> Expr -> ShowS #
-> ShowS
show :: Expr -> String #
-> String
showList :: [Expr] -> ShowS #
] -> ShowS
Show Show BinOp
showsPrec :: Int -> :: Int -> BinOp -> ShowS #
-> ShowS
show :: BinOp -> String #
-> String
showList :: [BinOp] -> ShowS #
] -> ShowS
eval :: Expr -> Integer -> Integer #
expr :: QuasiQuoter :: QuasiQuoter #
parseExprExp :: String -> Q Exp :: String -> Q Exp #
val :: Integer :: Integer #
dataSomeType (f :: * -> *) a (f :: * -> *) a #
Functor ( Functor (SomeType f) SomeType f a -> SomeType f b #
f b
(<$)SomeType f b -> SomeType f a #
f a
Applicative f => Applicative ( Applicative f => Applicative (SomeType f)pure :: a -> SomeType f a #
f a
(<*>)SomeType f a -> SomeType f b #
f b
liftA2SomeType f b -> SomeType f c #
f c
(*>)SomeType f b -> SomeType f b #
f b
(<*)SomeType f b -> SomeType f a #
f a
decl :: Q [Dec] :: Q [Dec] #
= A Int (Maybe Float)
Int (Maybe Float)
| BT a b, T Int Float)
Int Float)
p :: Int
:: Int
qr, s :: Int
:: Int }
t :: T1 -> T2 Int Int -> Int Int -> T3 Bool Bool -> Bool Bool -> T4 Float Float -> Float Float -> T5 () ()
u, v :: Int
:: Int }
s1 :: Int
:: Int
s2 :: Int
:: Int
s3 :: Int
:: Int}
p :: R -> Int
-> Int
qu :: R -> Int
-> Int
class
a :: IO a
:: IO a
ba :: C a => IO a
a => IO a
f :: C a => a -> Int
a => a -> Int
g :: Int -> IO CInt
:: Int -> IO CInt
hidden :: Int -> Int
:: Int -> Int
module VisibleT () () -> T2 Int Int -> ( Int Int -> (T3 Bool Bool -> Bool Bool -> T4 Float Float) -> Float Float) -> T5 () () -> IO ()
() () -> IO ()
l :: (Int, Int, Float) -> Int
:: (Int, Int, Float) -> Int
mR -> N1 () -> IO Int
() -> IO Int
o :: Float -> IO Float
:: Float -> IO Float
f' :: Int
:: Int
withType :: Int
:: Int
withoutType
Int (Maybe Float) Int Float)d :: T Float b Float b #
e :: (Float, Float) :: (Float, Float) #
D Int Int#d :: T Int b Int b #
e :: (Int, Int) :: (Int, Int) #
a :: C a => IO a a => IO a #
f :: C a => a -> Int a => a -> Int #
g :: Int -> IO CInt :: Int -> IO CInt #
hidden :: Int -> Int :: Int -> Int #
Int Int Float Float)-> IO ()
Show x => Show x => BlubCtor x Blub :: () => forall x. Show x => x -> x. Show x => x -> BlubType #
data (a :: *) (a :: *) > somex -> :: Eq somex => somex -> FooType somex #data Pattern :: [*] -> * :: [*] -> * where #
Cons :: Maybe h -> :: Maybe h -> Pattern t -> PatternRevPattern :: RevList * -> * * -> * where # RevCons :: Maybe h -> :: Maybe h -> RevPattern t -> RevPatterndata Tuple :: (*, *) -> * :: (*, *) -> * where #
fib :: Integer -> Integer
:: Integer -> Integer
fib :: Integer -> Integer :: Integer -> Integer #
Fibonacci number of given IntegerInteger.
fib n <= fib (n + 1)
IntExpr Integer
AntiIntExpr String
AntiExpr String

A Int (Maybe Float)
This comment describes the T a b, T Int Float)
This comment describes the p :: Int :: Int
This comment applies to the r, s :: Int :: Int
This comment applies to both t :: T1 -> T2 Int Int -> Int Int -> T3 Bool Bool -> Bool Bool -> T4 Float Float -> Float Float -> T5 () ()
u, v :: Int :: Int s1 :: Int :: IntThe s2 :: Int :: Int The s3 :: Int :: Int The p :: R -> Int -> Int # u :: R -> Int -> Int # a :: IO a :: IO a # D Float Float #
-> T2 Int Int
This argument has type 'T2 Int Int'
-> (T3 Bool Bool -> Bool Bool -> T4 Float Float)
This argument has type
-> IO ()
This is the result type
:: (Int, Int, Float)-> Int-> IO Int
:: (Int, Int, Float)
takes a triple
-> Int
returns an IntInt
-> IO Int
and the return value
:: Float-> IO FloatX<> (a :: *) (a :: *)#X<> (a :: *) = (a :: *) = XAssocDY :: * :: * #
AssocT Y :: * :: * #
Y<> (a :: *) (a :: *)#Y<> (a :: *) = a (a :: *) = a
BatZ1 :: :: forall (z :: Z). Z -> Bat ZA
BatZ2 :: :: forall (z :: Z). {..} -> Bat ZBdata family Bat (a :: k) :: * (a :: k) :: * #
BatZ1 :: :: forall (z :: Z). Z -> Bat ZA
BatZ2 :: :: forall (z :: Z). {..} -> Bat ZBdata AssocD a :: * a :: * #
type AssocT a :: * a :: * #
AssocD Y :: * :: * #
AssocT Y :: * :: * #
AssocD X :: * :: * #
AssocT X :: * :: * #
Y <> (a :: *) (a :: *) #Y <> (a :: *) = a (a :: *) = aX <> (a :: *) (a :: *) #X <> (a :: *) = (a :: *) = X
x :: Int
:: Int
x :: Int :: Int #
visible :: Int -> Int :: Int -> Int #
:: Float
The input float
-> IO Float
The output float
f' :: Int :: Int #
withType :: Int :: Int #
f :: Integer
:: Integer
f :: Integer :: Integer #
forkTH :: Q Exp
:: Q Exp
forkTH :: Q Exp :: Q Exp #
...given a raw Addr#Addr# to the string, and the length of the string.
f :: Int
:: Int
f :: Int :: Int #
foo :: Integer
:: Integer
bar :: Integer
:: Integer
foo :: Integer :: Integer #
bar :: Integer :: Integer #
data family Bat (a :: k) :: * (a :: k) :: *
classdata AssocD a :: *
a :: *
type AssocT a :: *
a :: *
AssocD X :: * :: * #
AssocT X :: * :: * #
Foo X :: *)
:: *)

pattern Empty :: Vec 0 a
pattern (:>) :: a -> :: a -> Vec n a -> n a -> Vec (n (n + 1) a infixr 5
pattern Empty :: Vec 0 a

AClass AType #	This is an orphan instance.
Instance details Methods aClass :: AType -> Int #