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/BundledPatterns2.html | 98 ++++++++++++++++++------------------- 1 file changed, 49 insertions(+), 49 deletions(-) (limited to 'html-test/ref/BundledPatterns2.html') diff --git a/html-test/ref/BundledPatterns2.html b/html-test/ref/BundledPatterns2.html index 385fd07f..9e791c65 100644 --- a/html-test/ref/BundledPatterns2.html +++ b/html-test/ref/BundledPatterns2.html @@ -48,11 +48,11 @@ >data 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) a 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/BundledPatterns2.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)

    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

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

    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

    (ArrowZero a, ArrowPlus a) => Alternative ( (ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b)

    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]

    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

    type Rep1 ( 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)))) type Rep ( 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
    • IntA Int IntB Int Intb :: B -> Int -> Int #

    c1 :: Int :: Int
    c2 :: Int :: Int
    D Int Int Int IntE Int Int Functor (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 (a -> Int) a (a -> Int)data Vec :: Nat -> * -> * :: Nat -> * -> * where
    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
    • StringSomeNewTypeConst String String

    SomeOtherNewTypeConst String 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 :: *)
    :: *)