From c04f44e29f38784e0e958abc683164e33f851c86 Mon Sep 17 00:00:00 2001 From: Alec Theriault Date: Thu, 19 Jul 2018 05:39:57 -0700 Subject: Fix HEAD html-test (#860) * Update tests for 'StarIsType' * Accept tests * Revert "Update tests for 'StarIsType'" This reverts commit 7f0c01383bbba6dc5af554ee82988d2cf44e407a. --- html-test/ref/A.html | 24 +- html-test/ref/Bug280.html | 4 +- html-test/ref/Bug3.html | 8 +- html-test/ref/Bug310.html | 44 ++- html-test/ref/Bug387.html | 16 +- html-test/ref/Bug4.html | 8 +- html-test/ref/Bug546.html | 20 +- html-test/ref/Bug548.html | 270 ++++++++++++--- html-test/ref/Bug6.html | 60 +++- html-test/ref/Bug613.html | 10 +- html-test/ref/Bug8.html | 4 +- html-test/ref/BugDeprecated.html | 48 ++- html-test/ref/BugExportHeadings.html | 48 ++- html-test/ref/Bugs.html | 4 +- html-test/ref/BundledPatterns.html | 20 +- html-test/ref/BundledPatterns2.html | 20 +- html-test/ref/ConstructorPatternExport.html | 26 +- 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/DeprecatedTypeSynonym.html | 16 +- html-test/ref/Examples.html | 16 +- html-test/ref/FunArgs.html | 16 +- html-test/ref/GADTRecords.html | 32 +- 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/OrphanInstances.html | 4 +- html-test/ref/OrphanInstancesClass.html | 8 +- html-test/ref/OrphanInstancesType.html | 8 +- html-test/ref/PatternSyns.html | 24 +- html-test/ref/PromotedTypes.html | 8 +- html-test/ref/Properties.html | 16 +- html-test/ref/QuasiExpr.html | 80 ++++- html-test/ref/QuasiQuote.html | 4 +- html-test/ref/SpuriousSuperclassConstraints.html | 38 ++- 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 | 68 +++- html-test/ref/Unicode.html | 8 +- html-test/ref/Visible.html | 6 +- 55 files changed, 1592 insertions(+), 396 deletions(-) (limited to 'html-test/ref') diff --git a/html-test/ref/A.html b/html-test/ref/A.html index c6965abc..e4802966 100644 --- a/html-test/ref/A.html +++ b/html-test/ref/A.html @@ -54,11 +54,15 @@ >
  • other :: Int
    • :: Int
  • test2 :: Bool
    • :: Bool
  • data
  • reExport :: Int
    • :: Int

    other :: Int :: Int #

    test2 :: Bool :: Bool #

    reExport :: Int :: Int #

    x :: [Char] :: [Char] #

  • 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

  • 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 :: Type -> Type -> Type) b c #

    Generic1 ( Generic1 (WrappedArrow a b :: * -> *) a b :: Type -> Type)

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

    Rep1 (WrappedArrow a b) :: k -> Type #

    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) :: Type -> Type #

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

    Since: base-4.7.0.0

    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 :: Type -> Type) = 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)

    Since: base-4.7.0.0

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

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

    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
    • IntInt
  • C4 :: {..} -> H1 Int a
    • Int a

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

    Hash IntInt#

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

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

    VisibleClass IntInt# 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 MaybeMaybe#

    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 :: Type -> Type)#

    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) Norf Int BoolIntBool#typePlugh Int c Bool :: * Int c Bool :: Type#

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

    norf :: Plugh Int c Bool -> Int -> (Int -> c) -> Bool Int c Bool -> Int -> (Int -> c) -> Bool#

    typePlugh [a] c [b] :: * [a] c [b] :: Type#

    data Thud [a] c :: * [a] c :: Type #

  • f :: Integer
    • :: Integer

    f :: Integer :: Integer #

    foo :: Int :: Int #

  • g :: Int
    • :: Int

    g :: Int :: Int #

    aClass :: 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
  • pattern 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 a:: { field :: Int :: Int

    hello docs

    } -> H1 Int Int Int Int
    } -> 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

    Hash Float Float #    		 AType Int
    IntegerStringString 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 #

    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 (MaybeFloat)
  • | BT a b, T Int Float)
    • IntFloat)
  • 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
    • () -> IOInt
  • o :: Float -> IO Float
    • :: Float -> IOFloat
  • f' :: Int
    • :: Int
  • withType :: Int
    • :: Int
  • withoutType
    • Int (MaybeFloat)IntFloat)d :: T Float b Float b #

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

    D IntInt#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 #

    IntIntFloatFloat)-> IO ()
    Show x => Show x => BlubCtor xBlub :: () => forall x. Show x => x -> x. Show x => x -> BlubType #pattern PatWithExplicitSig :: Eq somex => somex -> :: Eq somex => somex -> FooType somex #Cons :: Maybe h -> :: Maybe h -> Pattern t -> PatternRevCons :: Maybe h -> :: Maybe h -> RevPattern t -> RevPattern
  • 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-> IOInt
    :: (Int, Int, Float)

    takes a triple

    -> Int

    returns an IntInt

    -> IO Int

    and the return value

    :: Float-> IOFloatX<> (a :: *) (a :: Type)#X<> (a :: *) = (a :: Type) = XAssocDY :: * :: Type#

    AssocT Y :: * :: Type #

    Y<> (a :: *) (a :: Type)#Y<> (a :: *) = a (a :: Type) = aAssocDY :: * :: Type#

    AssocT Y :: * :: Type #

    AssocDX :: * :: Type#

    AssocT X :: * :: Type #

    Y<> (a :: *) (a :: Type)#Y<> (a :: *) = a (a :: Type) = aX<> (a :: *) (a :: Type)#X<> (a :: *) = (a :: Type) = 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 #

    AssocD X :: * :: Type #

    AssocT X :: * :: Type #

    Foo X :: *)
    :: Type)