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/ref/Operators.html | 40 ++++++++++++++++++++-------------------- 1 file changed, 20 insertions(+), 20 deletions(-) (limited to 'html-test/ref/Operators.html') diff --git a/html-test/ref/Operators.html b/html-test/ref/Operators.html index 1db0a91a..075affab 100644 --- a/html-test/ref/Operators.html +++ b/html-test/ref/Operators.html @@ -70,19 +70,19 @@ >Foo
  • (:<->) :: a -> b -> a :: a -> b -> a <-> b
    • type a <>< b :: b :: *
  • type (>-<) a b = a 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 = AInt 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

    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
    Foo `Bar` Foo infixl 3
    Foo :- Foo infixr 5(:<->) :: a -> b -> a :: a -> b -> a <-> b infixr 6

    Minimal complete definition

    (>><), , (<<>), , (**>), , (**<), , (>**), , (<**)

    type a <>< b :: b :: * infixl 2type (>-<) a b = a a b = a <-> b infixl 6 Date: Wed, 23 May 2018 02:29:05 -0700 Subject: Use `ClassOpSig` instead of `TypeSig` for class methods (#835) * Fix minimal pragma handling Class declarations contain 'ClassOpSig' not 'Typesig'. This should fix #834. * Accept html-test output --- haddock-api/src/Haddock/Backends/Xhtml/Decl.hs | 8 ++-- html-test/ref/Bug26.html | 14 +++---- html-test/ref/Bug613.html | 14 +++---- html-test/ref/Bug647.html | 8 ---- html-test/ref/Bug679.html | 8 ---- html-test/ref/DeprecatedClass.html | 28 +++++-------- html-test/ref/Hash.html | 16 ++++--- html-test/ref/Instances.html | 24 +++++++++++ html-test/ref/Minimal.html | 36 +++++++++++----- html-test/ref/Operators.html | 34 +++++++-------- html-test/ref/OrphanInstancesClass.html | 8 ---- html-test/ref/Test.html | 58 ++++++++++++-------------- html-test/ref/Ticket61.html | 8 ---- 13 files changed, 124 insertions(+), 140 deletions(-) (limited to 'html-test/ref/Operators.html') diff --git a/haddock-api/src/Haddock/Backends/Xhtml/Decl.hs b/haddock-api/src/Haddock/Backends/Xhtml/Decl.hs index d4f6db0e..819c9aa6 100644 --- a/haddock-api/src/Haddock/Backends/Xhtml/Decl.hs +++ b/haddock-api/src/Haddock/Backends/Xhtml/Decl.hs @@ -523,9 +523,9 @@ ppShortClassDecl summary links (ClassDecl { tcdCtxt = lctxt, tcdLName = lname, t -- ToDo: add associated type defaults - [ ppFunSig summary links loc doc names (hsSigWcType typ) + [ ppFunSig summary links loc doc names (hsSigType typ) [] splice unicode pkg qual - | L _ (TypeSig _ lnames typ) <- sigs + | L _ (ClassOpSig _ False lnames typ) <- sigs , let doc = lookupAnySubdoc (head names) subdocs names = map unLoc lnames ] -- FIXME: is taking just the first name ok? Is it possible that @@ -585,12 +585,12 @@ ppClassDecl summary links instances fixities loc d subdocs minimalBit = case [ s | MinimalSig _ _ (L _ s) <- sigs ] of -- Miminal complete definition = every shown method And xs : _ | sort [getName n | L _ (Var (L _ n)) <- xs] == - sort [getName n | TypeSig _ ns _ <- sigs, L _ n <- ns] + sort [getName n | ClassOpSig _ _ ns _ <- sigs, L _ n <- ns] -> noHtml -- Minimal complete definition = the only shown method Var (L _ n) : _ | [getName n] == - [getName n' | L _ (TypeSig _ ns _) <- lsigs, L _ n' <- ns] + [getName n' | L _ (ClassOpSig _ _ ns _) <- lsigs, L _ n' <- ns] -> noHtml -- Minimal complete definition = nothing diff --git a/html-test/ref/Bug26.html b/html-test/ref/Bug26.html index e50169ba..a363fef3 100644 --- a/html-test/ref/Bug26.html +++ b/html-test/ref/Bug26.html @@ -71,7 +71,11 @@ > a where
    • c_f :: a
      • Since: 1.0

      Minimal complete definition

      c_f

      Methods

      f where
      • fmap :: (a -> b) -> f a -> f b
      • #

        Minimal complete definition

        fmap

        Methods

        #

        Minimal complete definition

        f

        Methods

        #

        Minimal complete definition

        foo

        Methods

        a where
        • foo :: a -> a
        • a where
          • bar :: a -> a

            • some class

            Minimal complete definition

            foo

            Methods

            Deprecated: SomeOtherClass

            Minimal complete definition

            bar

            Methods

            a where
            • hash :: a -> Int

              • A class of types which can be hashed.

              Minimal complete definition

              hash

              Methods

              #

              Minimal complete definition

              Nothing

              Methods

              #

              Minimal complete definition

              Nothing

              Methods

              #

              Minimal complete definition

              Nothing

              Methods

              #

              Minimal complete definition

              Nothing

              Associated Types

              #

              Minimal complete definition

              (a, b, c | (d | e, (f | g)))

              Methods

              #

              Minimal complete definition

              aaa, bbb

              Methods

              #

              Minimal complete definition

              Nothing

              Methods

              a ><< b
            • (>><), (<<>) :: a -> b -> ()
            • (**>), (**<), (>**), (<**) :: a -> a -> ()

            • Class with fixity, including associated types

              • Minimal complete definition

              (>><), (<<>), (**>), (**<), (>**), (<**)

              Associated Types

              #

              Minimal complete definition

              aClass

              Methods

              a where
              • a :: IO a
              • b :: [a]
              • a where
                • d :: T a b
                • e :: (a, a)
                • a where
                  • ff :: a
                  • class)

                    • Minimal complete definition

                    a, b

                    Methods

                    This is a class declaration with no separate docs for the methods

                    Minimal complete definition

                    d, e

                    Methods

                    #

                    Minimal complete definition

                    ff

                    Methods

                    #

                    Minimal complete definition

                    f

                    Methods

                    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/Operators.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 :: * -> *)

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

                    HashFloat Float#

                    hash :: Float -> Int :: Float -> Int #

                    HashInt Int#

                    hash :: Int -> Int :: Int -> Int #

                    hash :: (a, b) -> Int :: (a, b) -> Int #

                    VisibleClassInt 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]] #

                    FooMaybe 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) #

                    BarMaybe [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 #dataThudInt ( Int (Quux a [a] c)data ThudInt ( Int (Quux a [a] c) NorfIntBool Int Bool#typePlughInt c Bool :: * Int c Bool :: * #

                    data Thud Int c :: * Int c :: * #

                    norf :: PlughInt 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 <>< b :: * b :: *
                  • datatype a <>< b :: * b :: * infixl 2aClass :: AType -> 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 :: *) >< b = Emptypattern PatWithExplicitSig :: Eq somex => 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 aC3 :: {..} -> H1 Int IntC4 :: {..} -> 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 :: TFloat b Float b #

                    e :: (Float, Float) :: (Float, Float) #

                    DInt Int#d :: TInt 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 xBlub :: () => forall x. Show x => x -> x. Show x => x -> BlubType #

                    data (a :: *) (a :: *) >< b #pattern PatWithExplicitSig :: Eq somex => 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 :: Int

                    The 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 :: *)
                    :: *)