Built-in Natural literals in Core
[ghc.git] / testsuite / tests / typecheck / should_compile / valid_hole_fits.stderr
1 [1 of 2] Compiling ValidHoleFits    ( ValidHoleFits.hs, ValidHoleFits.o )
2 [2 of 2] Compiling Foo              ( valid_hole_fits.hs, valid_hole_fits.o )
3
4 valid_hole_fits.hs:9:6: warning: [-Wdeferred-out-of-scope-variables (in -Wdefault)]
5     • Variable not in scope: putStrLn :: String -> IO ()
6     • Perhaps you meant one of these:
7         ‘System.IO.putStrLn’ (imported from System.IO),
8         ‘System.IO.putStr’ (imported from System.IO)
9       Perhaps you want to remove ‘putStrLn’ from the explicit hiding list
10       in the import of ‘Prelude’ (valid_hole_fits.hs:3:1-40).
11
12 valid_hole_fits.hs:17:17: warning: [-Wtyped-holes (in -Wdefault)]
13     • Found hole: _ :: Int -> IO Int
14     • In the expression: _
15       In a stmt of a 'do' block: y <- _ x
16       In the expression:
17         do x <- a 0
18            y <- _ x
19            return y
20     • Relevant bindings include
21         x :: Int (bound at valid_hole_fits.hs:16:12)
22         c :: Int -> IO Int (bound at valid_hole_fits.hs:16:1)
23       Valid hole fits include
24         c :: Int -> IO Int (bound at valid_hole_fits.hs:16:1)
25         a :: Int -> IO Int (bound at valid_hole_fits.hs:12:1)
26         b :: Int -> IO Int (bound at valid_hole_fits.hs:14:1)
27         return :: forall (m :: * -> *) a. Monad m => a -> m a
28           with return @IO @Int
29           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
30            (and originally defined in ‘GHC.Base’))
31         pure :: forall (f :: * -> *) a. Applicative f => a -> f a
32           with pure @IO @Int
33           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
34            (and originally defined in ‘GHC.Base’))
35
36 valid_hole_fits.hs:21:8: warning: [-Wtyped-holes (in -Wdefault)]
37     • Found hole: _ :: [Maybe a] -> [a]
38       Where: ‘a’ is a rigid type variable bound by
39                the type signature for:
40                  test :: forall a. [Maybe a] -> [a]
41                at valid_hole_fits.hs:20:1-24
42     • In the expression: _
43       In an equation for ‘test’: test = _
44     • Relevant bindings include
45         test :: [Maybe a] -> [a] (bound at valid_hole_fits.hs:21:1)
46       Valid hole fits include
47         test :: [Maybe a] -> [a] (bound at valid_hole_fits.hs:21:1)
48         catMaybes :: forall a. [Maybe a] -> [a]
49           with catMaybes @a
50           (imported from ‘Data.Maybe’ at valid_hole_fits.hs:5:1-17)
51         mempty :: forall a. Monoid a => a
52           with mempty @([Maybe a] -> [a])
53           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
54            (and originally defined in ‘GHC.Base’))
55
56 valid_hole_fits.hs:24:9: warning: [-Wtyped-holes (in -Wdefault)]
57     • Found hole: _ :: Integer -> ValidHoleFits.Moo
58     • In the expression: _
59       In an equation for ‘test2’: test2 = _
60     • Relevant bindings include
61         test2 :: Integer -> ValidHoleFits.Moo
62           (bound at valid_hole_fits.hs:24:1)
63       Valid hole fits include
64         test2 :: Integer -> ValidHoleFits.Moo
65           (bound at valid_hole_fits.hs:24:1)
66         ValidHoleFits.Moo :: Integer -> ValidHoleFits.Moo
67           (imported qualified from ‘ValidHoleFits’ at valid_hole_fits.hs:6:1-30
68            (and originally defined at ValidHoleFits.hs:4:12-22))
69
70 valid_hole_fits.hs:27:5: warning: [-Wtyped-holes (in -Wdefault)]
71     • Found hole: _ :: Integer -> Maybe Integer
72     • In the expression: _
73       In the expression: _ 2
74       In an equation for ‘k’: k = _ 2
75     • Relevant bindings include
76         k :: Maybe Integer (bound at valid_hole_fits.hs:27:1)
77       Valid hole fits include
78         Just :: forall a. a -> Maybe a
79           with Just @Integer
80           (imported from ‘Data.Maybe’ at valid_hole_fits.hs:5:1-17
81            (and originally defined in ‘GHC.Maybe’))
82         return :: forall (m :: * -> *) a. Monad m => a -> m a
83           with return @Maybe @Integer
84           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
85            (and originally defined in ‘GHC.Base’))
86         pure :: forall (f :: * -> *) a. Applicative f => a -> f a
87           with pure @Maybe @Integer
88           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
89            (and originally defined in ‘GHC.Base’))
90
91 valid_hole_fits.hs:30:5: warning: [-Wdeferred-type-errors (in -Wdefault)]
92     • Ambiguous type variable ‘a1’ arising from a use of ‘show’
93       prevents the constraint ‘(Show a1)’ from being solved.
94       Probable fix: use a type annotation to specify what ‘a1’ should be.
95       These potential instances exist:
96         instance (Show a, Show b) => Show (Either a b)
97           -- Defined in ‘Data.Either’
98         instance Show Ordering -- Defined in ‘GHC.Show’
99         instance Show Integer -- Defined in ‘GHC.Show’
100         ...plus 23 others
101         ...plus 69 instances involving out-of-scope types
102         (use -fprint-potential-instances to see them all)
103     • In the expression: show _
104       In an equation for ‘f’: f = show _
105
106 valid_hole_fits.hs:30:10: warning: [-Wtyped-holes (in -Wdefault)]
107     • Found hole: _ :: a1
108       Where: ‘a1’ is an ambiguous type variable
109     • In the first argument of ‘show’, namely ‘_’
110       In the expression: show _
111       In an equation for ‘f’: f = show _
112     • Relevant bindings include
113         f :: String (bound at valid_hole_fits.hs:30:1)
114       Valid hole fits include
115         f :: String (bound at valid_hole_fits.hs:30:1)
116         k :: Maybe Integer (defined at valid_hole_fits.hs:27:1)
117         h :: String (bound at valid_hole_fits.hs:34:1)
118         otherwise :: Bool
119           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
120            (and originally defined in ‘GHC.Base’))
121         False :: Bool
122           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
123            (and originally defined in ‘GHC.Types’))
124         True :: Bool
125           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
126            (and originally defined in ‘GHC.Types’))
127         EQ :: Ordering
128           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
129            (and originally defined in ‘GHC.Types’))
130         LT :: Ordering
131           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
132            (and originally defined in ‘GHC.Types’))
133         GT :: Ordering
134           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
135            (and originally defined in ‘GHC.Types’))
136         pi :: forall a. Floating a => a
137           with pi @Double
138           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
139            (and originally defined in ‘GHC.Float’))
140
141 valid_hole_fits.hs:34:5: warning: [-Wdeferred-type-errors (in -Wdefault)]
142     • Ambiguous type variable ‘a0’ arising from a use of ‘show’
143       prevents the constraint ‘(Show a0)’ from being solved.
144       Probable fix: use a type annotation to specify what ‘a0’ should be.
145       These potential instances exist:
146         instance (Show a, Show b) => Show (Either a b)
147           -- Defined in ‘Data.Either’
148         instance Show Ordering -- Defined in ‘GHC.Show’
149         instance Show Integer -- Defined in ‘GHC.Show’
150         ...plus 23 others
151         ...plus 69 instances involving out-of-scope types
152         (use -fprint-potential-instances to see them all)
153     • In the expression: show (_ (_ :: Bool))
154       In an equation for ‘h’: h = show (_ (_ :: Bool))
155
156 valid_hole_fits.hs:34:11: warning: [-Wtyped-holes (in -Wdefault)]
157     • Found hole: _ :: Bool -> a0
158       Where: ‘a0’ is an ambiguous type variable
159     • In the expression: _
160       In the first argument of ‘show’, namely ‘(_ (_ :: Bool))’
161       In the expression: show (_ (_ :: Bool))
162     • Relevant bindings include
163         h :: String (bound at valid_hole_fits.hs:34:1)
164       Valid hole fits include
165         not :: Bool -> Bool
166           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
167            (and originally defined in ‘GHC.Classes’))
168         enumFrom :: forall a. Enum a => a -> [a]
169           with enumFrom @Bool
170           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
171            (and originally defined in ‘GHC.Enum’))
172         Just :: forall a. a -> Maybe a
173           with Just @Bool
174           (imported from ‘Data.Maybe’ at valid_hole_fits.hs:5:1-17
175            (and originally defined in ‘GHC.Maybe’))
176         id :: forall a. a -> a
177           with id @Bool
178           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
179            (and originally defined in ‘GHC.Base’))
180         repeat :: forall a. a -> [a]
181           with repeat @Bool
182           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
183            (and originally defined in ‘GHC.List’))
184         fromEnum :: forall a. Enum a => a -> Int
185           with fromEnum @Bool
186           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
187            (and originally defined in ‘GHC.Enum’))
188         pred :: forall a. Enum a => a -> a
189           with pred @Bool
190           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
191            (and originally defined in ‘GHC.Enum’))
192         succ :: forall a. Enum a => a -> a
193           with succ @Bool
194           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
195            (and originally defined in ‘GHC.Enum’))
196         show :: forall a. Show a => a -> String
197           with show @Bool
198           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
199            (and originally defined in ‘GHC.Show’))
200
201 valid_hole_fits.hs:34:14: warning: [-Wtyped-holes (in -Wdefault)]
202     • Found hole: _ :: Bool
203     • In the first argument of ‘_’, namely ‘(_ :: Bool)’
204       In the first argument of ‘show’, namely ‘(_ (_ :: Bool))’
205       In the expression: show (_ (_ :: Bool))
206     • Relevant bindings include
207         h :: String (bound at valid_hole_fits.hs:34:1)
208       Valid hole fits include
209         otherwise :: Bool
210           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
211            (and originally defined in ‘GHC.Base’))
212         False :: Bool
213           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
214            (and originally defined in ‘GHC.Types’))
215         True :: Bool
216           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
217            (and originally defined in ‘GHC.Types’))
218         maxBound :: forall a. Bounded a => a
219           with maxBound @Bool
220           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
221            (and originally defined in ‘GHC.Enum’))
222         minBound :: forall a. Bounded a => a
223           with minBound @Bool
224           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
225            (and originally defined in ‘GHC.Enum’))
226
227 valid_hole_fits.hs:37:8: warning: [-Wtyped-holes (in -Wdefault)]
228     • Found hole: _ :: [Char] -> IO ()
229     • In the expression: _
230       In the expression: _ "hello, world"
231       In an equation for ‘main’: main = _ "hello, world"
232     • Relevant bindings include
233         main :: IO () (bound at valid_hole_fits.hs:37:1)
234       Valid hole fits include
235         ps :: String -> IO () (defined at valid_hole_fits.hs:9:1)
236         System.IO.putStr :: String -> IO ()
237           (imported qualified from ‘System.IO’ at valid_hole_fits.hs:4:29-34)
238         System.IO.putStrLn :: String -> IO ()
239           (imported qualified from ‘System.IO’ at valid_hole_fits.hs:4:37-44)
240         readIO :: forall a. Read a => String -> IO a
241           with readIO @()
242           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
243            (and originally defined in ‘System.IO’))
244         print :: forall a. Show a => a -> IO ()
245           with print @[Char]
246           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
247            (and originally defined in ‘System.IO’))
248         fail :: forall (m :: * -> *) a. Monad m => String -> m a
249           with fail @IO @()
250           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
251            (and originally defined in ‘GHC.Base’))
252         mempty :: forall a. Monoid a => a
253           with mempty @([Char] -> IO ())
254           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
255            (and originally defined in ‘GHC.Base’))