TcSimplify.hs 89 KB
Newer Older
1
2
{-# LANGUAGE CPP #-}

3
module TcSimplify(
4
5
       simplifyInfer, solveTopConstraints,
       growThetaTyVars,
Simon Peyton Jones's avatar
Simon Peyton Jones committed
6
       simplifyAmbiguityCheck,
7
       simplifyDefault,
8
9
       simplifyTop, simplifyInteractive, solveEqualities,
       simplifyWantedsTcM,
10
       tcCheckSatisfiability,
11

12
13
       -- For Rules we need these
       solveWanteds, runTcSDeriveds
14
  ) where
15

16
#include "HsVersions.h"
17

18
import Bag
19
import Class         ( Class, classKey, classTyCon )
20
import DynFlags      ( WarningFlag ( Opt_WarnMonomorphism )
21
                     , WarnReason ( Reason )
22
                     , DynFlags( solverIterations ) )
23
import Inst
24
import ListSetOps
25
import Maybes
26
27
import Name
import Outputable
28
29
import PrelInfo
import PrelNames
30
31
32
import TcErrors
import TcEvidence
import TcInteract
33
import TcCanonical   ( makeSuperClasses )
34
import TcMType   as TcM
35
import TcRnMonad as TcM
36
37
38
import TcSMonad  as TcS
import TcType
import TrieMap       () -- DV: for now
39
import Type
40
import TysWiredIn    ( ptrRepLiftedTy )
41
42
43
44
import Unify         ( tcMatchTy )
import Util
import Var
import VarSet
45
46
import BasicTypes    ( IntWithInf, intGtLimit )
import ErrUtils      ( emptyMessages )
47
import qualified GHC.LanguageExtensions as LangExt
48

49
import Control.Monad ( when, unless )
50
import Data.List     ( partition )
51
52
53
54

#if __GLASGOW_HASKELL__ < 709
import Data.Traversable ( traverse )
#endif
55

Austin Seipp's avatar
Austin Seipp committed
56
{-
57
*********************************************************************************
58
*                                                                               *
59
60
61
*                           External interface                                  *
*                                                                               *
*********************************************************************************
Austin Seipp's avatar
Austin Seipp committed
62
-}
63

64
65
simplifyTop :: WantedConstraints -> TcM (Bag EvBind)
-- Simplify top-level constraints
66
67
68
-- Usually these will be implications,
-- but when there is nothing to quantify we don't wrap
-- in a degenerate implication, so we do that here instead
69
simplifyTop wanteds
70
  = do { traceTc "simplifyTop {" $ text "wanted = " <+> ppr wanteds
71
       ; ((final_wc, unsafe_ol), binds1) <- runTcS $ simpl_top wanteds
72
73
74
       ; traceTc "End simplifyTop }" empty

       ; traceTc "reportUnsolved {" empty
75
       ; binds2 <- reportUnsolved final_wc
76
       ; traceTc "reportUnsolved }" empty
77

78
79
80
81
       ; traceTc "reportUnsolved (unsafe overlapping) {" empty
       ; unless (isEmptyCts unsafe_ol) $ do {
           -- grab current error messages and clear, warnAllUnsolved will
           -- update error messages which we'll grab and then restore saved
82
           -- messages.
83
           ; errs_var  <- getErrsVar
84
85
           ; saved_msg <- TcM.readTcRef errs_var
           ; TcM.writeTcRef errs_var emptyMessages
86
87
88
89
90

           ; warnAllUnsolved $ WC { wc_simple = unsafe_ol
                                  , wc_insol = emptyCts
                                  , wc_impl = emptyBag }

91
92
           ; whyUnsafe <- fst <$> TcM.readTcRef errs_var
           ; TcM.writeTcRef errs_var saved_msg
93
94
95
96
           ; recordUnsafeInfer whyUnsafe
           }
       ; traceTc "reportUnsolved (unsafe overlapping) }" empty

97
98
99
       ; return (evBindMapBinds binds1 `unionBags` binds2) }

-- | Type-check a thing that emits only equality constraints, then
100
-- solve those constraints. Fails outright if there is trouble.
101
102
solveEqualities :: TcM a -> TcM a
solveEqualities thing_inside
103
104
  = checkNoErrs $  -- See Note [Fail fast on kind errors]
    do { (result, wanted) <- captureConstraints thing_inside
105
106
107
108
109
110
111
112
       ; traceTc "solveEqualities {" $ text "wanted = " <+> ppr wanted
       ; (final_wc, _) <- runTcSEqualities $ simpl_top wanted
       ; traceTc "End solveEqualities }" empty

       ; traceTc "reportAllUnsolved {" empty
       ; reportAllUnsolved final_wc
       ; traceTc "reportAllUnsolved }" empty
       ; return result }
113

114
115
116
117
118
119
type SafeOverlapFailures = Cts
-- ^ See Note [Safe Haskell Overlapping Instances Implementation]

type FinalConstraints = (WantedConstraints, SafeOverlapFailures)

simpl_top :: WantedConstraints -> TcS FinalConstraints
120
    -- See Note [Top-level Defaulting Plan]
121
simpl_top wanteds
122
  = do { wc_first_go <- nestTcS (solveWantedsAndDrop wanteds)
123
                            -- This is where the main work happens
124
125
126
       ; wc_final <- try_tyvar_defaulting wc_first_go
       ; unsafe_ol <- getSafeOverlapFailures
       ; return (wc_final, unsafe_ol) }
127
  where
128
129
    try_tyvar_defaulting :: WantedConstraints -> TcS WantedConstraints
    try_tyvar_defaulting wc
130
      | isEmptyWC wc
131
132
      = return wc
      | otherwise
133
134
      = do { free_tvs <- TcS.zonkTyCoVarsAndFVList (tyCoVarsOfWCList wc)
           ; let meta_tvs = filter (isTyVar <&&> isMetaTyVar) free_tvs
135
                   -- zonkTyCoVarsAndFV: the wc_first_go is not yet zonked
136
                   -- filter isMetaTyVar: we might have runtime-skolems in GHCi,
137
                   -- and we definitely don't want to try to assign to those!
eir@cis.upenn.edu's avatar
eir@cis.upenn.edu committed
138
                   -- the isTyVar needs to weed out coercion variables
139

140
141
142
           ; defaulted <- mapM defaultTyVarTcS meta_tvs   -- Has unification side effects
           ; if or defaulted
             then do { wc_residual <- nestTcS (solveWanteds wc)
143
                            -- See Note [Must simplify after defaulting]
144
145
                     ; try_class_defaulting wc_residual }
             else try_class_defaulting wc }     -- No defaulting took place
146

147
148
    try_class_defaulting :: WantedConstraints -> TcS WantedConstraints
    try_class_defaulting wc
Austin Seipp's avatar
Austin Seipp committed
149
      | isEmptyWC wc
150
151
      = return wc
      | otherwise  -- See Note [When to do type-class defaulting]
152
      = do { something_happened <- applyDefaultingRules wc
153
                                   -- See Note [Top-level Defaulting Plan]
154
           ; if something_happened
155
             then do { wc_residual <- nestTcS (solveWantedsAndDrop wc)
156
                     ; try_class_defaulting wc_residual }
Simon Peyton Jones's avatar
Simon Peyton Jones committed
157
                  -- See Note [Overview of implicit CallStacks] in TcEvidence
158
159
160
161
162
163
164
165
166
167
168
             else try_callstack_defaulting wc }

    try_callstack_defaulting :: WantedConstraints -> TcS WantedConstraints
    try_callstack_defaulting wc
      | isEmptyWC wc
      = return wc
      | otherwise
      = defaultCallStacks wc

-- | Default any remaining @CallStack@ constraints to empty @CallStack@s.
defaultCallStacks :: WantedConstraints -> TcS WantedConstraints
Simon Peyton Jones's avatar
Simon Peyton Jones committed
169
-- See Note [Overview of implicit CallStacks] in TcEvidence
170
171
172
173
174
175
176
177
178
179
defaultCallStacks wanteds
  = do simples <- handle_simples (wc_simple wanteds)
       implics <- mapBagM handle_implic (wc_impl wanteds)
       return (wanteds { wc_simple = simples, wc_impl = implics })

  where

  handle_simples simples
    = catBagMaybes <$> mapBagM defaultCallStack simples

180
181
182
183
184
185
  handle_implic implic
    = do { wanteds <- setEvBindsTcS (ic_binds implic) $
                      -- defaultCallStack sets a binding, so
                      -- we must set the correct binding group
                      defaultCallStacks (ic_wanted implic)
         ; return (implic { ic_wanted = wanteds }) }
186

187
  defaultCallStack ct
Eric Seidel's avatar
Eric Seidel committed
188
    | Just _ <- isCallStackPred (ctPred ct)
189
    = do { solveCallStack (cc_ev ct) EvCsEmpty
190
191
192
193
194
         ; return Nothing }

  defaultCallStack ct
    = return (Just ct)

195

196
197
198
199
200
201
202
203
-- | Type-check a thing, returning the result and any EvBinds produced
-- during solving. Emits errors -- but does not fail -- if there is trouble.
solveTopConstraints :: TcM a -> TcM (a, Bag EvBind)
solveTopConstraints thing_inside
  = do { (result, wanted) <- captureConstraints thing_inside
       ; ev_binds <- simplifyTop wanted
       ; return (result, ev_binds) }

204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
{- Note [Fail fast on kind errors]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
solveEqualities is used to solve kind equalities when kind-checking
user-written types. If solving fails we should fail outright, rather
than just accumulate an error message, for two reasons:
  * A kind-bogus type signature may cause a cascade of knock-on
    errors if we let it pass

  * More seriously, if we don't solve a constraint we'll be left
    with a type that has a coercion hole in it, something like
           <type> |> co-hole
    where co-hole is not filled in.  Eeek!  That un-filled-in
    hole actually causes GHC to crash with "fvProv falls into a hole"
    See Trac #11563, #11520, #11516, #11399

So it's important to use 'checkNoErrs' here!

221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
Note [When to do type-class defaulting]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In GHC 7.6 and 7.8.2, we did type-class defaulting only if insolubleWC
was false, on the grounds that defaulting can't help solve insoluble
constraints.  But if we *don't* do defaulting we may report a whole
lot of errors that would be solved by defaulting; these errors are
quite spurious because fixing the single insoluble error means that
defaulting happens again, which makes all the other errors go away.
This is jolly confusing: Trac #9033.

So it seems better to always do type-class defaulting.

However, always doing defaulting does mean that we'll do it in
situations like this (Trac #5934):
   run :: (forall s. GenST s) -> Int
Austin Seipp's avatar
Austin Seipp committed
236
   run = fromInteger 0
237
238
239
We don't unify the return type of fromInteger with the given function
type, because the latter involves foralls.  So we're left with
    (Num alpha, alpha ~ (forall s. GenST s) -> Int)
Austin Seipp's avatar
Austin Seipp committed
240
241
Now we do defaulting, get alpha := Integer, and report that we can't
match Integer with (forall s. GenST s) -> Int.  That's not totally
242
243
244
245
246
247
stupid, but perhaps a little strange.

Another potential alternative would be to suppress *all* non-insoluble
errors if there are *any* insoluble errors, anywhere, but that seems
too drastic.

248
249
250
251
252
253
254
255
256
Note [Must simplify after defaulting]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
We may have a deeply buried constraint
    (t:*) ~ (a:Open)
which we couldn't solve because of the kind incompatibility, and 'a' is free.
Then when we default 'a' we can solve the constraint.  And we want to do
that before starting in on type classes.  We MUST do it before reporting
errors, because it isn't an error!  Trac #7967 was due to this.

257
258
Note [Top-level Defaulting Plan]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
259
260
We have considered two design choices for where/when to apply defaulting.
   (i) Do it in SimplCheck mode only /whenever/ you try to solve some
261
       simple constraints, maybe deep inside the context of implications.
262
       This used to be the case in GHC 7.4.1.
263
   (ii) Do it in a tight loop at simplifyTop, once all other constraints have
264
265
        finished. This is the current story.

266
Option (i) had many disadvantages:
267
268
   a) Firstly, it was deep inside the actual solver.
   b) Secondly, it was dependent on the context (Infer a type signature,
269
270
      or Check a type signature, or Interactive) since we did not want
      to always start defaulting when inferring (though there is an exception to
271
      this, see Note [Default while Inferring]).
272
273
274
275
276
277
278
279
280
281
282
   c) It plainly did not work. Consider typecheck/should_compile/DfltProb2.hs:
          f :: Int -> Bool
          f x = const True (\y -> let w :: a -> a
                                      w a = const a (y+1)
                                  in w y)
      We will get an implication constraint (for beta the type of y):
               [untch=beta] forall a. 0 => Num beta
      which we really cannot default /while solving/ the implication, since beta is
      untouchable.

Instead our new defaulting story is to pull defaulting out of the solver loop and
283
go with option (ii), implemented at SimplifyTop. Namely:
284
285
     - First, have a go at solving the residual constraint of the whole
       program
286
287
     - Try to approximate it with a simple constraint
     - Figure out derived defaulting equations for that simple constraint
288
289
290
291
     - Go round the loop again if you did manage to get some equations

Now, that has to do with class defaulting. However there exists type variable /kind/
defaulting. Again this is done at the top-level and the plan is:
292
     - At the top-level, once you had a go at solving the constraint, do
Gabor Greif's avatar
Gabor Greif committed
293
       figure out /all/ the touchable unification variables of the wanted constraints.
294
295
296
     - Apply defaulting to their kinds

More details in Note [DefaultTyVar].
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339

Note [Safe Haskell Overlapping Instances]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In Safe Haskell, we apply an extra restriction to overlapping instances. The
motive is to prevent untrusted code provided by a third-party, changing the
behavior of trusted code through type-classes. This is due to the global and
implicit nature of type-classes that can hide the source of the dictionary.

Another way to state this is: if a module M compiles without importing another
module N, changing M to import N shouldn't change the behavior of M.

Overlapping instances with type-classes can violate this principle. However,
overlapping instances aren't always unsafe. They are just unsafe when the most
selected dictionary comes from untrusted code (code compiled with -XSafe) and
overlaps instances provided by other modules.

In particular, in Safe Haskell at a call site with overlapping instances, we
apply the following rule to determine if it is a 'unsafe' overlap:

 1) Most specific instance, I1, defined in an `-XSafe` compiled module.
 2) I1 is an orphan instance or a MPTC.
 3) At least one overlapped instance, Ix, is both:
    A) from a different module than I1
    B) Ix is not marked `OVERLAPPABLE`

This is a slightly involved heuristic, but captures the situation of an
imported module N changing the behavior of existing code. For example, if
condition (2) isn't violated, then the module author M must depend either on a
type-class or type defined in N.

Secondly, when should these heuristics be enforced? We enforced them when the
type-class method call site is in a module marked `-XSafe` or `-XTrustworthy`.
This allows `-XUnsafe` modules to operate without restriction, and for Safe
Haskell inferrence to infer modules with unsafe overlaps as unsafe.

One alternative design would be to also consider if an instance was imported as
a `safe` import or not and only apply the restriction to instances imported
safely. However, since instances are global and can be imported through more
than one path, this alternative doesn't work.

Note [Safe Haskell Overlapping Instances Implementation]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

340
How is this implemented? It's complicated! So we'll step through it all:
341
342
343
344
345
346
347

 1) `InstEnv.lookupInstEnv` -- Performs instance resolution, so this is where
 we check if a particular type-class method call is safe or unsafe. We do this
 through the return type, `ClsInstLookupResult`, where the last parameter is a
 list of instances that are unsafe to overlap. When the method call is safe,
 the list is null.

348
349
350
351
 2) `TcInteract.matchClassInst` -- This module drives the instance resolution
 / dictionary generation. The return type is `LookupInstResult`, which either
 says no instance matched, or one found, and if it was a safe or unsafe
 overlap.
352
353
354
355
356

 3) `TcInteract.doTopReactDict` -- Takes a dictionary / class constraint and
 tries to resolve it by calling (in part) `matchClassInst`. The resolving
 mechanism has a work list (of constraints) that it process one at a time. If
 the constraint can't be resolved, it's added to an inert set. When compiling
357
 an `-XSafe` or `-XTrustworthy` module, we follow this approach as we know
358
359
360
 compilation should fail. These are handled as normal constraint resolution
 failures from here-on (see step 6).

361
 Otherwise, we may be inferring safety (or using `-Wunsafe`), and
362
363
364
365
366
367
368
369
370
 compilation should succeed, but print warnings and/or mark the compiled module
 as `-XUnsafe`. In this case, we call `insertSafeOverlapFailureTcS` which adds
 the unsafe (but resolved!) constraint to the `inert_safehask` field of
 `InertCans`.

 4) `TcSimplify.simpl_top` -- Top-level function for driving the simplifier for
 constraint resolution. Once finished, we call `getSafeOverlapFailures` to
 retrieve the list of overlapping instances that were successfully resolved,
 but unsafe. Remember, this is only applicable for generating warnings
371
 (`-Wunsafe`) or inferring a module unsafe. `-XSafe` and `-XTrustworthy`
372
373
374
375
376
377
378
379
380
 cause compilation failure by not resolving the unsafe constraint at all.
 `simpl_top` returns a list of unresolved constraints (all types), and resolved
 (but unsafe) resolved dictionary constraints.

 5) `TcSimplify.simplifyTop` -- Is the caller of `simpl_top`. For unresolved
 constraints, it calls `TcErrors.reportUnsolved`, while for unsafe overlapping
 instance constraints, it calls `TcErrors.warnAllUnsolved`. Both functions
 convert constraints into a warning message for the user.

381
 6) `TcErrors.*Unsolved` -- Generates error messages for constraints by
382
 actually calling `InstEnv.lookupInstEnv` again! Yes, confusing, but all we
383
384
385
386
 know is the constraint that is unresolved or unsafe. For dictionary, all we
 know is that we need a dictionary of type C, but not what instances are
 available and how they overlap. So we once again call `lookupInstEnv` to
 figure that out so we can generate a helpful error message.
387
388
389
390
391
392
393
394
395
396
397
398

 7) `TcSimplify.simplifyTop` -- In the case of `warnAllUnsolved` for resolved,
 but unsafe dictionary constraints, we collect the generated warning message
 (pop it) and call `TcRnMonad.recordUnsafeInfer` to mark the module we are
 compiling as unsafe, passing the warning message along as the reason.

 8) `TcRnMonad.recordUnsafeInfer` -- Save the unsafe result and reason in an
 IORef called `tcg_safeInfer`.

 9) `HscMain.tcRnModule'` -- Reads `tcg_safeInfer` after type-checking, calling
 `HscMain.markUnsafeInfer` (passing the reason along) when safe-inferrence
 failed.
399
400
401
402
403
404
405
406
407
408

Note [No defaulting in the ambiguity check]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
When simplifying constraints for the ambiguity check, we use
solveWantedsAndDrop, not simpl_top, so that we do no defaulting.
Trac #11947 was an example:
   f :: Num a => Int -> Int
This is ambiguous of course, but we don't want to default the
(Num alpha) constraint to (Num Int)!  Doing so gives a defaulting
warning, but no error.
Austin Seipp's avatar
Austin Seipp committed
409
-}
410

411
------------------
412
413
414
simplifyAmbiguityCheck :: Type -> WantedConstraints -> TcM ()
simplifyAmbiguityCheck ty wanteds
  = do { traceTc "simplifyAmbiguityCheck {" (text "type = " <+> ppr ty $$ text "wanted = " <+> ppr wanteds)
415
416
417
       ; (final_wc, _) <- runTcS $ solveWantedsAndDrop wanteds
             -- NB: no defaulting!  See Note [No defaulting in the ambiguity check]

418
419
420
421
422
       ; traceTc "End simplifyAmbiguityCheck }" empty

       -- Normally report all errors; but with -XAllowAmbiguousTypes
       -- report only insoluble ones, since they represent genuinely
       -- inaccessible code
423
       ; allow_ambiguous <- xoptM LangExt.AllowAmbiguousTypes
424
       ; traceTc "reportUnsolved(ambig) {" empty
425
       ; tc_lvl <- TcM.getTcLevel
426
       ; unless (allow_ambiguous && not (insolubleWC tc_lvl final_wc))
427
                (discardResult (reportUnsolved final_wc))
428
429
430
431
       ; traceTc "reportUnsolved(ambig) }" empty

       ; return () }

432
433
------------------
simplifyInteractive :: WantedConstraints -> TcM (Bag EvBind)
434
simplifyInteractive wanteds
435
  = traceTc "simplifyInteractive" empty >>
436
    simplifyTop wanteds
437
438

------------------
439
simplifyDefault :: ThetaType    -- Wanted; has no type variables in it
440
                -> TcM ()       -- Succeeds if the constraint is soluble
441
simplifyDefault theta
442
  = do { traceTc "simplifyDefault" empty
443
       ; wanted <- newWanteds DefaultOrigin theta
444
       ; unsolved <- simplifyWantedsTcM wanted
445
446
447

       ; traceTc "reportUnsolved {" empty
       -- See Note [Deferring coercion errors to runtime]
448
       ; reportAllUnsolved unsolved
449
450
       ; traceTc "reportUnsolved }" empty

451
       ; return () }
452

453
454
455
------------------
tcCheckSatisfiability :: Bag EvVar -> TcM Bool
-- Return True if satisfiable, False if definitely contradictory
456
tcCheckSatisfiability given_ids
457
  = do { lcl_env <- TcM.getLclEnv
458
459
       ; let given_loc = mkGivenLoc topTcLevel UnkSkol lcl_env
       ; (res, _ev_binds) <- runTcS $
460
             do { traceTcS "checkSatisfiability {" (ppr given_ids)
461
462
                ; let given_cts = mkGivens given_loc (bagToList given_ids)
                     -- See Note [Superclasses and satisfiability]
463
464
465
466
467
                ; insols <- solveSimpleGivens given_cts
                ; insols <- try_harder insols
                ; traceTcS "checkSatisfiability }" (ppr insols)
                ; return (isEmptyBag insols) }
       ; return res }
468
 where
469
470
471
    try_harder :: Cts -> TcS Cts
    -- Maybe we have to search up the superclass chain to find
    -- an unsatisfiable constraint.  Example: pmcheck/T3927b.
472
    -- At the moment we try just once
473
474
475
476
477
478
    try_harder insols
      | not (isEmptyBag insols)   -- We've found that it's definitely unsatisfiable
      = return insols             -- Hurrah -- stop now.
      | otherwise
      = do { pending_given <- getPendingScDicts
           ; new_given <- makeSuperClasses pending_given
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
           ; solveSimpleGivens new_given }

{- Note [Superclases and satisfiability]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Expand superclasses before starting, because (Int ~ Bool), has
(Int ~~ Bool) as a superclass, which in turn has (Int ~N# Bool)
as a superclass, and it's the latter that is insoluble.  See
Note [The equality types story] in TysPrim.

If we fail to prove unsatisfiability we (arbitrarily) try just once to
find superclasses, using try_harder.  Reason: we might have a type
signature
   f :: F op (Implements push) => ..
where F is a type function.  This happened in Trac #3972.

We could do more than once but we'd have to have /some/ limit: in the
the recurisve case, we would go on forever in the common case where
the constraints /are/ satisfiable (Trac #10592 comment:12!).

For stratightforard situations without type functions the try_harder
step does nothing.

501

502
***********************************************************************************
503
*                                                                                 *
504
505
506
*                            Inference
*                                                                                 *
***********************************************************************************
507

508
509
510
511
512
513
514
515
Note [Inferring the type of a let-bound variable]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider
   f x = rhs

To infer f's type we do the following:
 * Gather the constraints for the RHS with ambient level *one more than*
   the current one.  This is done by the call
516
        pushLevelAndCaptureConstraints (tcMonoBinds...)
517
518
519
520
   in TcBinds.tcPolyInfer

 * Call simplifyInfer to simplify the constraints and decide what to
   quantify over. We pass in the level used for the RHS constraints,
521
   here called rhs_tclvl.
522
523
524
525

This ensures that the implication constraint we generate, if any,
has a strictly-increased level compared to the ambient level outside
the let binding.
526

Austin Seipp's avatar
Austin Seipp committed
527
-}
528

529
simplifyInfer :: TcLevel               -- Used when generating the constraints
530
              -> Bool                  -- Apply monomorphism restriction
531
              -> [TcIdSigInfo]         -- Any signatures (possibly partial)
532
533
              -> [(Name, TcTauType)]   -- Variables to be generalised,
                                       -- and their tau-types
534
              -> WantedConstraints
535
              -> TcM ([TcTyVar],    -- Quantify over these type variables
536
                      [EvVar],      -- ... and these constraints (fully zonked)
537
                      TcEvBinds)    -- ... binding these evidence variables
538
simplifyInfer rhs_tclvl apply_mr sigs name_taus wanteds
539
  | isEmptyWC wanteds
540
  = do { gbl_tvs <- tcGetGlobalTyCoVars
541
542
       ; dep_vars <- zonkTcTypesAndSplitDepVars (map snd name_taus)
       ; qtkvs <- quantify_tvs sigs gbl_tvs dep_vars
543
       ; traceTc "simplifyInfer: empty WC" (ppr name_taus $$ ppr qtkvs)
544
       ; return (qtkvs, [], emptyTcEvBinds) }
545

546
  | otherwise
547
  = do { traceTc "simplifyInfer {"  $ vcat
548
549
550
551
552
             [ text "sigs =" <+> ppr sigs
             , text "binds =" <+> ppr name_taus
             , text "rhs_tclvl =" <+> ppr rhs_tclvl
             , text "apply_mr =" <+> ppr apply_mr
             , text "(unzonked) wanted =" <+> ppr wanteds
553
554
             ]

555
556
557
558
559
560
561
       -- First do full-blown solving
       -- NB: we must gather up all the bindings from doing
       -- this solving; hence (runTcSWithEvBinds ev_binds_var).
       -- And note that since there are nested implications,
       -- calling solveWanteds will side-effect their evidence
       -- bindings, so we can't just revert to the input
       -- constraint.
562

563
       ; ev_binds_var <- TcM.newTcEvBinds
564
       ; wanted_transformed_incl_derivs <- setTcLevel rhs_tclvl $
565
           do { sig_derived <- concatMapM mkSigDerivedWanteds sigs
566
567
                  -- the False says we don't really need to solve all Deriveds
              ; runTcSWithEvBinds False (Just ev_binds_var) $
568
                solveWanteds (wanteds `addSimples` listToBag sig_derived) }
569
       ; wanted_transformed_incl_derivs <- TcM.zonkWC wanted_transformed_incl_derivs
570

571
572
573
574
       -- Find quant_pred_candidates, the predicates that
       -- we'll consider quantifying over
       -- NB: We do not do any defaulting when inferring a type, this can lead
       -- to less polymorphic types, see Note [Default while Inferring]
575

576
       ; tc_lcl_env <- TcM.getLclEnv
577
       ; let wanted_transformed = dropDerivedWC wanted_transformed_incl_derivs
578
       ; quant_pred_candidates   -- Fully zonked
579
           <- if insolubleWC rhs_tclvl wanted_transformed_incl_derivs
580
              then return []   -- See Note [Quantification with errors]
581
                               -- NB: must include derived errors in this test,
582
583
                               --     hence "incl_derivs"

584
              else do { let quant_cand = approximateWC False wanted_transformed
niteria's avatar
niteria committed
585
586
                            meta_tvs   = filter isMetaTyVar $
                                         tyCoVarsOfCtsList quant_cand
587
588

                      ; gbl_tvs <- tcGetGlobalTyCoVars
589
590
                            -- Miminise quant_cand.  We are not interested in any evidence
                            -- produced, because we are going to simplify wanted_transformed
591
                            -- again later. All we want here are the predicates over which to
592
                            -- quantify.
593
                            --
594
595
                            -- If any meta-tyvar unifications take place (unlikely),
                            -- we'll pick that up later.
596

597
598
599
600
601
602
603
                      -- See Note [Promote _and_ default when inferring]
                      ; let def_tyvar tv
                              = when (not $ tv `elemVarSet` gbl_tvs) $
                                defaultTyVar tv
                      ; mapM_ def_tyvar meta_tvs
                      ; mapM_ (promoteTyVar rhs_tclvl) meta_tvs

604
                      ; WC { wc_simple = simples }
605
606
                           <- setTcLevel rhs_tclvl $
                              runTcSDeriveds       $
607
608
609
610
                              solveSimpleWanteds   $
                              mapBag toDerivedCt quant_cand
                                -- NB: we don't want evidence,
                                -- so use Derived constraints
611
612

                      ; simples <- TcM.zonkSimples simples
613

614
                      ; return [ ctEvPred ev | ct <- bagToList simples
615
                                             , let ev = ctEvidence ct ] }
616

617
       -- NB: quant_pred_candidates is already fully zonked
618

619
       -- Decide what type variables and constraints to quantify
620
       ; zonked_taus <- mapM (TcM.zonkTcType . snd) name_taus
621
       ; let zonked_tau_dvs = splitDepVarsOfTypes zonked_taus
622
623
       ; (qtvs, bound_theta)
           <- decideQuantification apply_mr sigs name_taus
624
                                   quant_pred_candidates zonked_tau_dvs
625
626
627
628
629
630
631
632
633
634
635
636
637

         -- Promote any type variables that are free in the inferred type
         -- of the function:
         --    f :: forall qtvs. bound_theta => zonked_tau
         -- These variables now become free in the envt, and hence will show
         -- up whenever 'f' is called.  They may currently at rhs_tclvl, but
         -- they had better be unifiable at the outer_tclvl!
         -- Example:   envt mentions alpha[1]
         --            tau_ty = beta[2] -> beta[2]
         --            consraints = alpha ~ [beta]
         -- we don't quantify over beta (since it is fixed by envt)
         -- so we must promote it!  The inferred type is just
         --   f :: beta -> beta
638
       ; zonked_tau_tkvs <- TcM.zonkTyCoVarsAndFV $
639
640
641
                            dVarSetToVarSet (dv_kvs zonked_tau_dvs)
                            `unionVarSet`
                            dVarSetToVarSet (dv_tvs zonked_tau_dvs)
642
643
644
              -- decideQuantification turned some meta tyvars into
              -- quantified skolems, so we have to zonk again

645
646
647
       ; let phi_tkvs = tyCoVarsOfTypes bound_theta  -- Already zonked
                        `unionVarSet` zonked_tau_tkvs
             promote_tkvs = closeOverKinds phi_tkvs `delVarSetList` qtvs
648

649
650
651
652
653
       ; MASSERT2( closeOverKinds promote_tkvs `subVarSet` promote_tkvs
                 , ppr phi_tkvs $$
                   ppr (closeOverKinds phi_tkvs) $$
                   ppr promote_tkvs $$
                   ppr (closeOverKinds promote_tkvs) )
654
655
656
           -- we really don't want a type to be promoted when its kind isn't!

           -- promoteTyVar ignores coercion variables
657
       ; outer_tclvl <- TcM.getTcLevel
658
       ; mapM_ (promoteTyVar outer_tclvl) (varSetElems promote_tkvs)
659
660
661
662
663
664

           -- Emit an implication constraint for the
           -- remaining constraints from the RHS
       ; bound_theta_vars <- mapM TcM.newEvVar bound_theta
       ; let skol_info   = InferSkol [ (name, mkSigmaTy [] bound_theta ty)
                                     | (name, ty) <- name_taus ]
665
                        -- Don't add the quantified variables here, because
666
667
                        -- they are also bound in ic_skols and we want them
                        -- to be tidied uniformly
668

669
             implic = Implic { ic_tclvl    = rhs_tclvl
670
                             , ic_skols    = qtvs
671
                             , ic_no_eqs   = False
672
                             , ic_given    = bound_theta_vars
673
                             , ic_wanted   = wanted_transformed
674
                             , ic_status   = IC_Unsolved
675
                             , ic_binds    = Just ev_binds_var
676
                             , ic_info     = skol_info
677
                             , ic_env      = tc_lcl_env }
678
       ; emitImplication implic
679

680
         -- All done!
681
       ; traceTc "} simplifyInfer/produced residual implication for quantification" $
682
683
         vcat [ text "quant_pred_candidates =" <+> ppr quant_pred_candidates
              , text "zonked_taus" <+> ppr zonked_taus
684
685
              , text "zonked_tau_dvs=" <+> ppr zonked_tau_dvs
              , text "promote_tvs=" <+> ppr promote_tkvs
686
687
688
              , text "bound_theta =" <+> ppr bound_theta
              , text "qtvs =" <+> ppr qtvs
              , text "implic =" <+> ppr implic ]
689

690
       ; return ( qtvs, bound_theta_vars, TcEvBinds ev_binds_var ) }
691

692
693
694
695
696
mkSigDerivedWanteds :: TcIdSigInfo -> TcM [Ct]
-- See Note [Add deriveds for signature contexts]
mkSigDerivedWanteds (TISI { sig_bndr = PartialSig { sig_name = name }
                          , sig_theta = theta, sig_tau = tau })
 = do { let skol_info = InferSkol [(name, mkSigmaTy [] theta tau)]
697
      ; loc <- getCtLocM (GivenOrigin skol_info) (Just TypeLevel)
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
      ; return [ mkNonCanonical (CtDerived { ctev_pred = pred
                                           , ctev_loc = loc })
               | pred <- theta ] }
mkSigDerivedWanteds _ = return []

{- Note [Add deriveds for signature contexts]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider this (Trac #11016):
  f2 :: (?x :: Int) => _
  f2 = ?x
We'll use plan InferGen because there are holes in the type.  But we want
to have the (?x :: Int) constraint floating around so that the functional
dependencies kick in.  Otherwise the occurrence of ?x on the RHS produces
constraint (?x :: alpha), and we wont unify alpha:=Int.

Solution: in simplifyInfer, just before simplifying the constraints
gathered from the RHS, add Derived constraints for the context of any
type signatures.  This is rare; if there is a type signature we'll usually
be doing CheckGen.  But it happens for signatures with holes.

Austin Seipp's avatar
Austin Seipp committed
718
719
************************************************************************
*                                                                      *
720
                Quantification
Austin Seipp's avatar
Austin Seipp committed
721
722
*                                                                      *
************************************************************************
723
724
725
726
727
728
729

Note [Deciding quantification]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If the monomorphism restriction does not apply, then we quantify as follows:
  * Take the global tyvars, and "grow" them using the equality constraints
    E.g.  if x:alpha is in the environment, and alpha ~ [beta] (which can
          happen because alpha is untouchable here) then do not quantify over
730
731
          beta, because alpha fixes beta, and beta is effectively free in
          the environment too
732
733
734
    These are the mono_tvs

  * Take the free vars of the tau-type (zonked_tau_tvs) and "grow" them
735
    using all the constraints.  These are tau_tvs_plus
736

737
738
739
740
  * Use quantifyTyVars to quantify over (tau_tvs_plus - mono_tvs), being
    careful to close over kinds, and to skolemise the quantified tyvars.
    (This actually unifies each quantifies meta-tyvar with a fresh skolem.)
    Result is qtvs.
Simon Peyton Jones's avatar
Simon Peyton Jones committed
741

742
  * Filter the constraints using pickQuantifiablePreds and the qtvs.
743
744
    We have to zonk the constraints first, so they "see" the freshly
    created skolems.
745

746
747
748
If the MR does apply, mono_tvs includes all the constrained tyvars --
including all covars -- and the quantified constraints are empty/insoluble.

Austin Seipp's avatar
Austin Seipp committed
749
-}
750

751
decideQuantification
752
753
754
755
  :: Bool                  -- try the MR restriction?
  -> [TcIdSigInfo]
  -> [(Name, TcTauType)]   -- variables to be generalised (for errors only)
  -> [PredType]            -- candidate theta
756
  -> TcDepVars
757
758
  -> TcM ( [TcTyVar]       -- Quantify over these (skolems)
         , [PredType] )    -- and this context (fully zonked)
759
-- See Note [Deciding quantification]
760
decideQuantification apply_mr sigs name_taus constraints
761
                     zonked_dvs@(DV { dv_kvs = zonked_tau_kvs, dv_tvs = zonked_tau_tvs })
762
  | apply_mr     -- Apply the Monomorphism restriction
763
  = do { gbl_tvs <- tcGetGlobalTyCoVars
764
765
       ; let zonked_tkvs = dVarSetToVarSet zonked_tau_kvs `unionVarSet`
                           dVarSetToVarSet zonked_tau_tvs
766
             constrained_tvs = tyCoVarsOfTypes constraints `unionVarSet`
767
                               filterVarSet isCoVar zonked_tkvs
768
             mono_tvs = gbl_tvs `unionVarSet` constrained_tvs
769
       ; qtvs <- quantify_tvs sigs mono_tvs zonked_dvs
770

771
           -- Warn about the monomorphism restriction
772
       ; warn_mono <- woptM Opt_WarnMonomorphism
773
       ; let mr_bites = constrained_tvs `intersectsVarSet` zonked_tkvs
774
       ; warnTc (Reason Opt_WarnMonomorphism) (warn_mono && mr_bites) $
775
         hang (text "The Monomorphism Restriction applies to the binding"
776
               <> plural bndrs <+> text "for" <+> pp_bndrs)
777
778
             2 (text "Consider giving a type signature for"
                <+> if isSingleton bndrs then pp_bndrs
779
                                         else text "these binders")
780

781
782
783
       -- All done
       ; traceTc "decideQuantification 1" (vcat [ppr constraints, ppr gbl_tvs, ppr mono_tvs
                                                , ppr qtvs, ppr mr_bites])
784
       ; return (qtvs, []) }
785
786

  | otherwise
787
  = do { gbl_tvs <- tcGetGlobalTyCoVars
788
       ; let mono_tvs     = growThetaTyVars equality_constraints gbl_tvs
789
             tau_tvs_plus = growThetaTyVarsDSet constraints zonked_tau_tvs
790
791
             dvs_plus     = DV { dv_kvs = zonked_tau_kvs, dv_tvs = tau_tvs_plus }
       ; qtvs <- quantify_tvs sigs mono_tvs dvs_plus
792
793
794
795
796
797
798
799
800
          -- We don't grow the kvs, as there's no real need to. Recall
          -- that quantifyTyVars uses the separation between kvs and tvs
          -- only for defaulting, and we don't want (ever) to default a tv
          -- to *. So, don't grow the kvs.

       ; constraints <- TcM.zonkTcTypes constraints
                 -- quantiyTyVars turned some meta tyvars into
                 -- quantified skolems, so we have to zonk again

Eric Seidel's avatar
Eric Seidel committed
801
802
       ; let theta     = pickQuantifiablePreds
                           (mkVarSet qtvs) (concatMap sig_theta sigs) constraints
803
804
805
806
807
808
809
810
811
812
813
             min_theta = mkMinimalBySCs theta
               -- See Note [Minimize by Superclasses]

       ; traceTc "decideQuantification 2"
           (vcat [ text "constraints:"  <+> ppr constraints
                 , text "gbl_tvs:"      <+> ppr gbl_tvs
                 , text "mono_tvs:"     <+> ppr mono_tvs
                 , text "zonked_kvs:"   <+> ppr zonked_tau_kvs
                 , text "tau_tvs_plus:" <+> ppr tau_tvs_plus
                 , text "qtvs:"         <+> ppr qtvs
                 , text "min_theta:"    <+> ppr min_theta ])
814
       ; return (qtvs, min_theta) }
815
  where
816
817
    bndrs    = map fst name_taus
    pp_bndrs = pprWithCommas (quotes . ppr) bndrs
818
819
    equality_constraints = filter isEqPred constraints

820
821
quantify_tvs :: [TcIdSigInfo]
             -> TcTyVarSet   -- the monomorphic tvs
822
             -> TcDepVars
823
824
             -> TcM [TcTyVar]
-- See Note [Which type variables to quantify]
825
quantify_tvs sigs mono_tvs dep_tvs@(DV { dv_tvs = tau_tvs })
826
827
   -- NB: don't use quantifyZonkedTyVars because the sig stuff might
   -- be unzonked
828
  = quantifyTyVars (mono_tvs `delVarSetList` sig_qtvs)
829
830
                   (dep_tvs { dv_tvs = tau_tvs `extendDVarSetList` sig_qtvs
                                               `extendDVarSetList` sig_wcs })
831
832
833
834
835
                   -- NB: quantifyTyVars zonks its arguments
  where
    sig_qtvs = [ skol | sig <- sigs, (_, skol) <- sig_skols sig ]
    sig_wcs  = [ wc   | TISI { sig_bndr = PartialSig { sig_wcs = wcs } } <- sigs
                      , (_, wc) <- wcs ]
836

837
838

------------------
839
growThetaTyVars :: ThetaType -> TyCoVarSet -> TyVarSet
840
-- See Note [Growing the tau-tvs using constraints]
841
-- NB: only returns tyvars, never covars
842
growThetaTyVars theta tvs
843
844
845
  | null theta = tvs_only
  | otherwise  = filterVarSet isTyVar $
                 transCloVarSet mk_next seed_tvs
846
  where
847
848
    tvs_only = filterVarSet isTyVar tvs
    seed_tvs = tvs `unionVarSet` tyCoVarsOfTypes ips
849
    (ips, non_ips) = partition isIPPred theta
850
                         -- See Note [Inheriting implicit parameters] in TcType
851
852
853
854
855
856

    mk_next :: VarSet -> VarSet -- Maps current set to newly-grown ones
    mk_next so_far = foldr (grow_one so_far) emptyVarSet non_ips
    grow_one so_far pred tvs
       | pred_tvs `intersectsVarSet` so_far = tvs `unionVarSet` pred_tvs
       | otherwise                          = tvs
857
       where
858
         pred_tvs = tyCoVarsOfType pred
859

860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
------------------
growThetaTyVarsDSet :: ThetaType -> DTyCoVarSet -> DTyVarSet
-- See Note [Growing the tau-tvs using constraints]
-- NB: only returns tyvars, never covars
-- It takes a deterministic set of TyCoVars and returns a deterministic set
-- of TyVars.
-- The implementation mirrors growThetaTyVars, the only difference is that
-- it avoids unionDVarSet and uses more efficient extendDVarSetList.
growThetaTyVarsDSet theta tvs
  | null theta = tvs_only
  | otherwise  = filterDVarSet isTyVar $
                 transCloDVarSet mk_next seed_tvs
  where
    tvs_only = filterDVarSet isTyVar tvs
    seed_tvs = tvs `extendDVarSetList` tyCoVarsOfTypesList ips
    (ips, non_ips) = partition isIPPred theta
                         -- See Note [Inheriting implicit parameters] in TcType

    mk_next :: DVarSet -> DVarSet -- Maps current set to newly-grown ones
    mk_next so_far = foldr (grow_one so_far) emptyDVarSet non_ips
    grow_one so_far pred tvs
       | any (`elemDVarSet` so_far) pred_tvs = tvs `extendDVarSetList` pred_tvs
       | otherwise                           = tvs
       where
         pred_tvs = tyCoVarsOfTypeList pred

886
887
888
889
890
891
{- Note [Which type variables to quantify]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
When choosing type variables to quantify, the basic plan is to
quantify over all type variables that are
 * free in the tau_tvs, and
 * not forced to be monomorphic (mono_tvs),
892
   for example by being free in the environment.
893

894
However, for a pattern binding, or with wildcards, we might
895
be doing inference *in the presence of a type signature*.
896
897
Mostly, if there is a signature we use CheckGen, not InferGen,
but with pattern bindings or wildcards we might do InferGen
898
899
900
and still have a type signature.  For example:
   f :: _ -> a
   f x = ...
901
902
or
   g :: (Eq _a) => _b -> _b
903
904
905
or
   p :: a -> a
   (p,q) = e
906
In all these cases we use plan InferGen, and hence call simplifyInfer.
907
908
909
910
911
But those 'a' variables are skolems, and we should be sure to quantify
over them, regardless of the monomorphism restriction etc.  If we
don't, when reporting a type error we panic when we find that a
skolem isn't bound by any enclosing implication.

912
913
914
915
916
917
918
919
920
921
Moreover we must quantify over all wildcards that are not free in
the environment.  In the case of 'g' for example, silly though it is,
we want to get the inferred type
   g :: forall t. Eq t => Int -> Int
and then report ambiguity, rather than *not* quantifying over 't'
and getting some much more mysterious error later.  A similar case
is
  h :: F _a -> Int

That's why we pass sigs to simplifyInfer, and make sure (in
922
923
924
quantify_tvs) that we do quantify over them.  Trac #10615 is
a case in point.

925
926
927
928
929
930
931
932
Note [Quantifying over equality constraints]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Should we quantify over an equality constraint (s ~ t)?  In general, we don't.
Doing so may simply postpone a type error from the function definition site to
its call site.  (At worst, imagine (Int ~ Bool)).

However, consider this
         forall a. (F [a] ~ Int) => blah
933
Should we quantify over the (F [a] ~ Int)?  Perhaps yes, because at the call
934
935
936
937
site we will know 'a', and perhaps we have instance  F [Bool] = Int.
So we *do* quantify over a type-family equality where the arguments mention
the quantified variables.

938
939
940
Note [Growing the tau-tvs using constraints]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
(growThetaTyVars insts tvs) is the result of extending the set
941
    of tyvars, tvs, using all conceivable links from pred
942
943
944
945
946
947
948
949

E.g. tvs = {a}, preds = {H [a] b, K (b,Int) c, Eq e}
Then growThetaTyVars preds tvs = {a,b,c}

Notice that
   growThetaTyVars is conservative       if v might be fixed by vs
                                         => v `elem` grow(vs,C)

950
951
952
953
954
955
956
957
Note [Quantification with errors]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If we find that the RHS of the definition has some absolutely-insoluble
constraints, we abandon all attempts to find a context to quantify
over, and instead make the function fully-polymorphic in whatever
type we have found.  For two reasons
  a) Minimise downstream errors
  b) Avoid spurious errors from this function
958

959
But NB that we must include *derived* errors in the check. Example:
960
961
962
    (a::*) ~ Int#
We get an insoluble derived error *~#, and we don't want to discard
it before doing the isInsolubleWC test!  (Trac #8262)
963

964
965
Note [Default while Inferring]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
966
Our current plan is that defaulting only happens at simplifyTop and
967
not simplifyInfer.  This may lead to some insoluble deferred constraints.
968
969
Example:

970
instance D g => C g Int b
971
972

constraint inferred = (forall b. 0 => C gamma alpha b) /\ Num alpha
973
type inferred       = gamma -> gamma
974

975
976
977
Now, if we try to default (alpha := Int) we will be able to refine the implication to
  (forall b. 0 => C gamma Int b)
which can then be simplified further to
978
  (forall b. 0 => D gamma)
979
Finally, we /can/ approximate this implication with (D gamma) and infer the quantified
980
981
type:  forall g. D g => g -> g

982
Instead what will currently happen is that we will get a quantified type
983
984
985
(forall g. g -> g) and an implication:
       forall g. 0 => (forall b. 0 => C g alpha b) /\ Num alpha

986
Which, even if the simplifyTop defaults (alpha := Int) we will still be left with an
987
988
989
unsolvable implication:
       forall g. 0 => (forall b. 0 => D g)

990
The concrete example would be:
991
992
993
       h :: C g a s => g -> a -> ST s a
       f (x::gamma) = (\_ -> x) (runST (h x (undefined::alpha)) + 1)

994
995
But it is quite tedious to do defaulting and resolve the implication constraints, and
we have not observed code breaking because of the lack of defaulting in inference, so
996
997
998
999
we don't do it for now.



1000
Note [Minimize by Superclasses]
1001
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1002
1003
1004
1005
1006
1007
1008
When we quantify over a constraint, in simplifyInfer we need to
quantify over a constraint that is minimal in some sense: For
instance, if the final wanted constraint is (Eq alpha, Ord alpha),
we'd like to quantify over Ord alpha, because we can just get Eq alpha
from superclass selection from Ord alpha. This minimization is what
mkMinimalBySCs does. Then, simplifyInfer uses the minimal constraint
to check the original wanted.
1009

1010

1011
Note [Avoid unnecessary constraint simplification]
1012
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1013
    -------- NB NB NB (Jun 12) -------------
1014
1015
1016
    This note not longer applies; see the notes with Trac #4361.
    But I'm leaving it in here so we remember the issue.)
    ----------------------------------------
1017
When inferring the type of a let-binding, with simplifyInfer,
1018
try to avoid unnecessarily simplifying class constraints.
1019
Doing so aids sharing, but it also helps with delicate
1020
situations like
1021

1022
   instance C t => C [t] where ..
1023

1024
   f :: C [t] => ....
1025
   f x = let g y = ...(constraint C [t])...
1026
1027
1028
1029
         in ...
When inferring a type for 'g', we don't want to apply the
instance decl, because then we can't satisfy (C t).  So we
just notice that g isn't quantified over 't' and partition
Gabor Greif's avatar
Gabor Greif committed
1030
the constraints before simplifying.
1031
1032
1033

This only half-works, but then let-generalisation only half-works.

1034
*********************************************************************************
1035
*                                                                                 *
1036
1037
1038
*                                 Main Simplifier                                 *
*                                                                                 *
***********************************************************************************
1039

Austin Seipp's avatar
Austin Seipp committed
1040
-}
1041