Error msg wibbles from reduced module prefixes
authorSimon Peyton Jones <simonpj@microsoft.com>
Tue, 7 Apr 2015 13:54:56 +0000 (14:54 +0100)
committerSimon Peyton Jones <simonpj@microsoft.com>
Tue, 7 Apr 2015 14:10:25 +0000 (15:10 +0100)
39 files changed:
testsuite/tests/annotations/should_fail/annfail05.stderr
testsuite/tests/annotations/should_fail/annfail08.stderr
testsuite/tests/annotations/should_fail/annfail10.stderr
testsuite/tests/deriving/should_fail/T4846.stderr
testsuite/tests/ghci.debugger/scripts/break006.stderr
testsuite/tests/ghci.debugger/scripts/break024.stdout
testsuite/tests/ghci.debugger/scripts/print026.stdout
testsuite/tests/ghci.debugger/scripts/print028.stdout
testsuite/tests/ghci/scripts/T2182ghci2.stderr
testsuite/tests/ghci/scripts/T5417.stdout
testsuite/tests/ghci/scripts/T8469.stdout
testsuite/tests/ghci/scripts/T9181.stdout
testsuite/tests/ghci/scripts/T9881.stdout
testsuite/tests/ghci/scripts/ghci008.stdout
testsuite/tests/ghci/scripts/ghci019.stderr
testsuite/tests/ghci/scripts/ghci019.stdout
testsuite/tests/ghci/scripts/ghci023.stdout
testsuite/tests/ghci/scripts/ghci025.stdout
testsuite/tests/ghci/scripts/ghci027.stdout
testsuite/tests/indexed-types/should_compile/T3017.stderr
testsuite/tests/indexed-types/should_fail/Over.stderr
testsuite/tests/indexed-types/should_fail/T9580.stderr
testsuite/tests/numeric/should_compile/T7116.stdout
testsuite/tests/overloadedlists/should_fail/overloadedlistsfail01.stderr
testsuite/tests/overloadedlists/should_fail/overloadedlistsfail02.stderr
testsuite/tests/partial-sigs/should_compile/ExtraConstraints3.stderr
testsuite/tests/rebindable/rebindable6.stderr
testsuite/tests/th/T3319.stderr
testsuite/tests/th/T5700.stderr
testsuite/tests/th/T7276.stderr
testsuite/tests/th/TH_foreignInterruptible.stderr
testsuite/tests/typecheck/should_fail/T5095.stderr
testsuite/tests/typecheck/should_fail/T8262.stderr
testsuite/tests/typecheck/should_fail/TcStaticPointersFail02.stderr
testsuite/tests/typecheck/should_fail/tcfail068.stderr
testsuite/tests/typecheck/should_fail/tcfail123.stderr
testsuite/tests/typecheck/should_fail/tcfail128.stderr
testsuite/tests/typecheck/should_fail/tcfail200.stderr
testsuite/tests/typecheck/should_fail/tcfail220.stderr

index 712cff2..e9b281e 100644 (file)
@@ -1,5 +1,4 @@
-
-annfail05.hs:11:1:
-    No instance for (Data.Data.Data NoInstances)
-      arising from an annotation
-    In the annotation: {-# ANN f NoInstances #-}
+\r
+annfail05.hs:11:1:\r
+    No instance for (Data NoInstances) arising from an annotation\r
+    In the annotation: {-# ANN f NoInstances #-}\r
index 1c6f9f6..2a9980d 100644 (file)
@@ -1,6 +1,6 @@
 \r
 annfail08.hs:9:1:\r
-    No instance for (Data.Data.Data (a0 -> a0))\r
+    No instance for (Data (a0 -> a0))\r
       (maybe you haven't applied a function to enough arguments?)\r
       arising from an annotation\r
     In the annotation: {-# ANN f (id + 1) #-}\r
index 5b42bd3..5ac8ab5 100644 (file)
@@ -1,30 +1,25 @@
-
-annfail10.hs:9:1:
-    No instance for (Data.Data.Data a0) arising from an annotation
-    The type variable ‘a0’ is ambiguous
-    Note: there are several potential instances:
-      instance (Data.Data.Data a, Data.Data.Data b) =>
-               Data.Data.Data (Either a b)
-        -- Defined in ‘Data.Data’
-      instance Data.Data.Data Data.Monoid.All -- Defined in ‘Data.Data’
-      instance (Data.Data.Data (f a), Data.Data.Data a,
-                Data.Typeable.Internal.Typeable f) =>
-               Data.Data.Data (Data.Monoid.Alt f a)
-        -- Defined in ‘Data.Data’
-      ...plus 39 others
-    In the annotation: {-# ANN f 1 #-}
-
-annfail10.hs:9:11:
-    No instance for (Num a0) arising from the literal ‘1’
-    The type variable ‘a0’ is ambiguous
-    Note: there are several potential instances:
-      instance forall (k :: BOX) (f :: k -> *) (a :: k).
-               Num (f a) =>
-               Num (Data.Monoid.Alt f a)
-        -- Defined in ‘Data.Monoid’
-      instance Num a => Num (Data.Monoid.Product a)
-        -- Defined in ‘Data.Monoid’
-      instance Num a => Num (Data.Monoid.Sum a)
-        -- Defined in ‘Data.Monoid’
-      ...plus 14 others
-    In the annotation: {-# ANN f 1 #-}
+\r
+annfail10.hs:9:1:\r
+    No instance for (Data a0) arising from an annotation\r
+    The type variable ‘a0’ is ambiguous\r
+    Note: there are several potential instances:\r
+      instance (Data a, Data b) => Data (Either a b)\r
+        -- Defined in ‘Data.Data’\r
+      instance Data All -- Defined in ‘Data.Data’\r
+      instance (Data (f a), Data a, Typeable f) => Data (Alt f a)\r
+        -- Defined in ‘Data.Data’\r
+      ...plus 39 others\r
+    In the annotation: {-# ANN f 1 #-}\r
+\r
+annfail10.hs:9:11:\r
+    No instance for (Num a0) arising from the literal ‘1’\r
+    The type variable ‘a0’ is ambiguous\r
+    Note: there are several potential instances:\r
+      instance forall (k :: BOX) (f :: k -> *) (a :: k).\r
+               Num (f a) =>\r
+               Num (Alt f a)\r
+        -- Defined in ‘Data.Monoid’\r
+      instance Num a => Num (Product a) -- Defined in ‘Data.Monoid’\r
+      instance Num a => Num (Sum a) -- Defined in ‘Data.Monoid’\r
+      ...plus 14 others\r
+    In the annotation: {-# ANN f 1 #-}\r
index 33b125f..b0ebb9e 100644 (file)
@@ -5,10 +5,9 @@ T4846.hs:29:1:
       ‘Expr Bool’ and
       ‘Expr BOOL’ are the same
     Relevant role signatures: type role Expr nominal
-    In the expression:
-        GHC.Prim.coerce (mkExpr :: Expr Bool) :: Expr BOOL
+    In the expression: coerce (mkExpr :: Expr Bool) :: Expr BOOL
     In an equation for ‘mkExpr’:
-        mkExpr = GHC.Prim.coerce (mkExpr :: Expr Bool) :: Expr BOOL
+        mkExpr = coerce (mkExpr :: Expr Bool) :: Expr BOOL
     When typechecking the code for ‘mkExpr’
       in a derived instance for ‘B BOOL’:
       To see the code I am typechecking, use -ddump-deriv
index 8658605..8a90905 100644 (file)
@@ -1,32 +1,32 @@
-
-<interactive>:6:1:
-    No instance for (Show t1) arising from a use of ‘print’
-    Cannot resolve unknown runtime type ‘t1’
-    Use :print or :force to determine these types
-    Relevant bindings include it :: t1 (bound at <interactive>:6:1)
-    Note: there are several potential instances:
-      instance (Show a, Show b) => Show (Either a b)
-        -- Defined in ‘Data.Either’
-      instance Show Data.Monoid.All -- Defined in ‘Data.Monoid’
-      instance forall (k :: BOX) (f :: k -> *) (a :: k).
-               Show (f a) =>
-               Show (Data.Monoid.Alt f a)
-        -- Defined in ‘Data.Monoid’
-      ...plus 33 others
-    In a stmt of an interactive GHCi command: print it
-
-<interactive>:8:1:
-    No instance for (Show t1) arising from a use of ‘print’
-    Cannot resolve unknown runtime type ‘t1’
-    Use :print or :force to determine these types
-    Relevant bindings include it :: t1 (bound at <interactive>:8:1)
-    Note: there are several potential instances:
-      instance (Show a, Show b) => Show (Either a b)
-        -- Defined in ‘Data.Either’
-      instance Show Data.Monoid.All -- Defined in ‘Data.Monoid’
-      instance forall (k :: BOX) (f :: k -> *) (a :: k).
-               Show (f a) =>
-               Show (Data.Monoid.Alt f a)
-        -- Defined in ‘Data.Monoid’
-      ...plus 33 others
-    In a stmt of an interactive GHCi command: print it
+\r
+<interactive>:6:1:\r
+    No instance for (Show t1) arising from a use of ‘print’\r
+    Cannot resolve unknown runtime type ‘t1’\r
+    Use :print or :force to determine these types\r
+    Relevant bindings include it :: t1 (bound at <interactive>:6:1)\r
+    Note: there are several potential instances:\r
+      instance (Show a, Show b) => Show (Either a b)\r
+        -- Defined in ‘Data.Either’\r
+      instance Show All -- Defined in ‘Data.Monoid’\r
+      instance forall (k :: BOX) (f :: k -> *) (a :: k).\r
+               Show (f a) =>\r
+               Show (Alt f a)\r
+        -- Defined in ‘Data.Monoid’\r
+      ...plus 33 others\r
+    In a stmt of an interactive GHCi command: print it\r
+\r
+<interactive>:8:1:\r
+    No instance for (Show t1) arising from a use of ‘print’\r
+    Cannot resolve unknown runtime type ‘t1’\r
+    Use :print or :force to determine these types\r
+    Relevant bindings include it :: t1 (bound at <interactive>:8:1)\r
+    Note: there are several potential instances:\r
+      instance (Show a, Show b) => Show (Either a b)\r
+        -- Defined in ‘Data.Either’\r
+      instance Show All -- Defined in ‘Data.Monoid’\r
+      instance forall (k :: BOX) (f :: k -> *) (a :: k).\r
+               Show (f a) =>\r
+               Show (Alt f a)\r
+        -- Defined in ‘Data.Monoid’\r
+      ...plus 33 others\r
+    In a stmt of an interactive GHCi command: print it\r
index dc3bd73..62aa429 100644 (file)
@@ -1,19 +1,16 @@
-Left user error (error)
-Stopped at <exception thrown>
-_exception :: e = _
-_exception = SomeException
-               (GHC.IO.Exception.IOError
-                  Nothing GHC.IO.Exception.UserError [] "error" Nothing Nothing)
-*** Exception: user error (error)
-Stopped at <exception thrown>
-_exception :: e = _
-_exception = SomeException
-               (GHC.IO.Exception.IOError
-                  Nothing GHC.IO.Exception.UserError [] "error" Nothing Nothing)
-*** Exception: user error (error)
-Stopped at <exception thrown>
-_exception :: e = _
-_exception = SomeException
-               (GHC.IO.Exception.IOError
-                  Nothing GHC.IO.Exception.UserError [] "error" Nothing Nothing)
-Left user error (error)
+Left user error (error)\r
+Stopped at <exception thrown>\r
+_exception :: e = _\r
+_exception = SomeException\r
+               (IOError Nothing UserError [] "error" Nothing Nothing)\r
+*** Exception: user error (error)\r
+Stopped at <exception thrown>\r
+_exception :: e = _\r
+_exception = SomeException\r
+               (IOError Nothing UserError [] "error" Nothing Nothing)\r
+*** Exception: user error (error)\r
+Stopped at <exception thrown>\r
+_exception :: e = _\r
+_exception = SomeException\r
+               (IOError Nothing UserError [] "error" Nothing Nothing)\r
+Left user error (error)\r
index decc3df..25abae2 100644 (file)
@@ -1,6 +1,6 @@
-fromList "abc"
-l = Data.Sequence.Seq (Data.Sequence.Deep
-                         3 (Data.Sequence.One (Data.Sequence.Elem 'a')) Data.Sequence.Empty
-                         (Data.Sequence.Two
-                            (Data.Sequence.Elem 'b') (Data.Sequence.Elem 'c')))
-l = fromList "abc"
+fromList "abc"\r
+l = Data.Sequence.Seq (Data.Sequence.Deep\r
+                         3 (Data.Sequence.One (Data.Sequence.Elem 'a')) Data.Sequence.Empty\r
+                         (Data.Sequence.Two\r
+                            (Data.Sequence.Elem 'b') (Data.Sequence.Elem 'c')))\r
+l = fromList "abc"\r
index 93a80bc..3e44dcc 100644 (file)
@@ -1,6 +1,5 @@
-l = (_t1::[Maybe Integer])
-Just 1
-r = GHC.IORef.IORef (GHC.STRef.STRef
-                       (GHC.Prim.MutVar# (Just 1 : (_t2::[Maybe Integer]))))
-r = GHC.IORef.IORef (GHC.STRef.STRef
-                       (GHC.Prim.MutVar# (Just 1 : _)))
+l = (_t1::[Maybe Integer])\r
+Just 1\r
+r = IORef (STRef\r
+             (GHC.Prim.MutVar# (Just 1 : (_t2::[Maybe Integer]))))\r
+r = IORef (STRef (GHC.Prim.MutVar# (Just 1 : _)))\r
index 0a7f619..f850e1d 100644 (file)
@@ -1,10 +1,8 @@
-
-<interactive>:8:1:
-    No instance for (GHC.Show.Show Float)
-      arising from a use of ‘System.IO.print’
-    In a stmt of an interactive GHCi command: System.IO.print it
-
-<interactive>:16:1:
-    No instance for (GHC.Show.Show Float)
-      arising from a use of ‘System.IO.print’
-    In a stmt of an interactive GHCi command: System.IO.print it
+\r
+<interactive>:8:1:\r
+    No instance for (Show Float) arising from a use of ‘print’\r
+    In a stmt of an interactive GHCi command: print it\r
+\r
+<interactive>:16:1:\r
+    No instance for (Show Float) arising from a use of ‘print’\r
+    In a stmt of an interactive GHCi command: print it\r
index 1085a17..2640c4e 100644 (file)
@@ -1,9 +1,9 @@
-data B1 a = B1 a
-data instance C.F (B1 a) = B2 a
-type role D nominal
-data family D a
-class C.C1 a where
-  type role C.F nominal
-  data family C.F a
-       -- Defined at T5417a.hs:5:5
-data instance C.F (B1 a) = B2 a        -- Defined at T5417.hs:8:10
+data B1 a = B1 a\r
+data instance C.F (B1 a) = B2 a\r
+type role D nominal\r
+data family D a\r
+class C.C1 a where\r
+  type role C.F nominal\r
+  data family C.F a\r
+       -- Defined at T5417a.hs:5:5\r
+data instance C.F (B1 a) = B2 a        -- Defined at T5417.hs:8:10\r
index cd7966e..c052868 100644 (file)
@@ -1,10 +1,10 @@
-data Int = GHC.Types.I# GHC.Prim.Int#  -- Defined in ‘GHC.Types’
-instance Bounded Int -- Defined in ‘GHC.Enum’
-instance Enum Int -- Defined in ‘GHC.Enum’
-instance Eq Int -- Defined in ‘GHC.Classes’
-instance Integral Int -- Defined in ‘GHC.Real’
-instance Num Int -- Defined in ‘GHC.Num’
-instance Ord Int -- Defined in ‘GHC.Classes’
-instance Read Int -- Defined in ‘GHC.Read’
-instance Real Int -- Defined in ‘GHC.Real’
-instance Show Int -- Defined in ‘GHC.Show’
+data Int = I# Int#     -- Defined in ‘GHC.Types’\r
+instance Bounded Int -- Defined in ‘GHC.Enum’\r
+instance Enum Int -- Defined in ‘GHC.Enum’\r
+instance Eq Int -- Defined in ‘GHC.Classes’\r
+instance Integral Int -- Defined in ‘GHC.Real’\r
+instance Num Int -- Defined in ‘GHC.Num’\r
+instance Ord Int -- Defined in ‘GHC.Classes’\r
+instance Read Int -- Defined in ‘GHC.Read’\r
+instance Real Int -- Defined in ‘GHC.Real’\r
+instance Show Int -- Defined in ‘GHC.Show’\r
index e1ac00c..6b67785 100644 (file)
@@ -1,54 +1,29 @@
-type family (GHC.TypeLits.*) (a :: GHC.TypeLits.Nat)
-                             (b :: GHC.TypeLits.Nat) ::
-  GHC.TypeLits.Nat
-type family (GHC.TypeLits.+) (a :: GHC.TypeLits.Nat)
-                             (b :: GHC.TypeLits.Nat) ::
-  GHC.TypeLits.Nat
-type family (GHC.TypeLits.-) (a :: GHC.TypeLits.Nat)
-                             (b :: GHC.TypeLits.Nat) ::
-  GHC.TypeLits.Nat
-type (GHC.TypeLits.<=) (x :: GHC.TypeLits.Nat)
-                       (y :: GHC.TypeLits.Nat) =
-  (x GHC.TypeLits.<=? y) ~ 'True
-type family (GHC.TypeLits.<=?) (a :: GHC.TypeLits.Nat)
-                               (b :: GHC.TypeLits.Nat) ::
-  Bool
-type family GHC.TypeLits.CmpNat (a :: GHC.TypeLits.Nat)
-                                (b :: GHC.TypeLits.Nat) ::
-  Ordering
-type family GHC.TypeLits.CmpSymbol (a :: GHC.TypeLits.Symbol)
-                                   (b :: GHC.TypeLits.Symbol) ::
-  Ordering
-class GHC.TypeLits.KnownNat (n :: GHC.TypeLits.Nat) where
-  GHC.TypeLits.natSing :: GHC.TypeLits.SNat n
-class GHC.TypeLits.KnownSymbol (n :: GHC.TypeLits.Symbol) where
-  GHC.TypeLits.symbolSing :: GHC.TypeLits.SSymbol n
-data GHC.TypeLits.Nat
-data GHC.TypeLits.SomeNat where
-  GHC.TypeLits.SomeNat :: GHC.TypeLits.KnownNat n =>
-                          (Data.Proxy.Proxy n) -> GHC.TypeLits.SomeNat
-data GHC.TypeLits.SomeSymbol where
-  GHC.TypeLits.SomeSymbol :: GHC.TypeLits.KnownSymbol n =>
-                             (Data.Proxy.Proxy n) -> GHC.TypeLits.SomeSymbol
-data GHC.TypeLits.Symbol
-type family (GHC.TypeLits.^) (a :: GHC.TypeLits.Nat)
-                             (b :: GHC.TypeLits.Nat) ::
-  GHC.TypeLits.Nat
-GHC.TypeLits.natVal ::
-  GHC.TypeLits.KnownNat n => proxy n -> Integer
-GHC.TypeLits.natVal' ::
-  GHC.TypeLits.KnownNat n => GHC.Prim.Proxy# n -> Integer
-GHC.TypeLits.sameNat ::
-  (GHC.TypeLits.KnownNat a, GHC.TypeLits.KnownNat b) =>
-  Data.Proxy.Proxy a
-  -> Data.Proxy.Proxy b -> Maybe (a Data.Type.Equality.:~: b)
-GHC.TypeLits.sameSymbol ::
-  (GHC.TypeLits.KnownSymbol a, GHC.TypeLits.KnownSymbol b) =>
-  Data.Proxy.Proxy a
-  -> Data.Proxy.Proxy b -> Maybe (a Data.Type.Equality.:~: b)
-GHC.TypeLits.someNatVal :: Integer -> Maybe GHC.TypeLits.SomeNat
-GHC.TypeLits.someSymbolVal :: String -> GHC.TypeLits.SomeSymbol
-GHC.TypeLits.symbolVal ::
-  GHC.TypeLits.KnownSymbol n => proxy n -> String
-GHC.TypeLits.symbolVal' ::
-  GHC.TypeLits.KnownSymbol n => GHC.Prim.Proxy# n -> String
+type family (*) (a :: Nat) (b :: Nat) :: Nat\r
+type family (+) (a :: Nat) (b :: Nat) :: Nat\r
+type family (-) (a :: Nat) (b :: Nat) :: Nat\r
+type (<=) (x :: Nat) (y :: Nat) = (x <=? y) ~ 'True\r
+type family (<=?) (a :: Nat) (b :: Nat) :: Bool\r
+type family CmpNat (a :: Nat) (b :: Nat) :: Ordering\r
+type family CmpSymbol (a :: Symbol) (b :: Symbol) :: Ordering\r
+class KnownNat (n :: Nat) where\r
+  natSing :: SNat n\r
+class KnownSymbol (n :: Symbol) where\r
+  symbolSing :: SSymbol n\r
+data Nat\r
+data SomeNat where\r
+  SomeNat :: KnownNat n => (Proxy n) -> SomeNat\r
+data SomeSymbol where\r
+  SomeSymbol :: KnownSymbol n => (Proxy n) -> SomeSymbol\r
+data Symbol\r
+type family (^) (a :: Nat) (b :: Nat) :: Nat\r
+natVal :: KnownNat n => proxy n -> Integer\r
+natVal' :: KnownNat n => Proxy# n -> Integer\r
+sameNat ::\r
+  (KnownNat a, KnownNat b) => Proxy a -> Proxy b -> Maybe (a :~: b)\r
+sameSymbol ::\r
+  (KnownSymbol a, KnownSymbol b) =>\r
+  Proxy a -> Proxy b -> Maybe (a :~: b)\r
+someNatVal :: Integer -> Maybe SomeNat\r
+someSymbolVal :: String -> SomeSymbol\r
+symbolVal :: KnownSymbol n => proxy n -> String\r
+symbolVal' :: KnownSymbol n => Proxy# n -> String\r
index 6866a6a..1fa697f 100644 (file)
@@ -1,32 +1,31 @@
-data Data.ByteString.Lazy.ByteString
-  = Data.ByteString.Lazy.Internal.Empty
-  | Data.ByteString.Lazy.Internal.Chunk {-# UNPACK #-}Data.ByteString.ByteString
-                                        Data.ByteString.Lazy.ByteString
-       -- Defined in ‘Data.ByteString.Lazy.Internal’
-instance Eq Data.ByteString.Lazy.ByteString
-  -- Defined in ‘Data.ByteString.Lazy.Internal’
-instance Ord Data.ByteString.Lazy.ByteString
-  -- Defined in ‘Data.ByteString.Lazy.Internal’
-instance Read Data.ByteString.Lazy.ByteString
-  -- Defined in ‘Data.ByteString.Lazy.Internal’
-instance Show Data.ByteString.Lazy.ByteString
-  -- Defined in ‘Data.ByteString.Lazy.Internal’
-instance Monoid Data.ByteString.Lazy.ByteString
-  -- Defined in ‘Data.ByteString.Lazy.Internal’
-
-data Data.ByteString.ByteString
-  = Data.ByteString.Internal.PS {-# UNPACK #-}(GHC.ForeignPtr.ForeignPtr
-                                                 GHC.Word.Word8)
-                                {-# UNPACK #-}Int
-                                {-# UNPACK #-}Int
-       -- Defined in ‘Data.ByteString.Internal’
-instance Eq Data.ByteString.ByteString
-  -- Defined in ‘Data.ByteString.Internal’
-instance Ord Data.ByteString.ByteString
-  -- Defined in ‘Data.ByteString.Internal’
-instance Read Data.ByteString.ByteString
-  -- Defined in ‘Data.ByteString.Internal’
-instance Show Data.ByteString.ByteString
-  -- Defined in ‘Data.ByteString.Internal’
-instance Monoid Data.ByteString.ByteString
-  -- Defined in ‘Data.ByteString.Internal’
+data Data.ByteString.Lazy.ByteString\r
+  = Data.ByteString.Lazy.Internal.Empty\r
+  | Data.ByteString.Lazy.Internal.Chunk {-# UNPACK #-}Data.ByteString.ByteString\r
+                                        Data.ByteString.Lazy.ByteString\r
+       -- Defined in ‘Data.ByteString.Lazy.Internal’\r
+instance Eq Data.ByteString.Lazy.ByteString\r
+  -- Defined in ‘Data.ByteString.Lazy.Internal’\r
+instance Ord Data.ByteString.Lazy.ByteString\r
+  -- Defined in ‘Data.ByteString.Lazy.Internal’\r
+instance Read Data.ByteString.Lazy.ByteString\r
+  -- Defined in ‘Data.ByteString.Lazy.Internal’\r
+instance Show Data.ByteString.Lazy.ByteString\r
+  -- Defined in ‘Data.ByteString.Lazy.Internal’\r
+instance Monoid Data.ByteString.Lazy.ByteString\r
+  -- Defined in ‘Data.ByteString.Lazy.Internal’\r
+\r
+data Data.ByteString.ByteString\r
+  = Data.ByteString.Internal.PS {-# UNPACK #-}(ForeignPtr Word8)\r
+                                {-# UNPACK #-}Int\r
+                                {-# UNPACK #-}Int\r
+       -- Defined in ‘Data.ByteString.Internal’\r
+instance Eq Data.ByteString.ByteString\r
+  -- Defined in ‘Data.ByteString.Internal’\r
+instance Ord Data.ByteString.ByteString\r
+  -- Defined in ‘Data.ByteString.Internal’\r
+instance Read Data.ByteString.ByteString\r
+  -- Defined in ‘Data.ByteString.Internal’\r
+instance Show Data.ByteString.ByteString\r
+  -- Defined in ‘Data.ByteString.Internal’\r
+instance Monoid Data.ByteString.ByteString\r
+  -- Defined in ‘Data.ByteString.Internal’\r
index 8aec160..0f9c93a 100644 (file)
@@ -1,36 +1,34 @@
-class Num a where
-  (+) :: a -> a -> a
-  ...
-       -- Defined in ‘GHC.Num’
-infixl 6 +
-class Num a where
-  (+) :: a -> a -> a
-  ...
-       -- Defined in ‘GHC.Num’
-infixl 6 +
-data Data.Complex.Complex a = !a Data.Complex.:+ !a
-       -- Defined in ‘Data.Complex’
-infix 6 Data.Complex.:+
-data Data.Complex.Complex a = !a Data.Complex.:+ !a
-       -- Defined in ‘Data.Complex’
-infix 6 Data.Complex.:+
-class (RealFrac a, Floating a) => RealFloat a where
-  floatRadix :: a -> Integer
-  floatDigits :: a -> Int
-  floatRange :: a -> (Int, Int)
-  decodeFloat :: a -> (Integer, Int)
-  encodeFloat :: Integer -> Int -> a
-  exponent :: a -> Int
-  significand :: a -> a
-  scaleFloat :: Int -> a -> a
-  isNaN :: a -> Bool
-  isInfinite :: a -> Bool
-  isDenormalized :: a -> Bool
-  isNegativeZero :: a -> Bool
-  isIEEE :: a -> Bool
-  atan2 :: a -> a -> a
-       -- Defined in ‘GHC.Float’
-instance RealFloat Float -- Defined in ‘GHC.Float’
-instance RealFloat Double -- Defined in ‘GHC.Float’
-base-4.8.1.0:Data.OldList.isPrefixOf :: Eq a => [a] -> [a] -> Bool
-       -- Defined in ‘base-4.8.1.0:Data.OldList’
+class Num a where\r
+  (+) :: a -> a -> a\r
+  ...\r
+       -- Defined in ‘GHC.Num’\r
+infixl 6 +\r
+class Num a where\r
+  (+) :: a -> a -> a\r
+  ...\r
+       -- Defined in ‘GHC.Num’\r
+infixl 6 +\r
+data Complex a = !a :+ !a      -- Defined in ‘Data.Complex’\r
+infix 6 :+\r
+data Complex a = !a :+ !a      -- Defined in ‘Data.Complex’\r
+infix 6 :+\r
+class (RealFrac a, Floating a) => RealFloat a where\r
+  floatRadix :: a -> Integer\r
+  floatDigits :: a -> Int\r
+  floatRange :: a -> (Int, Int)\r
+  decodeFloat :: a -> (Integer, Int)\r
+  encodeFloat :: Integer -> Int -> a\r
+  exponent :: a -> Int\r
+  significand :: a -> a\r
+  scaleFloat :: Int -> a -> a\r
+  isNaN :: a -> Bool\r
+  isInfinite :: a -> Bool\r
+  isDenormalized :: a -> Bool\r
+  isNegativeZero :: a -> Bool\r
+  isIEEE :: a -> Bool\r
+  atan2 :: a -> a -> a\r
+       -- Defined in ‘GHC.Float’\r
+instance RealFloat Float -- Defined in ‘GHC.Float’\r
+instance RealFloat Double -- Defined in ‘GHC.Float’\r
+isPrefixOf :: Eq a => [a] -> [a] -> Bool\r
+       -- Defined in ‘base-4.8.1.0:Data.OldList’\r
index de8c7f0..10f6a54 100644 (file)
@@ -1,5 +1,5 @@
-
-ghci019.hs:9:10: Warning:
-    No explicit implementation for
-      either ‘Prelude.==’ or ‘Prelude./=’
-    In the instance declaration for ‘Prelude.Eq Foo’
+\r
+ghci019.hs:9:10: Warning:\r
+    No explicit implementation for\r
+      either ‘==’ or ‘/=’\r
+    In the instance declaration for ‘Eq Foo’\r
index 4f346e7..85b5e02 100644 (file)
@@ -1,2 +1,2 @@
-data Foo = Foo         -- Defined at ghci019.hs:8:1
-instance Prelude.Eq Foo -- Defined at ghci019.hs:9:10
+data Foo = Foo         -- Defined at ghci019.hs:8:1\r
+instance Eq Foo -- Defined at ghci019.hs:9:10\r
index 51c1b91..010fe50 100644 (file)
@@ -1,16 +1,16 @@
--- testing ghci multiline commands :{ .. :}
--- via stdin
-(1,2,3)
-Data.Maybe.catMaybes :: [Maybe a] -> [a]
-Data.Maybe.fromJust :: Maybe a -> a
-Data.Maybe.fromMaybe :: a -> Maybe a -> a
-Data.Maybe.isJust :: Maybe a -> Bool
-Data.Maybe.isNothing :: Maybe a -> Bool
-Data.Maybe.listToMaybe :: [a] -> Maybe a
-Data.Maybe.mapMaybe :: (a -> Maybe b) -> [a] -> [b]
-maybe :: b -> (a -> b) -> Maybe a -> b
-Data.Maybe.maybeToList :: Maybe a -> [a]
-data Maybe a = Nothing | Just a
--- via readFile
-(True,False)
-id :: a -> a
+-- testing ghci multiline commands :{ .. :}\r
+-- via stdin\r
+(1,2,3)\r
+catMaybes :: [Maybe a] -> [a]\r
+fromJust :: Maybe a -> a\r
+fromMaybe :: a -> Maybe a -> a\r
+isJust :: Maybe a -> Bool\r
+isNothing :: Maybe a -> Bool\r
+listToMaybe :: [a] -> Maybe a\r
+mapMaybe :: (a -> Maybe b) -> [a] -> [b]\r
+maybe :: b -> (a -> b) -> Maybe a -> b\r
+maybeToList :: Maybe a -> [a]\r
+data Maybe a = Nothing | Just a\r
+-- via readFile\r
+(True,False)\r
+id :: a -> a\r
index 532a334..e5b5bc3 100644 (file)
--- test :browse! functionality
-:browse! *T
--- defined locally
-T.length :: T.Integer
-class N a
-class S a
-class C a b where
-  c1 :: N b => a -> b
-  c2 :: (N b, S b) => a -> b
-  c3 :: a1 -> b
-  c4 :: a1 -> b
-c1 :: (C a b, N b) => a -> b
-c2 :: (C a b, N b, S b) => a -> b
-c3 :: C a b => forall a. a -> b
-c4 :: C a b => forall a1. a1 -> b
--- imported via Control.Monad
-class (GHC.Base.Alternative m, Monad m) =>
-      MonadPlus (m :: * -> *) where
-  mzero :: m a
-  mplus :: m a -> m a -> m a
-mplus :: MonadPlus m => forall a. m a -> m a -> m a
-mzero :: MonadPlus m => forall a. m a
--- imported via Control.Monad, Prelude
-(>>) :: Monad m => forall a b. m a -> m b -> m b
-(>>=) :: Monad m => forall a b. m a -> (a -> m b) -> m b
-fail :: Monad m => forall a. GHC.Base.String -> m a
-return :: Monad m => forall a. a -> m a
--- imported via Control.Monad, Prelude, T
-class GHC.Base.Applicative m => Monad (m :: * -> *) where
-  (>>=) :: m a -> (a -> m b) -> m b
-  (>>) :: m a -> m b -> m b
-  return :: a -> m a
-  fail :: GHC.Base.String -> m a
--- imported via Data.Maybe
-catMaybes :: [Maybe a] -> [a]
-fromJust :: Maybe a -> a
-fromMaybe :: a -> Maybe a -> a
-isJust :: Maybe a -> GHC.Types.Bool
-isNothing :: Maybe a -> GHC.Types.Bool
-listToMaybe :: [a] -> Maybe a
-mapMaybe :: (a -> Maybe b) -> [a] -> [b]
-maybe :: b -> (a -> b) -> Maybe a -> b
-maybeToList :: Maybe a -> [a]
--- imported via Data.Maybe, Prelude
-Just :: a -> Maybe a
-data Maybe a = Nothing | Just a
-Nothing :: Maybe a
--- imported via Prelude
-(+) :: GHC.Num.Num a => a -> a -> a
-(=<<) :: Monad m => (a -> m b) -> m a -> m b
-class Eq a where
-  (GHC.Classes.==) :: a -> a -> GHC.Types.Bool
-  (GHC.Classes./=) :: a -> a -> GHC.Types.Bool
--- imported via Prelude, T
-Prelude.length ::
-  Data.Foldable.Foldable t => forall a. t a -> GHC.Types.Int
--- imported via T
-data T.Integer
-  = integer-gmp-1.0.0.0:GHC.Integer.Type.S# !GHC.Prim.Int#
-  | integer-gmp-1.0.0.0:GHC.Integer.Type.Jp# {-# UNPACK #-}integer-gmp-1.0.0.0:GHC.Integer.Type.BigNat
-  | integer-gmp-1.0.0.0:GHC.Integer.Type.Jn# {-# UNPACK #-}integer-gmp-1.0.0.0:GHC.Integer.Type.BigNat
-T.length :: Data.ByteString.Internal.ByteString -> GHC.Types.Int
-:browse! T
--- defined locally
-T.length :: T.Integer
-class N a
-class S a
-class C a b where
-  c1 :: N b => a -> b
-  c2 :: (N b, S b) => a -> b
-  c3 :: a1 -> b
-  c4 :: a1 -> b
-c1 :: (C a b, N b) => a -> b
-c2 :: (C a b, N b, S b) => a -> b
-c3 :: C a b => forall a. a -> b
-c4 :: C a b => forall a1. a1 -> b
-:browse! T -- with -fprint-explicit-foralls
--- defined locally
-T.length :: T.Integer
-class N a
-class S a
-class C a b where
-  c1 :: N b => a -> b
-  c2 :: (N b, S b) => a -> b
-  c3 :: forall a1. a1 -> b
-  c4 :: forall a1. a1 -> b
-c1 :: forall a b. (C a b, N b) => a -> b
-c2 :: forall a b. (C a b, N b, S b) => a -> b
-c3 :: forall a b. C a b => forall a. a -> b
-c4 :: forall a b. C a b => forall a1. a1 -> b
--- test :browse! <target> relative to different contexts
-:browse! Ghci025C -- from *Ghci025C>
--- defined locally
-g :: forall a. Num a => a -> a
-h :: forall a. Integral a => a -> a
--- imported via Ghci025D
-f :: forall a. Num a => a -> a
-:browse! Ghci025C -- from *Ghci025B>, after :add Ghci025B
--- imported via Ghci025C
-g :: forall a. Num a => a -> a
-h :: forall a. Integral a => a -> a
-f :: forall a. Num a => a -> a
-:browse! Ghci025C -- from *Ghci025C>, after :m *Ghci025C
--- defined locally
-g :: forall a. Num a => a -> a
-h :: forall a. Integral a => a -> a
--- imported via Ghci025D
-f :: forall a. Num a => a -> a
-:browse! Ghci025C -- from *Ghci025D>, after :m *Ghci025D
--- not currently imported
-Ghci025C.g :: forall a. Num a => a -> a
-Ghci025C.h :: forall a. Integral a => a -> a
--- defined locally
-f :: forall a. Num a => a -> a
+-- test :browse! functionality\r
+:browse! *T\r
+-- defined locally\r
+T.length :: T.Integer\r
+class N a\r
+class S a\r
+class C a b where\r
+  c1 :: N b => a -> b\r
+  c2 :: (N b, S b) => a -> b\r
+  c3 :: a1 -> b\r
+  c4 :: a1 -> b\r
+c1 :: (C a b, N b) => a -> b\r
+c2 :: (C a b, N b, S b) => a -> b\r
+c3 :: C a b => forall a. a -> b\r
+c4 :: C a b => forall a1. a1 -> b\r
+-- imported via Control.Monad\r
+class (Alternative m, Monad m) => MonadPlus (m :: * -> *) where\r
+  mzero :: m a\r
+  mplus :: m a -> m a -> m a\r
+mplus :: MonadPlus m => forall a. m a -> m a -> m a\r
+mzero :: MonadPlus m => forall a. m a\r
+-- imported via Control.Monad, Prelude\r
+(>>) :: Monad m => forall a b. m a -> m b -> m b\r
+(>>=) :: Monad m => forall a b. m a -> (a -> m b) -> m b\r
+fail :: Monad m => forall a. String -> m a\r
+return :: Monad m => forall a. a -> m a\r
+-- imported via Control.Monad, Prelude, T\r
+class Applicative m => Monad (m :: * -> *) where\r
+  (>>=) :: m a -> (a -> m b) -> m b\r
+  (>>) :: m a -> m b -> m b\r
+  return :: a -> m a\r
+  fail :: String -> m a\r
+-- imported via Data.Maybe\r
+catMaybes :: [Maybe a] -> [a]\r
+fromJust :: Maybe a -> a\r
+fromMaybe :: a -> Maybe a -> a\r
+isJust :: Maybe a -> Bool\r
+isNothing :: Maybe a -> Bool\r
+listToMaybe :: [a] -> Maybe a\r
+mapMaybe :: (a -> Maybe b) -> [a] -> [b]\r
+maybe :: b -> (a -> b) -> Maybe a -> b\r
+maybeToList :: Maybe a -> [a]\r
+-- imported via Data.Maybe, Prelude\r
+Just :: a -> Maybe a\r
+data Maybe a = Nothing | Just a\r
+Nothing :: Maybe a\r
+-- imported via Prelude\r
+(+) :: Num a => a -> a -> a\r
+(=<<) :: Monad m => (a -> m b) -> m a -> m b\r
+class Eq a where\r
+  (==) :: a -> a -> Bool\r
+  (/=) :: a -> a -> Bool\r
+-- imported via Prelude, T\r
+Prelude.length :: Foldable t => forall a. t a -> Int\r
+-- imported via T\r
+data T.Integer\r
+  = integer-gmp-1.0.0.0:GHC.Integer.Type.S# !Int#\r
+  | integer-gmp-1.0.0.0:GHC.Integer.Type.Jp# {-# UNPACK #-}integer-gmp-1.0.0.0:GHC.Integer.Type.BigNat\r
+  | integer-gmp-1.0.0.0:GHC.Integer.Type.Jn# {-# UNPACK #-}integer-gmp-1.0.0.0:GHC.Integer.Type.BigNat\r
+T.length :: Data.ByteString.Internal.ByteString -> Int\r
+:browse! T\r
+-- defined locally\r
+T.length :: T.Integer\r
+class N a\r
+class S a\r
+class C a b where\r
+  c1 :: N b => a -> b\r
+  c2 :: (N b, S b) => a -> b\r
+  c3 :: a1 -> b\r
+  c4 :: a1 -> b\r
+c1 :: (C a b, N b) => a -> b\r
+c2 :: (C a b, N b, S b) => a -> b\r
+c3 :: C a b => forall a. a -> b\r
+c4 :: C a b => forall a1. a1 -> b\r
+:browse! T -- with -fprint-explicit-foralls\r
+-- defined locally\r
+T.length :: T.Integer\r
+class N a\r
+class S a\r
+class C a b where\r
+  c1 :: N b => a -> b\r
+  c2 :: (N b, S b) => a -> b\r
+  c3 :: forall a1. a1 -> b\r
+  c4 :: forall a1. a1 -> b\r
+c1 :: forall a b. (C a b, N b) => a -> b\r
+c2 :: forall a b. (C a b, N b, S b) => a -> b\r
+c3 :: forall a b. C a b => forall a. a -> b\r
+c4 :: forall a b. C a b => forall a1. a1 -> b\r
+-- test :browse! <target> relative to different contexts\r
+:browse! Ghci025C -- from *Ghci025C>\r
+-- defined locally\r
+g :: forall a. Num a => a -> a\r
+h :: forall a. Integral a => a -> a\r
+-- imported via Ghci025D\r
+f :: forall a. Num a => a -> a\r
+:browse! Ghci025C -- from *Ghci025B>, after :add Ghci025B\r
+-- imported via Ghci025C\r
+g :: forall a. Num a => a -> a\r
+h :: forall a. Integral a => a -> a\r
+f :: forall a. Num a => a -> a\r
+:browse! Ghci025C -- from *Ghci025C>, after :m *Ghci025C\r
+-- defined locally\r
+g :: forall a. Num a => a -> a\r
+h :: forall a. Integral a => a -> a\r
+-- imported via Ghci025D\r
+f :: forall a. Num a => a -> a\r
+:browse! Ghci025C -- from *Ghci025D>, after :m *Ghci025D\r
+-- not currently imported\r
+Ghci025C.g :: forall a. Num a => a -> a\r
+Ghci025C.h :: forall a. Integral a => a -> a\r
+-- defined locally\r
+f :: forall a. Num a => a -> a\r
index bbe355c..33b138d 100644 (file)
@@ -1,8 +1,6 @@
-class (GHC.Base.Alternative m, GHC.Base.Monad m) =>
-      GHC.Base.MonadPlus (m :: * -> *) where
-  ...
-  mplus :: m a -> m a -> m a
-class (GHC.Base.Alternative m, GHC.Base.Monad m) =>
-      GHC.Base.MonadPlus (m :: * -> *) where
-  ...
-  Control.Monad.mplus :: m a -> m a -> m a
+class (Alternative m, Monad m) => MonadPlus (m :: * -> *) where\r
+  ...\r
+  mplus :: m a -> m a -> m a\r
+class (Alternative m, Monad m) => MonadPlus (m :: * -> *) where\r
+  ...\r
+  mplus :: m a -> m a -> m a\r
index ee83f16..3323235 100644 (file)
@@ -1,20 +1,20 @@
-TYPE SIGNATURES
-  emptyL :: forall a. ListColl a
-  test2 ::
-    forall c t t1. (Num t, Num t1, Coll c, Elem c ~ (t, t1)) => c -> c
-TYPE CONSTRUCTORS
-  class Coll c where
-    type family Elem c :: * open
-    empty :: c
-    insert :: Elem c -> c -> c
-  data ListColl a = L [a]
-    Promotable
-COERCION AXIOMS
-  axiom Foo.TFCo:R:ElemListColl :: Elem (ListColl a) = a
-INSTANCES
-  instance Coll (ListColl a) -- Defined at T3017.hs:12:11
-FAMILY INSTANCES
-  type Elem (ListColl a)
-Dependent modules: []
-Dependent packages: [base-4.8.1.0, ghc-prim-0.4.0.0,
-                     integer-gmp-1.0.0.0]
+TYPE SIGNATURES\r
+  emptyL :: forall a. ListColl a\r
+  test2 ::\r
+    forall c t t1. (Num t, Num t1, Coll c, Elem c ~ (t, t1)) => c -> c\r
+TYPE CONSTRUCTORS\r
+  class Coll c where\r
+    type family Elem c :: * open\r
+    empty :: c\r
+    insert :: Elem c -> c -> c\r
+  data ListColl a = L [a]\r
+    Promotable\r
+COERCION AXIOMS\r
+  axiom Foo.TFCo:R:ElemListColl :: Elem (ListColl a) = a\r
+INSTANCES\r
+  instance Coll (ListColl a) -- Defined at T3017.hs:12:11\r
+FAMILY INSTANCES\r
+  type Elem (ListColl a)\r
+Dependent modules: []\r
+Dependent packages: [base-4.8.1.0, ghc-prim-0.4.0.0,\r
+                     integer-gmp-1.0.0.0]\r
index ae89d05..3eef322 100644 (file)
@@ -1,10 +1,10 @@
-
-OverB.hs:7:15:
-    Conflicting family instance declarations:
-      OverA.C [Int] [a] -- Defined at OverB.hs:7:15
-      OverA.C [a] [Int] -- Defined at OverC.hs:7:15
-
-OverB.hs:9:15:
-    Conflicting family instance declarations:
-      OverA.D [Int] [a] -- Defined at OverB.hs:9:15
-      OverA.D [a] [Int] -- Defined at OverC.hs:9:15
+\r
+OverB.hs:7:15:\r
+    Conflicting family instance declarations:\r
+      OverA.C [Int] [a] -- Defined at OverB.hs:7:15\r
+      OverA.C [a] [Int] -- Defined at OverC.hs:7:15\r
+\r
+OverB.hs:9:15:\r
+    Conflicting family instance declarations:\r
+      OverA.D [Int] [a] -- Defined at OverB.hs:9:15\r
+      OverA.D [a] [Int] -- Defined at OverC.hs:9:15\r
index 2ed480f..e2b7eb0 100644 (file)
@@ -1,11 +1,11 @@
-[1 of 2] Compiling T9580a           ( T9580a.hs, T9580a.o )
-[2 of 2] Compiling T9580            ( T9580.hs, T9580.o )
-
-T9580.hs:7:9:
-    Couldn't match representation of type ‘Dimensional Int Double’
-                             with that of ‘Double’
-    Relevant role signatures: type role Dimensional nominal nominal
-    The data constructor ‘T9580a.Quantity'’
-      of newtype ‘Dimensional Int v’ is not in scope
-    In the expression: coerce x
-    In an equation for ‘foo’: foo x = coerce x
+[1 of 2] Compiling T9580a           ( T9580a.hs, T9580a.o )\r
+[2 of 2] Compiling T9580            ( T9580.hs, T9580.o )\r
+\r
+T9580.hs:7:9:\r
+    Couldn't match representation of type ‘Dimensional Int Double’\r
+                             with that of ‘Double’\r
+    Relevant role signatures: type role Dimensional nominal nominal\r
+    The data constructor ‘T9580a.Quantity'’\r
+      of newtype ‘Dimensional Int v’ is not in scope\r
+    In the expression: coerce x\r
+    In an equation for ‘foo’: foo x = coerce x\r
index 2ff1608..520460d 100644 (file)
@@ -1,70 +1,57 @@
-
-==================== Tidy Core ====================
-Result size of Tidy Core = {terms: 22, types: 14, coercions: 0}
-
-dl :: Double -> Double
-[GblId,
- Arity=1,
- Caf=NoCafRefs,
- Str=DmdType <S,1*U(U)>m,
- Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
-         WorkFree=True, Expandable=True,
-         Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
-         Tmpl= \ (x [Occ=Once!] :: Double) ->
-                 case x of _ [Occ=Dead] { GHC.Types.D# y ->
-                 GHC.Types.D# (GHC.Prim.+## y y)
-                 }}]
-dl =
-  \ (x :: Double) ->
-    case x of _ [Occ=Dead] { GHC.Types.D# y ->
-    GHC.Types.D# (GHC.Prim.+## y y)
-    }
-
-dr :: Double -> Double
-[GblId,
- Arity=1,
- Caf=NoCafRefs,
- Str=DmdType <S,1*U(U)>m,
- Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
-         WorkFree=True, Expandable=True,
-         Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
-         Tmpl= \ (x [Occ=Once!] :: Double) ->
-                 case x of _ [Occ=Dead] { GHC.Types.D# x1 ->
-                 GHC.Types.D# (GHC.Prim.+## x1 x1)
-                 }}]
-dr = dl
-
-fl :: Float -> Float
-[GblId,
- Arity=1,
- Caf=NoCafRefs,
- Str=DmdType <S,1*U(U)>m,
- Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
-         WorkFree=True, Expandable=True,
-         Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
-         Tmpl= \ (x [Occ=Once!] :: Float) ->
-                 case x of _ [Occ=Dead] { GHC.Types.F# y ->
-                 GHC.Types.F# (GHC.Prim.plusFloat# y y)
-                 }}]
-fl =
-  \ (x :: Float) ->
-    case x of _ [Occ=Dead] { GHC.Types.F# y ->
-    GHC.Types.F# (GHC.Prim.plusFloat# y y)
-    }
-
-fr :: Float -> Float
-[GblId,
- Arity=1,
- Caf=NoCafRefs,
- Str=DmdType <S,1*U(U)>m,
- Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
-         WorkFree=True, Expandable=True,
-         Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
-         Tmpl= \ (x [Occ=Once!] :: Float) ->
-                 case x of _ [Occ=Dead] { GHC.Types.F# x1 ->
-                 GHC.Types.F# (GHC.Prim.plusFloat# x1 x1)
-                 }}]
-fr = fl
-
-
-
+\r
+==================== Tidy Core ====================\r
+Result size of Tidy Core = {terms: 22, types: 14, coercions: 0}\r
+\r
+dl :: Double -> Double\r
+[GblId,\r
+ Arity=1,\r
+ Caf=NoCafRefs,\r
+ Str=DmdType <S,1*U(U)>m,\r
+ Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,\r
+         WorkFree=True, Expandable=True,\r
+         Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)\r
+         Tmpl= \ (x [Occ=Once!] :: Double) ->\r
+                 case x of _ [Occ=Dead] { D# y -> D# (+## y y) }}]\r
+dl =\r
+  \ (x :: Double) -> case x of _ [Occ=Dead] { D# y -> D# (+## y y) }\r
+\r
+dr :: Double -> Double\r
+[GblId,\r
+ Arity=1,\r
+ Caf=NoCafRefs,\r
+ Str=DmdType <S,1*U(U)>m,\r
+ Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,\r
+         WorkFree=True, Expandable=True,\r
+         Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)\r
+         Tmpl= \ (x [Occ=Once!] :: Double) ->\r
+                 case x of _ [Occ=Dead] { D# x1 -> D# (+## x1 x1) }}]\r
+dr = dl\r
+\r
+fl :: Float -> Float\r
+[GblId,\r
+ Arity=1,\r
+ Caf=NoCafRefs,\r
+ Str=DmdType <S,1*U(U)>m,\r
+ Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,\r
+         WorkFree=True, Expandable=True,\r
+         Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)\r
+         Tmpl= \ (x [Occ=Once!] :: Float) ->\r
+                 case x of _ [Occ=Dead] { F# y -> F# (plusFloat# y y) }}]\r
+fl =\r
+  \ (x :: Float) ->\r
+    case x of _ [Occ=Dead] { F# y -> F# (plusFloat# y y) }\r
+\r
+fr :: Float -> Float\r
+[GblId,\r
+ Arity=1,\r
+ Caf=NoCafRefs,\r
+ Str=DmdType <S,1*U(U)>m,\r
+ Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,\r
+         WorkFree=True, Expandable=True,\r
+         Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)\r
+         Tmpl= \ (x [Occ=Once!] :: Float) ->\r
+                 case x of _ [Occ=Dead] { F# x1 -> F# (plusFloat# x1 x1) }}]\r
+fr = fl\r
+\r
+\r
+\r
index 6516beb..52658fd 100644 (file)
@@ -1,37 +1,33 @@
-
-overloadedlistsfail01.hs:5:8:
-    No instance for (Show a0) arising from a use of ‘print’
-    The type variable ‘a0’ is ambiguous
-    Note: there are several potential instances:
-      instance [safe] Show Data.Version.Version
-        -- Defined in ‘Data.Version’
-      instance Show a => Show (Maybe a) -- Defined in ‘GHC.Show’
-      instance Show Ordering -- Defined in ‘GHC.Show’
-      ...plus 23 others
-    In the expression: print [1]
-    In an equation for ‘main’: main = print [1]
-
-overloadedlistsfail01.hs:5:14:
-    No instance for (GHC.Exts.IsList a0)
-      arising from an overloaded list
-    The type variable ‘a0’ is ambiguous
-    Note: there are several potential instances:
-      instance GHC.Exts.IsList Data.Version.Version
-        -- Defined in ‘GHC.Exts’
-      instance GHC.Exts.IsList [a] -- Defined in ‘GHC.Exts’
-    In the first argument of ‘print’, namely ‘[1]’
-    In the expression: print [1]
-    In an equation for ‘main’: main = print [1]
-
-overloadedlistsfail01.hs:5:15:
-    No instance for (Num (GHC.Exts.Item a0))
-      arising from the literal ‘1’
-    The type variable ‘a0’ is ambiguous
-    Note: there are several potential instances:
-      instance Num Integer -- Defined in ‘GHC.Num’
-      instance Num Double -- Defined in ‘GHC.Float’
-      instance Num Float -- Defined in ‘GHC.Float’
-      ...plus two others
-    In the expression: 1
-    In the first argument of ‘print’, namely ‘[1]’
-    In the expression: print [1]
+\r
+overloadedlistsfail01.hs:5:8:\r
+    No instance for (Show a0) arising from a use of ‘print’\r
+    The type variable ‘a0’ is ambiguous\r
+    Note: there are several potential instances:\r
+      instance [safe] Show Version -- Defined in ‘Data.Version’\r
+      instance Show a => Show (Maybe a) -- Defined in ‘GHC.Show’\r
+      instance Show Ordering -- Defined in ‘GHC.Show’\r
+      ...plus 23 others\r
+    In the expression: print [1]\r
+    In an equation for ‘main’: main = print [1]\r
+\r
+overloadedlistsfail01.hs:5:14:\r
+    No instance for (IsList a0) arising from an overloaded list\r
+    The type variable ‘a0’ is ambiguous\r
+    Note: there are several potential instances:\r
+      instance IsList Version -- Defined in ‘GHC.Exts’\r
+      instance IsList [a] -- Defined in ‘GHC.Exts’\r
+    In the first argument of ‘print’, namely ‘[1]’\r
+    In the expression: print [1]\r
+    In an equation for ‘main’: main = print [1]\r
+\r
+overloadedlistsfail01.hs:5:15:\r
+    No instance for (Num (Item a0)) arising from the literal ‘1’\r
+    The type variable ‘a0’ is ambiguous\r
+    Note: there are several potential instances:\r
+      instance Num Integer -- Defined in ‘GHC.Num’\r
+      instance Num Double -- Defined in ‘GHC.Float’\r
+      instance Num Float -- Defined in ‘GHC.Float’\r
+      ...plus two others\r
+    In the expression: 1\r
+    In the first argument of ‘print’, namely ‘[1]’\r
+    In the expression: print [1]\r
index d5f52fd..4597e1c 100644 (file)
@@ -1,13 +1,11 @@
-
-overloadedlistsfail02.hs:6:8:
-    No instance for (GHC.Exts.IsList Foo)
-      arising from an overloaded list
-    In the expression: [7]
-    In an equation for ‘test’: test = [7]
-
-overloadedlistsfail02.hs:6:9:
-    No instance for (Num (GHC.Exts.Item Foo))
-      arising from the literal ‘7’
-    In the expression: 7
-    In the expression: [7]
-    In an equation for ‘test’: test = [7]
+\r
+overloadedlistsfail02.hs:6:8:\r
+    No instance for (IsList Foo) arising from an overloaded list\r
+    In the expression: [7]\r
+    In an equation for ‘test’: test = [7]\r
+\r
+overloadedlistsfail02.hs:6:9:\r
+    No instance for (Num (Item Foo)) arising from the literal ‘7’\r
+    In the expression: 7\r
+    In the expression: [7]\r
+    In an equation for ‘test’: test = [7]\r
index 18f8807..439b4c5 100644 (file)
@@ -27,10 +27,10 @@ TYPE SIGNATURES
   acos :: forall a. Floating a => a -> a
   acosh :: forall a. Floating a => a -> a
   all ::
-    forall a (t :: * -> *). P.Foldable t => (a -> Bool) -> t a -> Bool
-  and :: forall (t :: * -> *). P.Foldable t => t Bool -> Bool
+    forall a (t :: * -> *). Foldable t => (a -> Bool) -> t a -> Bool
+  and :: forall (t :: * -> *). Foldable t => t Bool -> Bool
   any ::
-    forall a (t :: * -> *). P.Foldable t => (a -> Bool) -> t a -> Bool
+    forall a (t :: * -> *). Foldable t => (a -> Bool) -> t a -> Bool
   appendFile :: FilePath -> String -> IO ()
   asTypeOf :: forall a. a -> a -> a
   asin :: forall a. Floating a => a -> a
@@ -41,9 +41,9 @@ TYPE SIGNATURES
   break :: forall a. (a -> Bool) -> [a] -> ([a], [a])
   ceiling :: forall a b. (Integral b, RealFrac a) => a -> b
   compare :: forall a. Ord a => a -> a -> Ordering
-  concat :: forall (t :: * -> *) a. P.Foldable t => t [a] -> [a]
+  concat :: forall (t :: * -> *) a. Foldable t => t [a] -> [a]
   concatMap ::
-    forall a b (t :: * -> *). P.Foldable t => (a -> [b]) -> t a -> [b]
+    forall a b (t :: * -> *). Foldable t => (a -> [b]) -> t a -> [b]
   const :: forall a b. a -> b -> a
   cos :: forall a. Floating a => a -> a
   cosh :: forall a. Floating a => a -> a
@@ -56,7 +56,7 @@ TYPE SIGNATURES
   dropWhile :: forall a. (a -> Bool) -> [a] -> [a]
   either :: forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
   elem ::
-    forall (t :: * -> *) a. (Eq a, P.Foldable t) => a -> t a -> Bool
+    forall (t :: * -> *) a. (Eq a, Foldable t) => a -> t a -> Bool
   encodeFloat :: forall a. RealFloat a => Integer -> Int -> a
   enumFrom :: forall a. Enum a => a -> [a]
   enumFromThen :: forall a. Enum a => a -> a -> [a]
@@ -77,16 +77,16 @@ TYPE SIGNATURES
     forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
   foldl ::
     forall (t :: * -> *) b a.
-    P.Foldable t =>
+    Foldable t =>
     (b -> a -> b) -> b -> t a -> b
   foldl1 ::
-    forall (t :: * -> *) a. P.Foldable t => (a -> a -> a) -> t a -> a
+    forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
   foldr ::
     forall (t :: * -> *) a b.
-    P.Foldable t =>
+    Foldable t =>
     (a -> b -> b) -> b -> t a -> b
   foldr1 ::
-    forall (t :: * -> *) a. P.Foldable t => (a -> a -> a) -> t a -> a
+    forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
   fromEnum :: forall a. Enum a => a -> Int
   fromInteger :: forall a. Num a => Integer -> a
   fromIntegral :: forall a b. (Integral a, Num b) => a -> b
@@ -109,7 +109,7 @@ TYPE SIGNATURES
   iterate :: forall a. (a -> a) -> a -> [a]
   last :: forall a. [a] -> a
   lcm :: forall a. Integral a => a -> a -> a
-  length :: forall (t :: * -> *) a. P.Foldable t => t a -> Int
+  length :: forall (t :: * -> *) a. Foldable t => t a -> Int
   lex :: ReadS String
   lines :: String -> [String]
   log :: forall a. Floating a => a -> a
@@ -118,35 +118,32 @@ TYPE SIGNATURES
   map :: forall a b. (a -> b) -> [a] -> [b]
   mapM ::
     forall (t :: * -> *) a (m :: * -> *) b.
-    (Monad m, P.Traversable t) =>
+    (Monad m, Traversable t) =>
     (a -> m b) -> t a -> m (t b)
   mapM_ ::
     forall a (m :: * -> *) b (t :: * -> *).
-    (Monad m, P.Foldable t) =>
+    (Monad m, Foldable t) =>
     (a -> m b) -> t a -> m ()
   max :: forall a. Ord a => a -> a -> a
   maxBound :: forall w_. Bounded w_ => w_
-  maximum ::
-    forall (t :: * -> *) a. (Ord a, P.Foldable t) => t a -> a
+  maximum :: forall (t :: * -> *) a. (Ord a, Foldable t) => t a -> a
   maybe :: forall b a. b -> (a -> b) -> Maybe a -> b
   min :: forall a. Ord a => a -> a -> a
   minBound :: forall w_. Bounded w_ => w_
-  minimum ::
-    forall (t :: * -> *) a. (Ord a, P.Foldable t) => t a -> a
+  minimum :: forall (t :: * -> *) a. (Ord a, Foldable t) => t a -> a
   mod :: forall a. Integral a => a -> a -> a
   negate :: forall a. Num a => a -> a
   not :: Bool -> Bool
   notElem ::
-    forall a (t :: * -> *). (Eq a, P.Foldable t) => a -> t a -> Bool
-  null :: forall (t :: * -> *) a. P.Foldable t => t a -> Bool
+    forall a (t :: * -> *). (Eq a, Foldable t) => a -> t a -> Bool
+  null :: forall (t :: * -> *) a. Foldable t => t a -> Bool
   odd :: forall a. Integral a => a -> Bool
-  or :: forall (t :: * -> *). P.Foldable t => t Bool -> Bool
+  or :: forall (t :: * -> *). Foldable t => t Bool -> Bool
   otherwise :: Bool
   pi :: forall w_. Floating w_ => w_
   pred :: forall a. Enum a => a -> a
   print :: forall a. Show a => a -> IO ()
-  product ::
-    forall (t :: * -> *) a. (Num a, P.Foldable t) => t a -> a
+  product :: forall (t :: * -> *) a. (Num a, Foldable t) => t a -> a
   properFraction ::
     forall a b. (Integral b, RealFrac a) => a -> (b, a)
   putChar :: Char -> IO ()
@@ -178,11 +175,11 @@ TYPE SIGNATURES
   seq :: forall a b. a -> b -> b
   sequence ::
     forall (t :: * -> *) (m :: * -> *) a.
-    (Monad m, P.Traversable t) =>
+    (Monad m, Traversable t) =>
     t (m a) -> m (t a)
   sequence_ ::
     forall (t :: * -> *) (m :: * -> *) a.
-    (Monad m, P.Foldable t) =>
+    (Monad m, Foldable t) =>
     t (m a) -> m ()
   show :: forall a. Show a => a -> String
   showChar :: Char -> ShowS
@@ -201,7 +198,7 @@ TYPE SIGNATURES
   sqrt :: forall a. Floating a => a -> a
   subtract :: forall a. Num a => a -> a -> a
   succ :: forall a. Enum a => a -> a
-  sum :: forall (t :: * -> *) a. (Num a, P.Foldable t) => t a -> a
+  sum :: forall (t :: * -> *) a. (Num a, Foldable t) => t a -> a
   tail :: forall a. [a] -> [a]
   take :: forall a. Int -> [a] -> [a]
   takeWhile :: forall a. (a -> Bool) -> [a] -> [a]
index 88cf8ab..10c8f56 100644 (file)
@@ -1,66 +1,66 @@
-\r
-rebindable6.hs:106:17:\r
-    No instance for (HasSeq (IO a -> t0 -> IO b))\r
-      (maybe you haven't applied a function to enough arguments?)\r
-      arising from a do statement\r
-    The type variable ‘t0’ is ambiguous\r
-    Relevant bindings include\r
-      g :: IO (Maybe b) (bound at rebindable6.hs:104:19)\r
-      f :: IO a (bound at rebindable6.hs:104:17)\r
-      test_do :: IO a -> IO (Maybe b) -> IO b\r
-        (bound at rebindable6.hs:104:9)\r
-    Note: there is a potential instance available:\r
-      instance HasSeq (IO a -> IO b -> IO b)\r
-        -- Defined at rebindable6.hs:52:18\r
-    In a stmt of a 'do' block: f\r
-    In the expression:\r
-      do { f;\r
-           Just (b :: b) <- g;\r
-           return b }\r
-    In an equation for ‘test_do’:\r
-        test_do f g\r
-          = do { f;\r
-                 Just (b :: b) <- g;\r
-                 return b }\r
-\r
-rebindable6.hs:107:17:\r
-    No instance for (HasFail ([Prelude.Char] -> t1))\r
-      (maybe you haven't applied a function to enough arguments?)\r
-      arising from a do statement\r
-    The type variable ‘t1’ is ambiguous\r
-    Note: there is a potential instance available:\r
-      instance HasFail (String -> IO a)\r
-        -- Defined at rebindable6.hs:57:18\r
-    In a stmt of a 'do' block: Just (b :: b) <- g\r
-    In the expression:\r
-      do { f;\r
-           Just (b :: b) <- g;\r
-           return b }\r
-    In an equation for ‘test_do’:\r
-        test_do f g\r
-          = do { f;\r
-                 Just (b :: b) <- g;\r
-                 return b }\r
-\r
-rebindable6.hs:108:17:\r
-    No instance for (HasReturn (b -> t1))\r
-      (maybe you haven't applied a function to enough arguments?)\r
-      arising from a use of ‘return’\r
-    The type variable ‘t1’ is ambiguous\r
-    Relevant bindings include\r
-      b :: b (bound at rebindable6.hs:107:23)\r
-      g :: IO (Maybe b) (bound at rebindable6.hs:104:19)\r
-      test_do :: IO a -> IO (Maybe b) -> IO b\r
-        (bound at rebindable6.hs:104:9)\r
-    Note: there is a potential instance available:\r
-      instance HasReturn (a -> IO a) -- Defined at rebindable6.hs:42:18\r
-    In a stmt of a 'do' block: return b\r
-    In the expression:\r
-      do { f;\r
-           Just (b :: b) <- g;\r
-           return b }\r
-    In an equation for ‘test_do’:\r
-        test_do f g\r
-          = do { f;\r
-                 Just (b :: b) <- g;\r
-                 return b }\r
+
+rebindable6.hs:106:17:
+    No instance for (HasSeq (IO a -> t0 -> IO b))
+      (maybe you haven't applied a function to enough arguments?)
+      arising from a do statement
+    The type variable ‘t0’ is ambiguous
+    Relevant bindings include
+      g :: IO (Maybe b) (bound at rebindable6.hs:104:19)
+      f :: IO a (bound at rebindable6.hs:104:17)
+      test_do :: IO a -> IO (Maybe b) -> IO b
+        (bound at rebindable6.hs:104:9)
+    Note: there is a potential instance available:
+      instance HasSeq (IO a -> IO b -> IO b)
+        -- Defined at rebindable6.hs:52:18
+    In a stmt of a 'do' block: f
+    In the expression:
+      do { f;
+           Just (b :: b) <- g;
+           return b }
+    In an equation for ‘test_do’:
+        test_do f g
+          = do { f;
+                 Just (b :: b) <- g;
+                 return b }
+
+rebindable6.hs:107:17:
+    No instance for (HasFail ([Char] -> t1))
+      (maybe you haven't applied a function to enough arguments?)
+      arising from a do statement
+    The type variable ‘t1’ is ambiguous
+    Note: there is a potential instance available:
+      instance HasFail (String -> IO a)
+        -- Defined at rebindable6.hs:57:18
+    In a stmt of a 'do' block: Just (b :: b) <- g
+    In the expression:
+      do { f;
+           Just (b :: b) <- g;
+           return b }
+    In an equation for ‘test_do’:
+        test_do f g
+          = do { f;
+                 Just (b :: b) <- g;
+                 return b }
+
+rebindable6.hs:108:17:
+    No instance for (HasReturn (b -> t1))
+      (maybe you haven't applied a function to enough arguments?)
+      arising from a use of ‘return’
+    The type variable ‘t1’ is ambiguous
+    Relevant bindings include
+      b :: b (bound at rebindable6.hs:107:23)
+      g :: IO (Maybe b) (bound at rebindable6.hs:104:19)
+      test_do :: IO a -> IO (Maybe b) -> IO b
+        (bound at rebindable6.hs:104:9)
+    Note: there is a potential instance available:
+      instance HasReturn (a -> IO a) -- Defined at rebindable6.hs:42:18
+    In a stmt of a 'do' block: return b
+    In the expression:
+      do { f;
+           Just (b :: b) <- g;
+           return b }
+    In an equation for ‘test_do’:
+        test_do f g
+          = do { f;
+                 Just (b :: b) <- g;
+                 return b }
index b7e3411..4406c43 100644 (file)
@@ -1,7 +1,7 @@
-T3319.hs:8:3-93: Splicing declarations\r
-    return\r
-      [ForeignD\r
-         (ImportF\r
-            CCall Unsafe "&" (mkName "foo") (AppT (ConT ''Ptr) (ConT ''())))]\r
-  ======>\r
-    foreign import ccall unsafe "static &foo" foo :: Ptr GHC.Tuple.()\r
+T3319.hs:8:3-93: Splicing declarations
+    return
+      [ForeignD
+         (ImportF
+            CCall Unsafe "&" (mkName "foo") (AppT (ConT ''Ptr) (ConT ''())))]
+  ======>
+    foreign import ccall unsafe "static &foo" foo :: Ptr ()
index 729a366..3564b8c 100644 (file)
@@ -3,4 +3,4 @@ T5700.hs:8:3-9: Splicing declarations
   ======>
     instance C D where
       {-# INLINE inlinable #-}
-      inlinable _ = GHC.Tuple.()
+      inlinable _ = ()
index 157d731..1386045 100644 (file)
@@ -1,8 +1,7 @@
 
 T7276.hs:6:8:
-    Couldn't match type ‘[Language.Haskell.TH.Syntax.Dec]’
-                   with ‘Language.Haskell.TH.Syntax.Exp’
-    Expected type: Language.Haskell.TH.Lib.ExpQ
-      Actual type: Language.Haskell.TH.Lib.DecsQ
+    Couldn't match type ‘[Dec]’ with ‘Exp’
+    Expected type: ExpQ
+      Actual type: DecsQ
     In the expression: [d| y = 3 |]
     In the untyped splice: $([d| y = 3 |])
index 9cbf34a..a11ec36 100644 (file)
@@ -8,5 +8,4 @@ TH_foreignInterruptible.hs:8:3-100: Splicing declarations
             (mkName "foo")
             (AppT (ConT ''Ptr) (ConT ''())))]
   ======>
-    foreign import ccall interruptible "static &foo" foo
-      :: Ptr GHC.Tuple.()
+    foreign import ccall interruptible "static &foo" foo :: Ptr ()
index e0f9336..0cf8854 100644 (file)
@@ -60,28 +60,23 @@ T5095.hs:9:11:
         -- Defined in ‘integer-gmp-1.0.0.0:GHC.Integer.Type’
       instance Eq Integer
         -- Defined in ‘integer-gmp-1.0.0.0:GHC.Integer.Type’
-      instance Eq Data.Monoid.All -- Defined in ‘Data.Monoid’
+      instance Eq All -- Defined in ‘Data.Monoid’
       instance forall (k :: BOX) (f :: k -> *) (a :: k).
                Eq (f a) =>
-               Eq (Data.Monoid.Alt f a)
+               Eq (Alt f a)
         -- Defined in ‘Data.Monoid’
-      instance Eq Data.Monoid.Any -- Defined in ‘Data.Monoid’
-      instance Eq a => Eq (Data.Monoid.Dual a)
-        -- Defined in ‘Data.Monoid’
-      instance Eq a => Eq (Data.Monoid.First a)
-        -- Defined in ‘Data.Monoid’
-      instance Eq a => Eq (Data.Monoid.Last a)
-        -- Defined in ‘Data.Monoid’
-      instance Eq a => Eq (Data.Monoid.Product a)
-        -- Defined in ‘Data.Monoid’
-      instance Eq a => Eq (Data.Monoid.Sum a) -- Defined in ‘Data.Monoid’
-      instance forall (k :: BOX) (s :: k). Eq (Data.Proxy.Proxy s)
+      instance Eq Any -- Defined in ‘Data.Monoid’
+      instance Eq a => Eq (Dual a) -- Defined in ‘Data.Monoid’
+      instance Eq a => Eq (First a) -- Defined in ‘Data.Monoid’
+      instance Eq a => Eq (Last a) -- Defined in ‘Data.Monoid’
+      instance Eq a => Eq (Product a) -- Defined in ‘Data.Monoid’
+      instance Eq a => Eq (Sum a) -- Defined in ‘Data.Monoid’
+      instance forall (k :: BOX) (s :: k). Eq (Proxy s)
         -- Defined in ‘Data.Proxy’
       instance (Eq a, Eq b) => Eq (Either a b)
         -- Defined in ‘Data.Either’
-      instance (GHC.Arr.Ix i, Eq e) => Eq (GHC.Arr.Array i e)
-        -- Defined in ‘GHC.Arr’
-      instance Eq (GHC.Arr.STArray s i e) -- Defined in ‘GHC.Arr’
+      instance (Ix i, Eq e) => Eq (Array i e) -- Defined in ‘GHC.Arr’
+      instance Eq (STArray s i e) -- Defined in ‘GHC.Arr’
     (The choice depends on the instantiation of ‘a’
      To pick the first instance above, use IncoherentInstances
      when compiling the other instance declarations)
index 9bc46e3..cfaf5ad 100644 (file)
@@ -3,7 +3,7 @@ T8262.hs:5:15:
     Couldn't match kind ‘*’ with ‘#’
     When matching types
       a :: *
-      GHC.Prim.Int# :: #
+      Int# :: #
     Relevant bindings include
       foo :: t -> Maybe a (bound at T8262.hs:5:1)
     In the first argument of ‘Just’, namely ‘(1#)’
index 3989ea4..85b988a 100644 (file)
@@ -1,13 +1,12 @@
 
 TcStaticPointersFail02.hs:9:6:
-    No instance for (Data.Typeable.Internal.Typeable b)
-      arising from a static form
+    No instance for (Typeable b) arising from a static form
     In the expression: static (undefined :: (forall a. a -> a) -> b)
     In an equation for ‘f1’:
         f1 = static (undefined :: (forall a. a -> a) -> b)
 
 TcStaticPointersFail02.hs:12:6:
-    No instance for (Data.Typeable.Internal.Typeable m)
+    No instance for (Typeable m)
       (maybe you haven't applied a function to enough arguments?)
       arising from a static form
     In the expression: static return
index a25e575..d7c8ed7 100644 (file)
@@ -1,96 +1,96 @@
-\r
-tcfail068.hs:14:9:\r
-    Couldn't match type ‘s1’ with ‘s’\r
-      ‘s1’ is a rigid type variable bound by\r
-           a type expected by the context: GHC.ST.ST s1 (IndTree s a)\r
-           at tcfail068.hs:13:9\r
-      ‘s’ is a rigid type variable bound by\r
-          the type signature for:\r
-          itgen :: Constructed a => (Int, Int) -> a -> IndTree s a\r
-          at tcfail068.hs:11:10\r
-    Expected type: GHC.ST.ST s1 (IndTree s a)\r
-      Actual type: GHC.ST.ST s1 (STArray s1 (Int, Int) a)\r
-    Relevant bindings include\r
-      itgen :: (Int, Int) -> a -> IndTree s a\r
-        (bound at tcfail068.hs:12:1)\r
-    In the first argument of ‘runST’, namely\r
-      ‘(newSTArray ((1, 1), n) x)’\r
-    In the expression: runST (newSTArray ((1, 1), n) x)\r
-\r
-tcfail068.hs:19:21:\r
-    Couldn't match type ‘s’ with ‘s1’\r
-      ‘s’ is a rigid type variable bound by\r
-          the type signature for:\r
-          itiap :: Constructed a =>\r
-                   (Int, Int) -> (a -> a) -> IndTree s a -> IndTree s a\r
-          at tcfail068.hs:16:10\r
-      ‘s1’ is a rigid type variable bound by\r
-           a type expected by the context: GHC.ST.ST s1 (IndTree s a)\r
-           at tcfail068.hs:18:9\r
-    Expected type: STArray s1 (Int, Int) a\r
-      Actual type: IndTree s a\r
-    Relevant bindings include\r
-      arr :: IndTree s a (bound at tcfail068.hs:17:11)\r
-      itiap :: (Int, Int) -> (a -> a) -> IndTree s a -> IndTree s a\r
-        (bound at tcfail068.hs:17:1)\r
-    In the first argument of ‘readSTArray’, namely ‘arr’\r
-    In the first argument of ‘(>>=)’, namely ‘readSTArray arr i’\r
-\r
-tcfail068.hs:24:36:\r
-    Couldn't match type ‘s’ with ‘s1’\r
-      ‘s’ is a rigid type variable bound by\r
-          the type signature for:\r
-          itrap :: Constructed a =>\r
-                   ((Int, Int), (Int, Int)) -> (a -> a) -> IndTree s a -> IndTree s a\r
-          at tcfail068.hs:23:10\r
-      ‘s1’ is a rigid type variable bound by\r
-           a type expected by the context: GHC.ST.ST s1 (IndTree s a)\r
-           at tcfail068.hs:24:29\r
-    Expected type: GHC.ST.ST s1 (IndTree s a)\r
-      Actual type: GHC.ST.ST s (IndTree s a)\r
-    Relevant bindings include\r
-      itrap' :: Int -> Int -> GHC.ST.ST s (IndTree s a)\r
-        (bound at tcfail068.hs:26:9)\r
-      itrapsnd :: Int -> Int -> GHC.ST.ST s (IndTree s a)\r
-        (bound at tcfail068.hs:29:9)\r
-      arr :: IndTree s a (bound at tcfail068.hs:24:23)\r
-      itrap :: ((Int, Int), (Int, Int))\r
-               -> (a -> a) -> IndTree s a -> IndTree s a\r
-        (bound at tcfail068.hs:24:1)\r
-    In the first argument of ‘runST’, namely ‘(itrap' i k)’\r
-    In the expression: runST (itrap' i k)\r
-\r
-tcfail068.hs:36:46:\r
-    Couldn't match type ‘s’ with ‘s1’\r
-      ‘s’ is a rigid type variable bound by\r
-          the type signature for:\r
-          itrapstate :: Constructed b =>\r
-                        ((Int, Int), (Int, Int))\r
-                        -> (a -> b -> (a, b))\r
-                        -> ((Int, Int) -> c -> a)\r
-                        -> (a -> c)\r
-                        -> c\r
-                        -> IndTree s b\r
-                        -> (c, IndTree s b)\r
-          at tcfail068.hs:34:15\r
-      ‘s1’ is a rigid type variable bound by\r
-           a type expected by the context: GHC.ST.ST s1 (c, IndTree s b)\r
-           at tcfail068.hs:36:40\r
-    Expected type: GHC.ST.ST s1 (c, IndTree s b)\r
-      Actual type: GHC.ST.ST s (c, IndTree s b)\r
-    Relevant bindings include\r
-      itrapstate' :: Int -> Int -> c -> GHC.ST.ST s (c, IndTree s b)\r
-        (bound at tcfail068.hs:38:9)\r
-      itrapstatesnd :: Int -> Int -> c -> GHC.ST.ST s (c, IndTree s b)\r
-        (bound at tcfail068.hs:41:9)\r
-      arr :: IndTree s b (bound at tcfail068.hs:36:34)\r
-      itrapstate :: ((Int, Int), (Int, Int))\r
-                    -> (a -> b -> (a, b))\r
-                    -> ((Int, Int) -> c -> a)\r
-                    -> (a -> c)\r
-                    -> c\r
-                    -> IndTree s b\r
-                    -> (c, IndTree s b)\r
-        (bound at tcfail068.hs:36:1)\r
-    In the first argument of ‘runST’, namely ‘(itrapstate' i k s)’\r
-    In the expression: runST (itrapstate' i k s)\r
+
+tcfail068.hs:14:9:
+    Couldn't match type ‘s1’ with ‘s’
+      ‘s1’ is a rigid type variable bound by
+           a type expected by the context: ST s1 (IndTree s a)
+           at tcfail068.hs:13:9
+      ‘s’ is a rigid type variable bound by
+          the type signature for:
+          itgen :: Constructed a => (Int, Int) -> a -> IndTree s a
+          at tcfail068.hs:11:10
+    Expected type: ST s1 (IndTree s a)
+      Actual type: ST s1 (STArray s1 (Int, Int) a)
+    Relevant bindings include
+      itgen :: (Int, Int) -> a -> IndTree s a
+        (bound at tcfail068.hs:12:1)
+    In the first argument of ‘runST’, namely
+      ‘(newSTArray ((1, 1), n) x)’
+    In the expression: runST (newSTArray ((1, 1), n) x)
+
+tcfail068.hs:19:21:
+    Couldn't match type ‘s’ with ‘s1’
+      ‘s’ is a rigid type variable bound by
+          the type signature for:
+          itiap :: Constructed a =>
+                   (Int, Int) -> (a -> a) -> IndTree s a -> IndTree s a
+          at tcfail068.hs:16:10
+      ‘s1’ is a rigid type variable bound by
+           a type expected by the context: ST s1 (IndTree s a)
+           at tcfail068.hs:18:9
+    Expected type: STArray s1 (Int, Int) a
+      Actual type: IndTree s a
+    Relevant bindings include
+      arr :: IndTree s a (bound at tcfail068.hs:17:11)
+      itiap :: (Int, Int) -> (a -> a) -> IndTree s a -> IndTree s a
+        (bound at tcfail068.hs:17:1)
+    In the first argument of ‘readSTArray’, namely ‘arr’
+    In the first argument of ‘(>>=)’, namely ‘readSTArray arr i’
+
+tcfail068.hs:24:36:
+    Couldn't match type ‘s’ with ‘s1’
+      ‘s’ is a rigid type variable bound by
+          the type signature for:
+          itrap :: Constructed a =>
+                   ((Int, Int), (Int, Int)) -> (a -> a) -> IndTree s a -> IndTree s a
+          at tcfail068.hs:23:10
+      ‘s1’ is a rigid type variable bound by
+           a type expected by the context: ST s1 (IndTree s a)
+           at tcfail068.hs:24:29
+    Expected type: ST s1 (IndTree s a)
+      Actual type: ST s (IndTree s a)
+    Relevant bindings include
+      itrap' :: Int -> Int -> ST s (IndTree s a)
+        (bound at tcfail068.hs:26:9)
+      itrapsnd :: Int -> Int -> ST s (IndTree s a)
+        (bound at tcfail068.hs:29:9)
+      arr :: IndTree s a (bound at tcfail068.hs:24:23)
+      itrap :: ((Int, Int), (Int, Int))
+               -> (a -> a) -> IndTree s a -> IndTree s a
+        (bound at tcfail068.hs:24:1)
+    In the first argument of ‘runST’, namely ‘(itrap' i k)’
+    In the expression: runST (itrap' i k)
+
+tcfail068.hs:36:46:
+    Couldn't match type ‘s’ with ‘s1’
+      ‘s’ is a rigid type variable bound by
+          the type signature for:
+          itrapstate :: Constructed b =>
+                        ((Int, Int), (Int, Int))
+                        -> (a -> b -> (a, b))
+                        -> ((Int, Int) -> c -> a)
+                        -> (a -> c)
+                        -> c
+                        -> IndTree s b
+                        -> (c, IndTree s b)
+          at tcfail068.hs:34:15
+      ‘s1’ is a rigid type variable bound by
+           a type expected by the context: ST s1 (c, IndTree s b)
+           at tcfail068.hs:36:40
+    Expected type: ST s1 (c, IndTree s b)
+      Actual type: ST s (c, IndTree s b)
+    Relevant bindings include
+      itrapstate' :: Int -> Int -> c -> ST s (c, IndTree s b)
+        (bound at tcfail068.hs:38:9)
+      itrapstatesnd :: Int -> Int -> c -> ST s (c, IndTree s b)
+        (bound at tcfail068.hs:41:9)
+      arr :: IndTree s b (bound at tcfail068.hs:36:34)
+      itrapstate :: ((Int, Int), (Int, Int))
+                    -> (a -> b -> (a, b))
+                    -> ((Int, Int) -> c -> a)
+                    -> (a -> c)
+                    -> c
+                    -> IndTree s b
+                    -> (c, IndTree s b)
+        (bound at tcfail068.hs:36:1)
+    In the first argument of ‘runST’, namely ‘(itrapstate' i k s)’
+    In the expression: runST (itrapstate' i k s)
index 1bc0246..9f5cc09 100644 (file)
@@ -3,7 +3,7 @@ tcfail123.hs:11:9:
     Couldn't match kind ‘*’ with ‘#’
     When matching types
       t0 :: *
-      GHC.Prim.Int# :: #
+      Int# :: #
     In the first argument of ‘f’, namely ‘3#’
     In the expression: f 3#
     In an equation for ‘h’: h v = f 3#
index b33dffb..6d59560 100644 (file)
@@ -4,7 +4,7 @@ tcfail128.hs:18:16:
       arising from a use of ‘thaw’
     The type variable ‘b0’ is ambiguous
     Note: there is a potential instance available:
-      instance Data.Array.Base.MArray GHC.IOArray.IOArray e IO
+      instance Data.Array.Base.MArray IOArray e IO
         -- Defined in ‘Data.Array.Base’
     In a stmt of a 'do' block: v <- thaw tmp
     In the expression:
index ba9f0ce..473ff9e 100644 (file)
@@ -3,7 +3,7 @@ tcfail200.hs:5:15:
     Couldn't match kind ‘*’ with ‘#’
     When matching types
       t1 :: *
-      GHC.Prim.Int# :: #
+      Int# :: #
     Relevant bindings include
       x :: (t1, Char) (bound at tcfail200.hs:5:9)
     In the expression: 1#
index e565cc7..dcb6fbc 100644 (file)
@@ -3,13 +3,13 @@
 tcfail220.hsig:4:1:
     Type constructor ‘Bool’ has conflicting definitions in the module
     and its hsig file
-    Main module: data Bool = False | GHC.Types.True
+    Main module: data Bool = False | True
     Hsig file:  data Bool a b c d = False
     The types have different kinds
 
 tcfail220.hsig:5:1:
     Type constructor ‘Maybe’ has conflicting definitions in the module
     and its hsig file
-    Main module: data Maybe a = Nothing | GHC.Base.Just a
+    Main module: data Maybe a = Nothing | Just a
     Hsig file:  data Maybe a b = Nothing
     The types have different kinds