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/Instances.html | 398 ++++++++++++++++++++++++++++++++++++------- 1 file changed, 335 insertions(+), 63 deletions(-) (limited to 'html-test/ref/Instances.html') diff --git a/html-test/ref/Instances.html b/html-test/ref/Instances.html index 40b1045c..a23f9eb9 100644 --- a/html-test/ref/Instances.html +++ b/html-test/ref/Instances.html @@ -102,7 +102,9 @@ >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 :: 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 #data Thud Int ( Int (Quux a [a] c) data Thud Int ( Int (Quux a [a] c) Norf Int Bool Int Bool #type Plugh 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 #

type Plugh [a] c [b] :: * [a] c [b] :: Type #

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