testsuite: Assert that testsuite ways are known
[ghc.git] / testsuite / tests / typecheck / should_compile / holes.stderr
1
2 holes.hs:3:5: warning: [-Wtyped-holes (in -Wdefault)]
3     • Found hole: _ :: t
4       Where: ‘t’ is a rigid type variable bound by
5                the inferred type of f :: t
6                at holes.hs:3:1-5
7     • In the expression: _
8       In an equation for ‘f’: f = _
9     • Relevant bindings include f :: t (bound at holes.hs:3:1)
10       Valid hole fits include f :: forall t. t
11
12 holes.hs:6:7: warning: [-Wtyped-holes (in -Wdefault)]
13     • Found hole: _ :: Char
14     • In the expression: _
15       In an equation for ‘g’: g x = _
16     • Relevant bindings include
17         x :: Int (bound at holes.hs:6:3)
18         g :: Int -> Char (bound at holes.hs:6:1)
19       Valid hole fits include
20         f :: forall t. t
21         maxBound :: forall a. Bounded a => a
22         minBound :: forall a. Bounded a => a
23
24 holes.hs:8:5: warning: [-Wtyped-holes (in -Wdefault)]
25     • Found hole: _ :: [Char]
26     • In the first argument of ‘(++)’, namely ‘_’
27       In the expression: _ ++ "a"
28       In an equation for ‘h’: h = _ ++ "a"
29     • Relevant bindings include h :: [Char] (bound at holes.hs:8:1)
30       Valid hole fits include
31         h :: [Char]
32         f :: forall t. t
33         [] :: forall a. [a]
34         mempty :: forall a. Monoid a => a
35
36 holes.hs:11:15: warning: [-Wtyped-holes (in -Wdefault)]
37     • Found hole: _ :: b0
38       Where: ‘b0’ is an ambiguous type variable
39     • In the second argument of ‘const’, namely ‘_’
40       In the expression: const y _
41       In an equation for ‘z’: z y = const y _
42     • Relevant bindings include
43         y :: [a] (bound at holes.hs:11:3)
44         z :: [a] -> [a] (bound at holes.hs:11:1)
45       Valid hole fits include
46         y :: [a]
47         z :: [a] -> [a]
48         g :: Int -> Char
49         h :: [Char]
50         f :: forall t. t
51         otherwise :: Bool
52         False :: Bool
53         True :: Bool
54         LT :: Ordering
55         EQ :: Ordering
56         GT :: Ordering
57         () :: ()
58         lines :: String -> [String]
59         unlines :: [String] -> String
60         unwords :: [String] -> String
61         words :: String -> [String]
62         userError :: String -> IOError
63         lex :: ReadS String
64         showChar :: Char -> ShowS
65         showParen :: Bool -> ShowS -> ShowS
66         showString :: String -> ShowS
67         appendFile :: FilePath -> String -> IO ()
68         getChar :: IO Char
69         getContents :: IO String
70         getLine :: IO String
71         interact :: (String -> String) -> IO ()
72         putChar :: Char -> IO ()
73         putStr :: String -> IO ()
74         putStrLn :: String -> IO ()
75         readFile :: FilePath -> IO String
76         writeFile :: FilePath -> String -> IO ()
77         (&&) :: Bool -> Bool -> Bool
78         not :: Bool -> Bool
79         (||) :: Bool -> Bool -> Bool
80         (++) :: forall a. [a] -> [a] -> [a]
81         filter :: forall a. (a -> Bool) -> [a] -> [a]
82         fromInteger :: forall a. Num a => Integer -> a
83         (-) :: forall a. Num a => a -> a -> a
84         fromRational :: forall a. Fractional a => Rational -> a
85         negate :: forall a. Num a => a -> a
86         fromIntegral :: forall a b. (Integral a, Num b) => a -> b
87         toInteger :: forall a. Integral a => a -> Integer
88         toRational :: forall a. Real a => a -> Rational
89         (:) :: forall a. a -> [a] -> [a]
90         Nothing :: forall a. Maybe a
91         Just :: forall a. a -> Maybe a
92         [] :: forall a. [a]
93         asTypeOf :: forall a. a -> a -> a
94         id :: forall a. a -> a
95         until :: forall a. (a -> Bool) -> (a -> a) -> a -> a
96         ioError :: forall a. IOError -> IO a
97         (!!) :: forall a. [a] -> Int -> a
98         break :: forall a. (a -> Bool) -> [a] -> ([a], [a])
99         cycle :: forall a. [a] -> [a]
100         drop :: forall a. Int -> [a] -> [a]
101         dropWhile :: forall a. (a -> Bool) -> [a] -> [a]
102         head :: forall a. [a] -> a
103         init :: forall a. [a] -> [a]
104         iterate :: forall a. (a -> a) -> a -> [a]
105         last :: forall a. [a] -> a
106         repeat :: forall a. a -> [a]
107         replicate :: forall a. Int -> a -> [a]
108         reverse :: forall a. [a] -> [a]
109         scanl1 :: forall a. (a -> a -> a) -> [a] -> [a]
110         scanr1 :: forall a. (a -> a -> a) -> [a] -> [a]
111         span :: forall a. (a -> Bool) -> [a] -> ([a], [a])
112         splitAt :: forall a. Int -> [a] -> ([a], [a])
113         tail :: forall a. [a] -> [a]
114         take :: forall a. Int -> [a] -> [a]
115         takeWhile :: forall a. (a -> Bool) -> [a] -> [a]
116         subtract :: forall a. Num a => a -> a -> a
117         readParen :: forall a. Bool -> ReadS a -> ReadS a
118         (^) :: forall a b. (Num a, Integral b) => a -> b -> a
119         even :: forall a. Integral a => a -> Bool
120         gcd :: forall a. Integral a => a -> a -> a
121         lcm :: forall a. Integral a => a -> a -> a
122         odd :: forall a. Integral a => a -> Bool
123         (**) :: forall a. Floating a => a -> a -> a
124         acos :: forall a. Floating a => a -> a
125         acosh :: forall a. Floating a => a -> a
126         asin :: forall a. Floating a => a -> a
127         asinh :: forall a. Floating a => a -> a
128         atan :: forall a. Floating a => a -> a
129         atanh :: forall a. Floating a => a -> a
130         cos :: forall a. Floating a => a -> a
131         cosh :: forall a. Floating a => a -> a
132         exp :: forall a. Floating a => a -> a
133         log :: forall a. Floating a => a -> a
134         logBase :: forall a. Floating a => a -> a -> a
135         pi :: forall a. Floating a => a
136         sin :: forall a. Floating a => a -> a
137         sinh :: forall a. Floating a => a -> a
138         sqrt :: forall a. Floating a => a -> a
139         tan :: forall a. Floating a => a -> a
140         tanh :: forall a. Floating a => a -> a
141         atan2 :: forall a. RealFloat a => a -> a -> a
142         decodeFloat :: forall a. RealFloat a => a -> (Integer, Int)
143         encodeFloat :: forall a. RealFloat a => Integer -> Int -> a
144         exponent :: forall a. RealFloat a => a -> Int
145         floatDigits :: forall a. RealFloat a => a -> Int
146         floatRadix :: forall a. RealFloat a => a -> Integer
147         floatRange :: forall a. RealFloat a => a -> (Int, Int)
148         isDenormalized :: forall a. RealFloat a => a -> Bool
149         isIEEE :: forall a. RealFloat a => a -> Bool
150         isInfinite :: forall a. RealFloat a => a -> Bool
151         isNaN :: forall a. RealFloat a => a -> Bool
152         isNegativeZero :: forall a. RealFloat a => a -> Bool
153         scaleFloat :: forall a. RealFloat a => Int -> a -> a
154         significand :: forall a. RealFloat a => a -> a
155         (*) :: forall a. Num a => a -> a -> a
156         (+) :: forall a. Num a => a -> a -> a
157         abs :: forall a. Num a => a -> a
158         signum :: forall a. Num a => a -> a
159         (/) :: forall a. Fractional a => a -> a -> a
160         recip :: forall a. Fractional a => a -> a
161         div :: forall a. Integral a => a -> a -> a
162         divMod :: forall a. Integral a => a -> a -> (a, a)
163         mod :: forall a. Integral a => a -> a -> a
164         quot :: forall a. Integral a => a -> a -> a
165         quotRem :: forall a. Integral a => a -> a -> (a, a)
166         rem :: forall a. Integral a => a -> a -> a
167         seq :: forall a b. a -> b -> b
168         zip :: forall a b. [a] -> [b] -> [(a, b)]
169         fst :: forall a b. (a, b) -> a
170         snd :: forall a b. (a, b) -> b
171         map :: forall a b. (a -> b) -> [a] -> [b]
172         realToFrac :: forall a b. (Real a, Fractional b) => a -> b
173         Left :: forall a b. a -> Either a b
174         Right :: forall a b. b -> Either a b
175         maybe :: forall b a. b -> (a -> b) -> Maybe a -> b
176         const :: forall a b. a -> b -> a
177         scanl :: forall b a. (b -> a -> b) -> b -> [a] -> [b]
178         scanr :: forall a b. (a -> b -> b) -> b -> [a] -> [b]
179         unzip :: forall a b. [(a, b)] -> ([a], [b])
180         (^^) :: forall a b. (Fractional a, Integral b) => a -> b -> a
181         ceiling :: forall a b. (RealFrac a, Integral b) => a -> b
182         floor :: forall a b. (RealFrac a, Integral b) => a -> b
183         properFraction :: forall a b.
184                           (RealFrac a, Integral b) =>
185                           a -> (b, a)
186         round :: forall a b. (RealFrac a, Integral b) => a -> b
187         truncate :: forall a b. (RealFrac a, Integral b) => a -> b
188         ($) :: forall a b. (a -> b) -> a -> b
189         either :: forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
190         curry :: forall a b c. ((a, b) -> c) -> a -> b -> c
191         uncurry :: forall a b c. (a -> b -> c) -> (a, b) -> c
192         ($!) :: forall a b. (a -> b) -> a -> b
193         (.) :: forall b c a. (b -> c) -> (a -> b) -> a -> c
194         flip :: forall a b c. (a -> b -> c) -> b -> a -> c
195         unzip3 :: forall a b c. [(a, b, c)] -> ([a], [b], [c])
196         zip3 :: forall a b c. [a] -> [b] -> [c] -> [(a, b, c)]
197         zipWith :: forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
198         zipWith3 :: forall a b c d.
199                     (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]