ghc/tests/reader/should_fail/read001.stderr

   1 ==================== Reader ====================
   2 module OneOfEverything (
   3         fixn, FooData, FooDataB(..), FooDataC(..), EqTree(EqLeaf,
   4                                                           EqBranch), EqClass(..), OrdClass(orda,
   5                                                                                            ordb), module OneC, module OneOfEverything
   6     ) where
   7 import qualified OneA
   8 import OneB (fB)
   9 import OneC hiding (fC)
  10 import OneC hiding (fC)
  11 infix 6 fixn
  12 infixl 7 +#
  13 infixr 8 fixr
  14 {- rec -}
  15 bindwith :: _forall_ [] (OrdClass a, OrdClass b) => a -> b -> b
  16 g :: _forall_ [] (Num a, Eq b) => Foo a -> [b] -> (a, a, a) -> b
  17 fixn x y = x
  18 fixl x y = x
  19 fixr x y = x
  20 singlebind x = x
  21 bindwith a b = b
  22 reca a = recb a
  23 recb a = reca a
  24 (~(a, b, c))
  25     | nullity b = a
  26     | nullity c = a
  27     | otherwise = a
  28     where
  29         {- rec -}
  30         nullity = null
  31 mat a b c d
  32     | foof a b = d
  33     | foof a c = d
  34     | foof b c = d
  35     where
  36         {- rec -}
  37         foof a b = a == b
  38 expr a b c d
  39      = ((((((((a + (: a b)) + (a : b))
  40              + (((1 - 'c') - "abc") - 1.2929999999999999))
  41             + ((\ x y z -> x) 42))
  42            + ((9 *)))
  43           + ((* 8)))
  44          + (case x of
  45               Prelude.[]
  46               | null x -> 99
  47               | otherwise -> 98
  48               | True -> 97
  49               where
  50                   {- rec -}
  51                   null x = False))
  52         + ([z | z <- c, isSpace z]))
  53        + (let
  54             {- rec -}
  55             y = foo
  56           in
  57             (((((((y + [1, 2, 3, 4]) + (4, 3, 2, 1))
  58                  + (4 :: _forall_ [] (Num a) => a))
  59                 + (if 42 == 42.000000000000000 then 1 else 4))
  60                + ([1 .. ]))
  61               + ([2, 4 .. ]))
  62              + ([3 .. 5]))
  63             + ([4, 8 .. 999]))
  64 f _
  65   x
  66   1
  67   1.9299999999999999
  68   'c'
  69   "dog"
  70   ~y
  71   (z@(Foo a b))
  72   (c Bar d)
  73   [1, 2]
  74   (3, 4)
  75   ((n+42))
  76   = y
  77 g x y z = head y
  78 default (Integer, Rational)
  79 instance _forall_ [] (Eq a) => EqClass (EqTree a) where
  80     []
  81     eqc x = 'a'
  82 class (Ord a) => OrdClass a where {
  83     orda :: a -> Char; ordb :: a -> Char; ordc :: a -> Char;
  84     }
  85 class (Eq a) => EqClass a where {
  86     eqc :: a -> Char;
  87     eqc x = '?'
  88     }
  89 data (Eq a) => EqTree a = EqLeaf a | EqBranch (EqLeaf a) (EqLeaf a)
  90 data FooDataB = FooConB Double
  91 data FooData = FooCon Int
  92 type Pair a b = (a, b)
  93
  94
  95 read001.hs:17: Could not find valid interface file `OneA'
  96
  97 read001.hs:18: Could not find valid interface file `OneB'
  98
  99 read001.hs:18: Module OneB does not export `fB'
 100
 101 read001.hs:19: Could not find valid interface file `OneC'
 102
 103 read001.hs:19: Module OneC does not export `fC'
 104
 105 read001.hs:20: Module OneC does not export `fC'
 106
 107 Compilation had errors