# Ticket #8221: compile.log

File compile.log, 50.2 KB (added by maxs, 3 years ago) |
---|

Line | |
---|---|

1 | Glasgow Haskell Compiler, Version 7.7.20130903, stage 1 booted by GHC version 7.6.3 |

2 | Using binary package database: /usr/local/ghc-ios/lib/arm-apple-darwin10-ghc-7.7.20130903/package.conf.d/package.cache |

3 | Using binary package database: /Users/maxs/.ghc/arm-ios-7.7.20130903/package.conf.d/package.cache |

4 | package Cabal-1.18.0-f77d4cea4e126952c97920670266b908 is shadowed by package Cabal-1.18.0-aeeba9bf826ee649b431ef7c47b896d5 |

5 | package bin-package-db-0.0.0.0-be66b8c90c0a5f2c8a07062cb3b43336 is unusable due to missing or recursive dependencies: |

6 | Cabal-1.18.0-f77d4cea4e126952c97920670266b908 |

7 | hiding package unix-2.6.0.1 to avoid conflict with later version unix-2.7.0.0 |

8 | wired-in package ghc-prim mapped to ghc-prim-0.3.1.0-15bdba9fbb71757de83e7e846ca2ba20 |

9 | wired-in package integer-simple mapped to integer-simple-0.1.1.0-3f983ebeb5daa77a5baede308e1193cc |

10 | wired-in package base mapped to base-4.7.0.0-1d4059174fe5fd8684ad293e8a9bb194 |

11 | wired-in package rts mapped to builtin_rts |

12 | wired-in package template-haskell mapped to template-haskell-2.9.0.0-be75e6d1e077cfba95f63ab72c68744e |

13 | wired-in package dph-seq not found. |

14 | wired-in package dph-par not found. |

15 | Hsc static flags: |

16 | package Cabal-1.18.0-f77d4cea4e126952c97920670266b908 is shadowed by package Cabal-1.18.0-aeeba9bf826ee649b431ef7c47b896d5 |

17 | package bin-package-db-0.0.0.0-be66b8c90c0a5f2c8a07062cb3b43336 is unusable due to missing or recursive dependencies: |

18 | Cabal-1.18.0-f77d4cea4e126952c97920670266b908 |

19 | hiding package unix-2.6.0.1 to avoid conflict with later version unix-2.7.0.0 |

20 | wired-in package ghc-prim mapped to ghc-prim-0.3.1.0-15bdba9fbb71757de83e7e846ca2ba20 |

21 | wired-in package integer-simple mapped to integer-simple-0.1.1.0-3f983ebeb5daa77a5baede308e1193cc |

22 | wired-in package base mapped to base-4.7.0.0-1d4059174fe5fd8684ad293e8a9bb194 |

23 | wired-in package rts mapped to builtin_rts |

24 | wired-in package template-haskell mapped to template-haskell-2.9.0.0-be75e6d1e077cfba95f63ab72c68744e |

25 | wired-in package dph-seq not found. |

26 | wired-in package dph-par not found. |

27 | *** Chasing dependencies: |

28 | Chasing modules from: *Type/Type.hs |

29 | Stable obj: [] |

30 | Stable BCO: [] |

31 | Ready for upsweep |

32 | [NONREC |

33 | ModSummary { |

34 | ms_hs_date = 2013-09-03 23:59:07 UTC |

35 | ms_mod = main:Type.Type, |

36 | ms_textual_imps = [import (implicit) Prelude, |

37 | import qualified Data.UnionFind.IO as UF, import Data.Data] |

38 | ms_srcimps = [] |

39 | }] |

40 | *** Deleting temp files: |

41 | Deleting: |

42 | compile: input file Type/Type.hs |

43 | Created temporary directory: /var/folders/4q/5j7w6x5x3c1bc427tcgvg4sc0000gn/T/ghc50904_0 |

44 | *** Checking old interface for main:Type.Type: |

45 | [1 of 1] Compiling Type.Type ( Type/Type.hs, Type/Type.o ) |

46 | *** Parser: |

47 | *** Renamer/typechecker: |

48 | rn12 |

49 | rn13 |

50 | Tc2 (src) |

51 | Tc3 |

52 | kcTyClGroup |

53 | module Type.Type |

54 | data SrcSpan |

55 | = Span String | NoSpan String |

56 | deriving (Eq, Ord, Data, Typeable) |

57 | env2 [] |

58 | kcTyClGroup: initial kinds |

59 | [(SrcSpan, AThing *), (Span, APromotionErr RecDataConPE), |

60 | (NoSpan, APromotionErr RecDataConPE)] |

61 | env2 [] |

62 | env2 [] |

63 | tc_lhs_type: |

64 | String |

65 | Expected a type |

66 | lk1 String |

67 | lk2 String Type constructor ‛String’ |

68 | env2 [] |

69 | tc_lhs_type: |

70 | String |

71 | Expected a type |

72 | lk1 String |

73 | lk2 String Type constructor ‛String’ |

74 | Generalise kind |

75 | SrcSpan |

76 | * |

77 | [] |

78 | * |

79 | kcTyClGroup result [(SrcSpan, *)] |

80 | tcTyAndCl generalized kinds [(SrcSpan, *)] |

81 | tcTyAndCl-x |

82 | data SrcSpan |

83 | = Span String | NoSpan String |

84 | deriving (Eq, Ord, Data, Typeable) |

85 | env2 [] |

86 | env2 [] |

87 | tcConDecl 1 Span |

88 | env2 [] |

89 | tcHsTyVarBndrs { |

90 | Hs kind vars: [] |

91 | Hs type vars: [] |

92 | Kind vars: [] |

93 | Type vars: [] |

94 | env2 [] |

95 | tcConArg 1 String |

96 | tc_lhs_type: |

97 | String |

98 | Expected a type |

99 | lk1 String |

100 | lk2 String Type constructor ‛String’ |

101 | tcConArg 2 String |

102 | tcHsTyVarBndrs } |

103 | Hs kind vars: [] |

104 | Hs type vars: [] |

105 | Kind vars: [] |

106 | Type vars: [] |

107 | tcConDecl 1 NoSpan |

108 | env2 [] |

109 | tcHsTyVarBndrs { |

110 | Hs kind vars: [] |

111 | Hs type vars: [] |

112 | Kind vars: [] |

113 | Type vars: [] |

114 | env2 [] |

115 | tcConArg 1 String |

116 | tc_lhs_type: |

117 | String |

118 | Expected a type |

119 | lk1 String |

120 | lk2 String Type constructor ‛String’ |

121 | tcConArg 2 String |

122 | tcHsTyVarBndrs } |

123 | Hs kind vars: [] |

124 | Hs type vars: [] |

125 | Kind vars: [] |

126 | Type vars: [] |

127 | Starting validity check [Type constructor ‛SrcSpan’] |

128 | Validity of 1 SrcSpan |

129 | Validity of 1a [(r6, Type constructor ‛SrcSpan’)] |

130 | Validity of 2 SrcSpan |

131 | Validity of Type constructor ‛SrcSpan’ |

132 | of kind * |

133 | cvtc1 SrcSpan |

134 | cvtc2 SrcSpan |

135 | Validity of data con Span |

136 | checkValidDataCon |

137 | Span |

138 | SrcSpan |

139 | checkValidType String -> SrcSpan :: * |

140 | Done validity of data con Span String -> SrcSpan |

141 | Validity of data con NoSpan |

142 | checkValidDataCon |

143 | NoSpan |

144 | SrcSpan |

145 | checkValidType String -> SrcSpan :: * |

146 | Done validity of data con NoSpan String -> SrcSpan |

147 | Done validity of Type constructor ‛SrcSpan’ |

148 | env2 [] |

149 | kcTyClGroup |

150 | module Type.Type |

151 | data Located e |

152 | = L SrcSpan e |

153 | deriving (Eq, Ord, Data, Typeable) |

154 | env2 [] |

155 | kcTyClGroup: initial kinds |

156 | [(Located, AThing k_aFs -> *), (L, APromotionErr RecDataConPE)] |

157 | env2 [] |

158 | env2 [] |

159 | tc_lhs_type: |

160 | SrcSpan |

161 | Expected a type |

162 | lk1 SrcSpan |

163 | lk2 SrcSpan Type constructor ‛SrcSpan’ |

164 | tc_lhs_type: |

165 | e |

166 | Expected a type |

167 | lk1 e |

168 | lk2 e AThing k_aFs |

169 | writeMetaTyVar k_aFs := * |

170 | Generalise kind |

171 | Located |

172 | k_aFs -> * |

173 | [] |

174 | * -> * |

175 | kcTyClGroup result [(Located, * -> *)] |

176 | tcTyAndCl generalized kinds [(Located, * -> *)] |

177 | tcTyAndCl-x |

178 | data Located e |

179 | = L SrcSpan e |

180 | deriving (Eq, Ord, Data, Typeable) |

181 | env2 [] |

182 | env2 [(e, Type variable ‛e’ = e)] |

183 | tcConDecl 1 L |

184 | env2 [] |

185 | tcHsTyVarBndrs { |

186 | Hs kind vars: [] |

187 | Hs type vars: [] |

188 | Kind vars: [] |

189 | Type vars: [] |

190 | env2 [] |

191 | tcConArg 1 SrcSpan |

192 | tc_lhs_type: |

193 | SrcSpan |

194 | Expected a type |

195 | lk1 SrcSpan |

196 | lk2 SrcSpan Type constructor ‛SrcSpan’ |

197 | tcConArg 2 SrcSpan |

198 | tcConArg 1 e |

199 | tc_lhs_type: |

200 | e |

201 | Expected a type |

202 | lk1 e |

203 | lk2 e Type variable ‛e’ = e |

204 | tcConArg 2 e |

205 | tcHsTyVarBndrs } |

206 | Hs kind vars: [] |

207 | Hs type vars: [] |

208 | Kind vars: [] |

209 | Type vars: [] |

210 | Starting validity check [Type constructor ‛Located’] |

211 | Validity of 1 Located |

212 | Validity of 1a |

213 | [(r4, Data constructor ‛Span’), (r5, Data constructor ‛NoSpan’), |

214 | (r6, Type constructor ‛SrcSpan’), (r8, Type constructor ‛Located’), |

215 | (rFo, Identifier ‛Type.Type.Span’), |

216 | (rFq, Identifier ‛Type.Type.NoSpan’)] |

217 | Validity of 2 Located |

218 | Validity of Type constructor ‛Located’ |

219 | of kind * -> * |

220 | cvtc1 Located |

221 | cvtc2 Located |

222 | Validity of data con L |

223 | checkValidDataCon |

224 | L |

225 | Located |

226 | checkValidType forall e. SrcSpan -> e -> Located e :: * |

227 | tcGen |

228 | u_tys |

229 | untch 1 |

230 | SrcSpan -> e_aFx -> Located e_aFx ~ SrcSpan -> e -> Located e |

231 | a type equality SrcSpan -> e_aFx -> Located e_aFx |

232 | ~ |

233 | SrcSpan -> e -> Located e |

234 | u_tys |

235 | untch 1 |

236 | SrcSpan ~ SrcSpan |

237 | a type equality SrcSpan -> e_aFx -> Located e_aFx |

238 | ~ |

239 | SrcSpan -> e -> Located e |

240 | u_tys yields no coercion |

241 | u_tys |

242 | untch 1 |

243 | e_aFx -> Located e_aFx ~ e -> Located e |

244 | a type equality SrcSpan -> e_aFx -> Located e_aFx |

245 | ~ |

246 | SrcSpan -> e -> Located e |

247 | u_tys |

248 | untch 1 |

249 | e_aFx ~ e |

250 | a type equality SrcSpan -> e_aFx -> Located e_aFx |

251 | ~ |

252 | SrcSpan -> e -> Located e |

253 | uUnfilledVars trying to unify * with * |

254 | writeMetaTyVar e_aFx := e |

255 | u_tys yields no coercion |

256 | u_tys |

257 | untch 1 |

258 | Located e_aFx ~ Located e |

259 | a type equality SrcSpan -> e_aFx -> Located e_aFx |

260 | ~ |

261 | SrcSpan -> e -> Located e |

262 | u_tys |

263 | untch 1 |

264 | e_aFx ~ e |

265 | a type equality SrcSpan -> e_aFx -> Located e_aFx |

266 | ~ |

267 | SrcSpan -> e -> Located e |

268 | u_tys yields no coercion |

269 | u_tys yields no coercion |

270 | u_tys yields no coercion |

271 | u_tys yields no coercion |

272 | simplifyTop { wanted = WC {} |

273 | solveWantedsTcMWithEvBinds wanted= WC {} |

274 | solveWanteds { WC {} |

275 | solveFlats { |

276 | solveFlats end } {} |

277 | solveWanteds } |

278 | unsolved_flats = {} |

279 | unsolved_implics = {} |

280 | current evbinds = {} |

281 | current tybinds = |

282 | final wc = WC {} |

283 | End simplifyTop } |

284 | reportUnsolved { |

285 | reportUnsolved } |

286 | Done validity of data con L forall e. SrcSpan -> e -> Located e |

287 | Done validity of Type constructor ‛Located’ |

288 | env2 [] |

289 | Adding instances: |

290 | addFamInsts |

291 | env2 [] |

292 | tcDeriving |

293 | tcDeriving False |

294 | env2 [] |

295 | lk1 Eq |

296 | lk2 Eq Class ‛Eq’ |

297 | writeMetaTyVar k_aFD := * -> Constraint |

298 | tcCheckHsTypeAndGen Eq |

299 | tcCheckHsTypeAndGen Eq |

300 | derivTyData |

301 | SrcSpan |

302 | [] |

303 | SrcSpan |

304 | env2 [] |

305 | lk1 Ord |

306 | lk2 Ord Class ‛Ord’ |

307 | writeMetaTyVar k_aFH := * -> Constraint |

308 | tcCheckHsTypeAndGen Ord |

309 | tcCheckHsTypeAndGen Ord |

310 | derivTyData |

311 | SrcSpan |

312 | [] |

313 | SrcSpan |

314 | env2 [] |

315 | lk1 Data |

316 | lk2 Data Class ‛Data’ |

317 | writeMetaTyVar k_aFL := * -> Constraint |

318 | tcCheckHsTypeAndGen Data |

319 | tcCheckHsTypeAndGen Data |

320 | derivTyData |

321 | SrcSpan |

322 | [] |

323 | SrcSpan |

324 | env2 [] |

325 | lk1 Typeable |

326 | lk2 Typeable Class ‛Typeable’ |

327 | lk4 Typeable :: forall (k :: BOX). k -> Constraint |

328 | writeMetaTyVar k_aFP := k_aFU -> Constraint |

329 | tcCheckHsTypeAndGen Typeable |

330 | tcCheckHsTypeAndGen Typeable k_aFU |

331 | writeMetaTyVar k_aFU := * |

332 | env2 [(e, Type variable ‛e’ = e)] |

333 | lk1 Eq |

334 | lk2 Eq Class ‛Eq’ |

335 | writeMetaTyVar k_aFV := * -> Constraint |

336 | tcCheckHsTypeAndGen Eq |

337 | tcCheckHsTypeAndGen Eq |

338 | derivTyData |

339 | e |

340 | Located |

341 | [e] |

342 | e |

343 | Located e |

344 | env2 [(e, Type variable ‛e’ = e)] |

345 | lk1 Ord |

346 | lk2 Ord Class ‛Ord’ |

347 | writeMetaTyVar k_aFW := * -> Constraint |

348 | tcCheckHsTypeAndGen Ord |

349 | tcCheckHsTypeAndGen Ord |

350 | derivTyData |

351 | e |

352 | Located |

353 | [e] |

354 | e |

355 | Located e |

356 | env2 [(e, Type variable ‛e’ = e)] |

357 | lk1 Data |

358 | lk2 Data Class ‛Data’ |

359 | writeMetaTyVar k_aFX := * -> Constraint |

360 | tcCheckHsTypeAndGen Data |

361 | tcCheckHsTypeAndGen Data |

362 | derivTyData |

363 | e |

364 | Located |

365 | [e] |

366 | e |

367 | Located e |

368 | env2 [(e, Type variable ‛e’ = e)] |

369 | lk1 Typeable |

370 | lk2 Typeable Class ‛Typeable’ |

371 | lk4 Typeable :: forall (k :: BOX). k -> Constraint |

372 | writeMetaTyVar k_aFY := k_aFZ -> Constraint |

373 | tcCheckHsTypeAndGen Typeable |

374 | tcCheckHsTypeAndGen Typeable k_aFZ |

375 | writeMetaTyVar k_aFZ := * |

376 | tcDeriving 1 |

377 | [Left (Type/Type.hs:9:15-16 Type.Type.$fEqSrcSpan [] Eq [SrcSpan] = [Eq |

378 | String, |

379 | Eq String]), |

380 | Left (Type/Type.hs:9:19-21 Type.Type.$fOrdSrcSpan [] Ord [SrcSpan] = [Eq |

381 | SrcSpan, |

382 | Ord String, Ord String]), |

383 | Left (Type/Type.hs:9:24-27 Type.Type.$fDataSrcSpan [] Data [SrcSpan] = [Typeable |

384 | * SrcSpan, |

385 | Data String, |

386 | Data String]), |

387 | Right (Type/Type.hs:9:30-37 Type.Type.$fTypeableSrcSpan [] Typeable [*, |

388 | SrcSpan] = []), |

389 | Left (Type/Type.hs:12:15-16 Type.Type.$fEqLocated [e] Eq [Located |

390 | e] = [Eq SrcSpan, Eq e]), |

391 | Left (Type/Type.hs:12:19-21 Type.Type.$fOrdLocated [e] Ord [Located |

392 | e] = [Eq (Located e), Ord SrcSpan, |

393 | Ord e]), |

394 | Left (Type/Type.hs:12:24-27 Type.Type.$fDataLocated [e] Data [Located |

395 | e] = [Data e, |

396 | Typeable * (Located e), |

397 | Data SrcSpan, Data e]), |

398 | Right (Type/Type.hs:12:30-37 Type.Type.$fTypeableLocated [] Typeable [* |

399 | -> *, |

400 | Located] = [])] |

401 | inferInstanceContexts |

402 | (Type/Type.hs:9:15-16 Type.Type.$fEqSrcSpan [] Eq [SrcSpan] = [Eq |

403 | String, |

404 | Eq String]) |

405 | (Type/Type.hs:9:19-21 Type.Type.$fOrdSrcSpan [] Ord [SrcSpan] = [Eq |

406 | SrcSpan, |

407 | Ord String, Ord String]) |

408 | (Type/Type.hs:9:24-27 Type.Type.$fDataSrcSpan [] Data [SrcSpan] = [Typeable |

409 | * SrcSpan, |

410 | Data String, Data String]) |

411 | (Type/Type.hs:12:15-16 Type.Type.$fEqLocated [e] Eq [Located |

412 | e] = [Eq SrcSpan, Eq e]) |

413 | (Type/Type.hs:12:19-21 Type.Type.$fOrdLocated [e] Ord [Located |

414 | e] = [Eq (Located e), Ord SrcSpan, |

415 | Ord e]) |

416 | (Type/Type.hs:12:24-27 Type.Type.$fDataLocated [e] Data [Located |

417 | e] = [Data e, Typeable * (Located e), |

418 | Data SrcSpan, Data e]) |

419 | simplifyDeriv |

420 | [Eq String, Eq String] |

421 | [[W] $dEq_aGb :: Eq String (CNonCanonical), |

422 | [W] $dEq_aGc :: Eq String (CNonCanonical)] |

423 | deriving (Eq SrcSpan) |

424 | solveWantedsTcMWithEvBinds |

425 | wanted= WC {wc_flat = [W] $dEq_aGb :: Eq String (CNonCanonical) |

426 | [W] $dEq_aGc :: Eq String (CNonCanonical)} |

427 | solveWanteds { |

428 | WC {wc_flat = [W] $dEq_aGb :: Eq String (CNonCanonical) |

429 | [W] $dEq_aGc :: Eq String (CNonCanonical)} |

430 | solveFlats { |

431 | Start solver pipeline { |

432 | work item = [W] $dEq_aGb :: Eq String (CNonCanonical) |

433 | inerts = Equalities: |

434 | Type-function equalities: |

435 | Dictionaries: |

436 | Irreds: |

437 | Insolubles = {} |

438 | Solved dicts 0 |

439 | Solved funeqs 0 |

440 | runStage canonicalization { |

441 | workitem = [W] $dEq_aGb :: Eq String (CNonCanonical) |

442 | canonicalize (non-canonical) |

443 | [W] $dEq_aGb :: Eq String (CNonCanonical) |

444 | canEvNC:cls Eq [String] |

445 | canClass |

446 | [W] $dEq_aGb :: Eq String Eq [String] |

447 | Eq String |

448 | Just [W] $dEq_aGb :: Eq String |

449 | end stage canonicalization } |

450 | runStage spontaneous solve { |

451 | workitem = [W] $dEq_aGb :: Eq String (CDictCan) |

452 | Spont: no tyvar on lhs [W] $dEq_aGb :: Eq String (CDictCan) |

453 | end stage spontaneous solve } |

454 | runStage interact with inerts { |

455 | workitem = [W] $dEq_aGb :: Eq String (CDictCan) |

456 | interactWithInerts workitem = [W] $dEq_aGb :: Eq String (CDictCan) |

457 | relevant inerts are: {} |

458 | end stage interact with inerts } |

459 | runStage top-level reactions { |

460 | workitem = [W] $dEq_aGb :: Eq String (CDictCan) |

461 | doTopReact [W] $dEq_aGb :: Eq String (CDictCan) |

462 | matchClassInst |

463 | pred = Eq String |

464 | inerts= Equalities: |

465 | Type-function equalities: |

466 | Dictionaries: |

467 | Irreds: |

468 | Insolubles = {} |

469 | Solved dicts 0 |

470 | Solved funeqs 0 |

471 | untouchables= 0 |

472 | matchClass success |

473 | dict Eq String |

474 | witness GHC.Classes.$fEq[] forall a. Eq a => Eq [a] |

475 | newWantedEvVar/cache miss [W] $dEq_aGf :: Eq Char |

476 | updSolvedSetTcs: [W] $dEq_aGb :: Eq String |

477 | doTopReact/found non-nullary instance for $dEq_aGb |

478 | setEvBind |

479 | ev = $dEq_aGb |

480 | tm = GHC.Classes.$fEq[] @[Char] [$dEq_aGf] |

481 | end stage top-level reactions } |

482 | End solver pipeline (discharged) } |

483 | inerts = Equalities: |

484 | Type-function equalities: |

485 | Dictionaries: |

486 | Irreds: |

487 | Insolubles = {} |

488 | Solved dicts 1 |

489 | Solved funeqs 0 |

490 | Start solver pipeline { |

491 | work item = [W] $dEq_aGf :: Eq Char (CNonCanonical) |

492 | inerts = Equalities: |

493 | Type-function equalities: |

494 | Dictionaries: |

495 | Irreds: |

496 | Insolubles = {} |

497 | Solved dicts 1 |

498 | Solved funeqs 0 |

499 | runStage canonicalization { |

500 | workitem = [W] $dEq_aGf :: Eq Char (CNonCanonical) |

501 | canonicalize (non-canonical) |

502 | [W] $dEq_aGf :: Eq Char (CNonCanonical) |

503 | canEvNC:cls Eq [Char] |

504 | canClass |

505 | [W] $dEq_aGf :: Eq Char Eq [Char] |

506 | Eq Char |

507 | Just [W] $dEq_aGf :: Eq Char |

508 | end stage canonicalization } |

509 | runStage spontaneous solve { |

510 | workitem = [W] $dEq_aGf :: Eq Char (CDictCan) |

511 | Spont: no tyvar on lhs [W] $dEq_aGf :: Eq Char (CDictCan) |

512 | end stage spontaneous solve } |

513 | runStage interact with inerts { |

514 | workitem = [W] $dEq_aGf :: Eq Char (CDictCan) |

515 | interactWithInerts workitem = [W] $dEq_aGf :: Eq Char (CDictCan) |

516 | relevant inerts are: {} |

517 | end stage interact with inerts } |

518 | runStage top-level reactions { |

519 | workitem = [W] $dEq_aGf :: Eq Char (CDictCan) |

520 | doTopReact [W] $dEq_aGf :: Eq Char (CDictCan) |

521 | matchClassInst |

522 | pred = Eq Char |

523 | inerts= Equalities: |

524 | Type-function equalities: |

525 | Dictionaries: |

526 | Irreds: |

527 | Insolubles = {} |

528 | Solved dicts 1 |

529 | Solved funeqs 0 |

530 | untouchables= 0 |

531 | matchClass success |

532 | dict Eq Char |

533 | witness GHC.Classes.$fEqChar Eq Char |

534 | updSolvedSetTcs: [W] $dEq_aGf :: Eq Char |

535 | doTopReact/found nullary instance for $dEq_aGf |

536 | setEvBind |

537 | ev = $dEq_aGf |

538 | tm = GHC.Classes.$fEqChar @[] [] |

539 | end stage top-level reactions } |

540 | End solver pipeline (discharged) } |

541 | inerts = Equalities: |

542 | Type-function equalities: |

543 | Dictionaries: |

544 | Irreds: |

545 | Insolubles = {} |

546 | Solved dicts 2 |

547 | Solved funeqs 0 |

548 | Start solver pipeline { |

549 | work item = [W] $dEq_aGc :: Eq String (CNonCanonical) |

550 | inerts = Equalities: |

551 | Type-function equalities: |

552 | Dictionaries: |

553 | Irreds: |

554 | Insolubles = {} |

555 | Solved dicts 2 |

556 | Solved funeqs 0 |

557 | runStage canonicalization { |

558 | workitem = [W] $dEq_aGc :: Eq String (CNonCanonical) |

559 | canonicalize (non-canonical) |

560 | [W] $dEq_aGc :: Eq String (CNonCanonical) |

561 | canEvNC:cls Eq [String] |

562 | canClass |

563 | [W] $dEq_aGc :: Eq String Eq [String] |

564 | Eq String |

565 | Just [W] $dEq_aGc :: Eq String |

566 | end stage canonicalization } |

567 | runStage spontaneous solve { |

568 | workitem = [W] $dEq_aGc :: Eq String (CDictCan) |

569 | Spont: no tyvar on lhs [W] $dEq_aGc :: Eq String (CDictCan) |

570 | end stage spontaneous solve } |

571 | runStage interact with inerts { |

572 | workitem = [W] $dEq_aGc :: Eq String (CDictCan) |

573 | interactWithInerts workitem = [W] $dEq_aGc :: Eq String (CDictCan) |

574 | relevant inerts are: {} |

575 | end stage interact with inerts } |

576 | runStage top-level reactions { |

577 | workitem = [W] $dEq_aGc :: Eq String (CDictCan) |

578 | doTopReact [W] $dEq_aGc :: Eq String (CDictCan) |

579 | setEvBind |

580 | ev = $dEq_aGc |

581 | tm = $dEq_aGb |

582 | end stage top-level reactions } |

583 | End solver pipeline (discharged) } |

584 | inerts = Equalities: |

585 | Type-function equalities: |

586 | Dictionaries: |

587 | Irreds: |

588 | Insolubles = {} |

589 | Solved dicts 2 |

590 | Solved funeqs 0 |

591 | solveFlats end } {} |

592 | solveWanteds } |

593 | unsolved_flats = {} |

594 | unsolved_implics = {} |

595 | current evbinds = {$dEq_aGb |

596 | = GHC.Classes.$fEq[] @[Char] [$dEq_aGf], |

597 | $dEq_aGc = $dEq_aGb, $dEq_aGf = GHC.Classes.$fEqChar @[] []} |

598 | current tybinds = |

599 | final wc = WC {} |

600 | TcDeriv |

601 | [Eq String, Eq String] |

602 | [] |

603 | simplifyDeriv |

604 | [Eq SrcSpan, Ord String, Ord String] |

605 | [[W] $dEq_aGg :: Eq SrcSpan (CNonCanonical), |

606 | [W] $dOrd_aGh :: Ord String (CNonCanonical), |

607 | [W] $dOrd_aGi :: Ord String (CNonCanonical)] |

608 | deriving (Ord SrcSpan) |

609 | solveWantedsTcMWithEvBinds |

610 | wanted= WC {wc_flat = [W] $dEq_aGg :: Eq SrcSpan (CNonCanonical) |

611 | [W] $dOrd_aGh :: Ord String (CNonCanonical) |

612 | [W] $dOrd_aGi :: Ord String (CNonCanonical)} |

613 | solveWanteds { |

614 | WC {wc_flat = [W] $dEq_aGg :: Eq SrcSpan (CNonCanonical) |

615 | [W] $dOrd_aGh :: Ord String (CNonCanonical) |

616 | [W] $dOrd_aGi :: Ord String (CNonCanonical)} |

617 | solveFlats { |

618 | Start solver pipeline { |

619 | work item = [W] $dEq_aGg :: Eq SrcSpan (CNonCanonical) |

620 | inerts = Equalities: |

621 | Type-function equalities: |

622 | Dictionaries: |

623 | Irreds: |

624 | Insolubles = {} |

625 | Solved dicts 0 |

626 | Solved funeqs 0 |

627 | runStage canonicalization { |

628 | workitem = [W] $dEq_aGg :: Eq SrcSpan (CNonCanonical) |

629 | canonicalize (non-canonical) |

630 | [W] $dEq_aGg :: Eq SrcSpan (CNonCanonical) |

631 | canEvNC:cls Eq [SrcSpan] |

632 | canClass |

633 | [W] $dEq_aGg :: Eq SrcSpan Eq [SrcSpan] |

634 | Eq SrcSpan |

635 | Just [W] $dEq_aGg :: Eq SrcSpan |

636 | end stage canonicalization } |

637 | runStage spontaneous solve { |

638 | workitem = [W] $dEq_aGg :: Eq SrcSpan (CDictCan) |

639 | Spont: no tyvar on lhs [W] $dEq_aGg :: Eq SrcSpan (CDictCan) |

640 | end stage spontaneous solve } |

641 | runStage interact with inerts { |

642 | workitem = [W] $dEq_aGg :: Eq SrcSpan (CDictCan) |

643 | interactWithInerts |

644 | workitem = [W] $dEq_aGg :: Eq SrcSpan (CDictCan) |

645 | relevant inerts are: {} |

646 | end stage interact with inerts } |

647 | runStage top-level reactions { |

648 | workitem = [W] $dEq_aGg :: Eq SrcSpan (CDictCan) |

649 | doTopReact [W] $dEq_aGg :: Eq SrcSpan (CDictCan) |

650 | matchClassInst |

651 | pred = Eq SrcSpan |

652 | inerts= Equalities: |

653 | Type-function equalities: |

654 | Dictionaries: |

655 | Irreds: |

656 | Insolubles = {} |

657 | Solved dicts 0 |

658 | Solved funeqs 0 |

659 | untouchables= 0 |

660 | matchClass success |

661 | dict Eq SrcSpan |

662 | witness Type.Type.$fEqSrcSpan Eq SrcSpan |

663 | updSolvedSetTcs: [W] $dEq_aGg :: Eq SrcSpan |

664 | doTopReact/found nullary instance for $dEq_aGg |

665 | setEvBind |

666 | ev = $dEq_aGg |

667 | tm = Type.Type.$fEqSrcSpan @[] [] |

668 | end stage top-level reactions } |

669 | End solver pipeline (discharged) } |

670 | inerts = Equalities: |

671 | Type-function equalities: |

672 | Dictionaries: |

673 | Irreds: |

674 | Insolubles = {} |

675 | Solved dicts 1 |

676 | Solved funeqs 0 |

677 | Start solver pipeline { |

678 | work item = [W] $dOrd_aGh :: Ord String (CNonCanonical) |

679 | inerts = Equalities: |

680 | Type-function equalities: |

681 | Dictionaries: |

682 | Irreds: |

683 | Insolubles = {} |

684 | Solved dicts 1 |

685 | Solved funeqs 0 |

686 | runStage canonicalization { |

687 | workitem = [W] $dOrd_aGh :: Ord String (CNonCanonical) |

688 | canonicalize (non-canonical) |

689 | [W] $dOrd_aGh :: Ord String (CNonCanonical) |

690 | canEvNC:cls Ord [String] |

691 | canClass |

692 | [W] $dOrd_aGh :: Ord String Ord [String] |

693 | Ord String |

694 | Just [W] $dOrd_aGh :: Ord String |

695 | end stage canonicalization } |

696 | runStage spontaneous solve { |

697 | workitem = [W] $dOrd_aGh :: Ord String (CDictCan) |

698 | Spont: no tyvar on lhs [W] $dOrd_aGh :: Ord String (CDictCan) |

699 | end stage spontaneous solve } |

700 | runStage interact with inerts { |

701 | workitem = [W] $dOrd_aGh :: Ord String (CDictCan) |

702 | interactWithInerts |

703 | workitem = [W] $dOrd_aGh :: Ord String (CDictCan) |

704 | relevant inerts are: {} |

705 | end stage interact with inerts } |

706 | runStage top-level reactions { |

707 | workitem = [W] $dOrd_aGh :: Ord String (CDictCan) |

708 | doTopReact [W] $dOrd_aGh :: Ord String (CDictCan) |

709 | matchClassInst |

710 | pred = Ord String |

711 | inerts= Equalities: |

712 | Type-function equalities: |

713 | Dictionaries: |

714 | Irreds: |

715 | Insolubles = {} |

716 | Solved dicts 1 |

717 | Solved funeqs 0 |

718 | untouchables= 0 |

719 | matchClass success |

720 | dict Ord String |

721 | witness GHC.Classes.$fOrd[] forall a. (Eq [a], Ord a) => Ord [a] |

722 | newWantedEvVar/cache miss [W] $dEq_aGl :: Eq [Char] |

723 | newWantedEvVar/cache miss [W] $dOrd_aGm :: Ord Char |

724 | updSolvedSetTcs: [W] $dOrd_aGh :: Ord String |

725 | doTopReact/found non-nullary instance for $dOrd_aGh |

726 | setEvBind |

727 | ev = $dOrd_aGh |

728 | tm = GHC.Classes.$fOrd[] @[Char] [$dEq_aGl, $dOrd_aGm] |

729 | end stage top-level reactions } |

730 | End solver pipeline (discharged) } |

731 | inerts = Equalities: |

732 | Type-function equalities: |

733 | Dictionaries: |

734 | Irreds: |

735 | Insolubles = {} |

736 | Solved dicts 2 |

737 | Solved funeqs 0 |

738 | Start solver pipeline { |

739 | work item = [W] $dEq_aGl :: Eq [Char] (CNonCanonical) |

740 | inerts = Equalities: |

741 | Type-function equalities: |

742 | Dictionaries: |

743 | Irreds: |

744 | Insolubles = {} |

745 | Solved dicts 2 |

746 | Solved funeqs 0 |

747 | runStage canonicalization { |

748 | workitem = [W] $dEq_aGl :: Eq [Char] (CNonCanonical) |

749 | canonicalize (non-canonical) |

750 | [W] $dEq_aGl :: Eq [Char] (CNonCanonical) |

751 | canEvNC:cls Eq [[Char]] |

752 | canClass |

753 | [W] $dEq_aGl :: Eq [Char] Eq [[Char]] |

754 | Eq [Char] |

755 | Just [W] $dEq_aGl :: Eq [Char] |

756 | end stage canonicalization } |

757 | runStage spontaneous solve { |

758 | workitem = [W] $dEq_aGl :: Eq [Char] (CDictCan) |

759 | Spont: no tyvar on lhs [W] $dEq_aGl :: Eq [Char] (CDictCan) |

760 | end stage spontaneous solve } |

761 | runStage interact with inerts { |

762 | workitem = [W] $dEq_aGl :: Eq [Char] (CDictCan) |

763 | interactWithInerts workitem = [W] $dEq_aGl :: Eq [Char] (CDictCan) |

764 | relevant inerts are: {} |

765 | end stage interact with inerts } |

766 | runStage top-level reactions { |

767 | workitem = [W] $dEq_aGl :: Eq [Char] (CDictCan) |

768 | doTopReact [W] $dEq_aGl :: Eq [Char] (CDictCan) |

769 | matchClassInst |

770 | pred = Eq [Char] |

771 | inerts= Equalities: |

772 | Type-function equalities: |

773 | Dictionaries: |

774 | Irreds: |

775 | Insolubles = {} |

776 | Solved dicts 2 |

777 | Solved funeqs 0 |

778 | untouchables= 0 |

779 | matchClass success |

780 | dict Eq [Char] |

781 | witness GHC.Classes.$fEq[] forall a. Eq a => Eq [a] |

782 | newWantedEvVar/cache miss [W] $dEq_aGn :: Eq Char |

783 | updSolvedSetTcs: [W] $dEq_aGl :: Eq [Char] |

784 | doTopReact/found non-nullary instance for $dEq_aGl |

785 | setEvBind |

786 | ev = $dEq_aGl |

787 | tm = GHC.Classes.$fEq[] @[Char] [$dEq_aGn] |

788 | end stage top-level reactions } |

789 | End solver pipeline (discharged) } |

790 | inerts = Equalities: |

791 | Type-function equalities: |

792 | Dictionaries: |

793 | Irreds: |

794 | Insolubles = {} |

795 | Solved dicts 3 |

796 | Solved funeqs 0 |

797 | Start solver pipeline { |

798 | work item = [W] $dEq_aGn :: Eq Char (CNonCanonical) |

799 | inerts = Equalities: |

800 | Type-function equalities: |

801 | Dictionaries: |

802 | Irreds: |

803 | Insolubles = {} |

804 | Solved dicts 3 |

805 | Solved funeqs 0 |

806 | runStage canonicalization { |

807 | workitem = [W] $dEq_aGn :: Eq Char (CNonCanonical) |

808 | canonicalize (non-canonical) |

809 | [W] $dEq_aGn :: Eq Char (CNonCanonical) |

810 | canEvNC:cls Eq [Char] |

811 | canClass |

812 | [W] $dEq_aGn :: Eq Char Eq [Char] |

813 | Eq Char |

814 | Just [W] $dEq_aGn :: Eq Char |

815 | end stage canonicalization } |

816 | runStage spontaneous solve { |

817 | workitem = [W] $dEq_aGn :: Eq Char (CDictCan) |

818 | Spont: no tyvar on lhs [W] $dEq_aGn :: Eq Char (CDictCan) |

819 | end stage spontaneous solve } |

820 | runStage interact with inerts { |

821 | workitem = [W] $dEq_aGn :: Eq Char (CDictCan) |

822 | interactWithInerts workitem = [W] $dEq_aGn :: Eq Char (CDictCan) |

823 | relevant inerts are: {} |

824 | end stage interact with inerts } |

825 | runStage top-level reactions { |

826 | workitem = [W] $dEq_aGn :: Eq Char (CDictCan) |

827 | doTopReact [W] $dEq_aGn :: Eq Char (CDictCan) |

828 | matchClassInst |

829 | pred = Eq Char |

830 | inerts= Equalities: |

831 | Type-function equalities: |

832 | Dictionaries: |

833 | Irreds: |

834 | Insolubles = {} |

835 | Solved dicts 3 |

836 | Solved funeqs 0 |

837 | untouchables= 0 |

838 | matchClass success |

839 | dict Eq Char |

840 | witness GHC.Classes.$fEqChar Eq Char |

841 | updSolvedSetTcs: [W] $dEq_aGn :: Eq Char |

842 | doTopReact/found nullary instance for $dEq_aGn |

843 | setEvBind |

844 | ev = $dEq_aGn |

845 | tm = GHC.Classes.$fEqChar @[] [] |

846 | end stage top-level reactions } |

847 | End solver pipeline (discharged) } |

848 | inerts = Equalities: |

849 | Type-function equalities: |

850 | Dictionaries: |

851 | Irreds: |

852 | Insolubles = {} |

853 | Solved dicts 4 |

854 | Solved funeqs 0 |

855 | Start solver pipeline { |

856 | work item = [W] $dOrd_aGm :: Ord Char (CNonCanonical) |

857 | inerts = Equalities: |

858 | Type-function equalities: |

859 | Dictionaries: |

860 | Irreds: |

861 | Insolubles = {} |

862 | Solved dicts 4 |

863 | Solved funeqs 0 |

864 | runStage canonicalization { |

865 | workitem = [W] $dOrd_aGm :: Ord Char (CNonCanonical) |

866 | canonicalize (non-canonical) |

867 | [W] $dOrd_aGm :: Ord Char (CNonCanonical) |

868 | canEvNC:cls Ord [Char] |

869 | canClass |

870 | [W] $dOrd_aGm :: Ord Char Ord [Char] |

871 | Ord Char |

872 | Just [W] $dOrd_aGm :: Ord Char |

873 | end stage canonicalization } |

874 | runStage spontaneous solve { |

875 | workitem = [W] $dOrd_aGm :: Ord Char (CDictCan) |

876 | Spont: no tyvar on lhs [W] $dOrd_aGm :: Ord Char (CDictCan) |

877 | end stage spontaneous solve } |

878 | runStage interact with inerts { |

879 | workitem = [W] $dOrd_aGm :: Ord Char (CDictCan) |

880 | interactWithInerts workitem = [W] $dOrd_aGm :: Ord Char (CDictCan) |

881 | relevant inerts are: {} |

882 | end stage interact with inerts } |

883 | runStage top-level reactions { |

884 | workitem = [W] $dOrd_aGm :: Ord Char (CDictCan) |

885 | doTopReact [W] $dOrd_aGm :: Ord Char (CDictCan) |

886 | matchClassInst |

887 | pred = Ord Char |

888 | inerts= Equalities: |

889 | Type-function equalities: |

890 | Dictionaries: |

891 | Irreds: |

892 | Insolubles = {} |

893 | Solved dicts 4 |

894 | Solved funeqs 0 |

895 | untouchables= 0 |

896 | matchClass success |

897 | dict Ord Char |

898 | witness GHC.Classes.$fOrdChar Ord Char |

899 | updSolvedSetTcs: [W] $dOrd_aGm :: Ord Char |

900 | doTopReact/found nullary instance for $dOrd_aGm |

901 | setEvBind |

902 | ev = $dOrd_aGm |

903 | tm = GHC.Classes.$fOrdChar @[] [] |

904 | end stage top-level reactions } |

905 | End solver pipeline (discharged) } |

906 | inerts = Equalities: |

907 | Type-function equalities: |

908 | Dictionaries: |

909 | Irreds: |

910 | Insolubles = {} |

911 | Solved dicts 5 |

912 | Solved funeqs 0 |

913 | Start solver pipeline { |

914 | work item = [W] $dOrd_aGi :: Ord String (CNonCanonical) |

915 | inerts = Equalities: |

916 | Type-function equalities: |

917 | Dictionaries: |

918 | Irreds: |

919 | Insolubles = {} |

920 | Solved dicts 5 |

921 | Solved funeqs 0 |

922 | runStage canonicalization { |

923 | workitem = [W] $dOrd_aGi :: Ord String (CNonCanonical) |

924 | canonicalize (non-canonical) |

925 | [W] $dOrd_aGi :: Ord String (CNonCanonical) |

926 | canEvNC:cls Ord [String] |

927 | canClass |

928 | [W] $dOrd_aGi :: Ord String Ord [String] |

929 | Ord String |

930 | Just [W] $dOrd_aGi :: Ord String |

931 | end stage canonicalization } |

932 | runStage spontaneous solve { |

933 | workitem = [W] $dOrd_aGi :: Ord String (CDictCan) |

934 | Spont: no tyvar on lhs [W] $dOrd_aGi :: Ord String (CDictCan) |

935 | end stage spontaneous solve } |

936 | runStage interact with inerts { |

937 | workitem = [W] $dOrd_aGi :: Ord String (CDictCan) |

938 | interactWithInerts |

939 | workitem = [W] $dOrd_aGi :: Ord String (CDictCan) |

940 | relevant inerts are: {} |

941 | end stage interact with inerts } |

942 | runStage top-level reactions { |

943 | workitem = [W] $dOrd_aGi :: Ord String (CDictCan) |

944 | doTopReact [W] $dOrd_aGi :: Ord String (CDictCan) |

945 | setEvBind |

946 | ev = $dOrd_aGi |

947 | tm = $dOrd_aGh |

948 | end stage top-level reactions } |

949 | End solver pipeline (discharged) } |

950 | inerts = Equalities: |

951 | Type-function equalities: |

952 | Dictionaries: |

953 | Irreds: |

954 | Insolubles = {} |

955 | Solved dicts 5 |

956 | Solved funeqs 0 |

957 | solveFlats end } {} |

958 | solveWanteds } |

959 | unsolved_flats = {} |

960 | unsolved_implics = {} |

961 | current evbinds = {$dEq_aGg = Type.Type.$fEqSrcSpan @[] [], |

962 | $dOrd_aGh = GHC.Classes.$fOrd[] @[Char] [$dEq_aGl, $dOrd_aGm], |

963 | $dOrd_aGi = $dOrd_aGh, |

964 | $dEq_aGl = GHC.Classes.$fEq[] @[Char] [$dEq_aGn], |

965 | $dOrd_aGm = GHC.Classes.$fOrdChar @[] [], |

966 | $dEq_aGn = GHC.Classes.$fEqChar @[] []} |

967 | current tybinds = |

968 | final wc = WC {} |

969 | TcDeriv |

970 | [Eq SrcSpan, Ord String, Ord String] |

971 | [] |

972 | simplifyDeriv |

973 | [Typeable * SrcSpan, Data String, Data String] |

974 | [[W] $dTypeable_aGo :: Typeable * SrcSpan (CNonCanonical), |

975 | [W] $dData_aGp :: Data String (CNonCanonical), |

976 | [W] $dData_aGq :: Data String (CNonCanonical)] |

977 | deriving (Data SrcSpan) |

978 | solveWantedsTcMWithEvBinds |

979 | wanted= WC {wc_flat = [W] $dTypeable_aGo :: Typeable |

980 | * SrcSpan (CNonCanonical) |

981 | [W] $dData_aGp :: Data String (CNonCanonical) |

982 | [W] $dData_aGq :: Data String (CNonCanonical)} |

983 | solveWanteds { |

984 | WC {wc_flat = [W] $dTypeable_aGo :: Typeable |

985 | * SrcSpan (CNonCanonical) |

986 | [W] $dData_aGp :: Data String (CNonCanonical) |

987 | [W] $dData_aGq :: Data String (CNonCanonical)} |

988 | solveFlats { |

989 | Start solver pipeline { |

990 | work item = [W] $dTypeable_aGo :: Typeable |

991 | * SrcSpan (CNonCanonical) |

992 | inerts = Equalities: |

993 | Type-function equalities: |

994 | Dictionaries: |

995 | Irreds: |

996 | Insolubles = {} |

997 | Solved dicts 0 |

998 | Solved funeqs 0 |

999 | runStage canonicalization { |

1000 | workitem = [W] $dTypeable_aGo :: Typeable |

1001 | * SrcSpan (CNonCanonical) |

1002 | canonicalize (non-canonical) |

1003 | [W] $dTypeable_aGo :: Typeable * SrcSpan (CNonCanonical) |

1004 | canEvNC:cls Typeable [*, SrcSpan] |

1005 | canClass |

1006 | [W] $dTypeable_aGo :: Typeable * SrcSpan Typeable [*, SrcSpan] |

1007 | Typeable * SrcSpan |

1008 | Just [W] $dTypeable_aGo :: Typeable * SrcSpan |

1009 | end stage canonicalization } |

1010 | runStage spontaneous solve { |

1011 | workitem = [W] $dTypeable_aGo :: Typeable * SrcSpan (CDictCan) |

1012 | Spont: no tyvar on lhs |

1013 | [W] $dTypeable_aGo :: Typeable * SrcSpan (CDictCan) |

1014 | end stage spontaneous solve } |

1015 | runStage interact with inerts { |

1016 | workitem = [W] $dTypeable_aGo :: Typeable * SrcSpan (CDictCan) |

1017 | interactWithInerts |

1018 | workitem = [W] $dTypeable_aGo :: Typeable * SrcSpan (CDictCan) |

1019 | relevant inerts are: {} |

1020 | end stage interact with inerts } |

1021 | runStage top-level reactions { |

1022 | workitem = [W] $dTypeable_aGo :: Typeable * SrcSpan (CDictCan) |

1023 | doTopReact [W] $dTypeable_aGo :: Typeable * SrcSpan (CDictCan) |

1024 | matchClassInst |

1025 | pred = Typeable * SrcSpan |

1026 | inerts= Equalities: |

1027 | Type-function equalities: |

1028 | Dictionaries: |

1029 | Irreds: |

1030 | Insolubles = {} |

1031 | Solved dicts 0 |

1032 | Solved funeqs 0 |

1033 | untouchables= 0 |

1034 | matchClass success |

1035 | dict Typeable * SrcSpan |

1036 | witness Type.Type.$fTypeableSrcSpan Typeable * SrcSpan |

1037 | updSolvedSetTcs: [W] $dTypeable_aGo :: Typeable * SrcSpan |

1038 | doTopReact/found nullary instance for $dTypeable_aGo |

1039 | setEvBind |

1040 | ev = $dTypeable_aGo |

1041 | tm = Type.Type.$fTypeableSrcSpan @[] [] |

1042 | end stage top-level reactions } |

1043 | End solver pipeline (discharged) } |

1044 | inerts = Equalities: |

1045 | Type-function equalities: |

1046 | Dictionaries: |

1047 | Irreds: |

1048 | Insolubles = {} |

1049 | Solved dicts 1 |

1050 | Solved funeqs 0 |

1051 | Start solver pipeline { |

1052 | work item = [W] $dData_aGp :: Data String (CNonCanonical) |

1053 | inerts = Equalities: |

1054 | Type-function equalities: |

1055 | Dictionaries: |

1056 | Irreds: |

1057 | Insolubles = {} |

1058 | Solved dicts 1 |

1059 | Solved funeqs 0 |

1060 | runStage canonicalization { |

1061 | workitem = [W] $dData_aGp :: Data String (CNonCanonical) |

1062 | canonicalize (non-canonical) |

1063 | [W] $dData_aGp :: Data String (CNonCanonical) |

1064 | canEvNC:cls Data [String] |

1065 | canClass |

1066 | [W] $dData_aGp :: Data String Data [String] |

1067 | Data String |

1068 | Just [W] $dData_aGp :: Data String |

1069 | end stage canonicalization } |

1070 | runStage spontaneous solve { |

1071 | workitem = [W] $dData_aGp :: Data String (CDictCan) |

1072 | Spont: no tyvar on lhs [W] $dData_aGp :: Data String (CDictCan) |

1073 | end stage spontaneous solve } |

1074 | runStage interact with inerts { |

1075 | workitem = [W] $dData_aGp :: Data String (CDictCan) |

1076 | interactWithInerts |

1077 | workitem = [W] $dData_aGp :: Data String (CDictCan) |

1078 | relevant inerts are: {} |

1079 | end stage interact with inerts } |

1080 | runStage top-level reactions { |

1081 | workitem = [W] $dData_aGp :: Data String (CDictCan) |

1082 | doTopReact [W] $dData_aGp :: Data String (CDictCan) |

1083 | matchClassInst |

1084 | pred = Data String |

1085 | inerts= Equalities: |

1086 | Type-function equalities: |

1087 | Dictionaries: |

1088 | Irreds: |

1089 | Insolubles = {} |

1090 | Solved dicts 1 |

1091 | Solved funeqs 0 |

1092 | untouchables= 0 |

1093 | matchClass success |

1094 | dict Data String |

1095 | witness Data.Data.$fData[] forall a. |

1096 | (Typeable * [a], Data a) => |

1097 | Data [a] |

1098 | newWantedEvVar/cache miss [W] $dTypeable_aGx :: Typeable * [Char] |

1099 | newWantedEvVar/cache miss [W] $dData_aGy :: Data Char |

1100 | updSolvedSetTcs: [W] $dData_aGp :: Data String |

1101 | doTopReact/found non-nullary instance for $dData_aGp |

1102 | setEvBind |

1103 | ev = $dData_aGp |

1104 | tm = Data.Data.$fData[] @[Char] [$dTypeable_aGx, $dData_aGy] |

1105 | end stage top-level reactions } |

1106 | End solver pipeline (discharged) } |

1107 | inerts = Equalities: |

1108 | Type-function equalities: |

1109 | Dictionaries: |

1110 | Irreds: |

1111 | Insolubles = {} |

1112 | Solved dicts 2 |

1113 | Solved funeqs 0 |

1114 | Start solver pipeline { |

1115 | work item = [W] $dTypeable_aGx :: Typeable |

1116 | * [Char] (CNonCanonical) |

1117 | inerts = Equalities: |

1118 | Type-function equalities: |

1119 | Dictionaries: |

1120 | Irreds: |

1121 | Insolubles = {} |

1122 | Solved dicts 2 |

1123 | Solved funeqs 0 |

1124 | runStage canonicalization { |

1125 | workitem = [W] $dTypeable_aGx :: Typeable |

1126 | * [Char] (CNonCanonical) |

1127 | canonicalize (non-canonical) |

1128 | [W] $dTypeable_aGx :: Typeable * [Char] (CNonCanonical) |

1129 | canEvNC:cls Typeable [*, [Char]] |

1130 | canClass |

1131 | [W] $dTypeable_aGx :: Typeable * [Char] Typeable [*, [Char]] |

1132 | Typeable * [Char] |

1133 | Just [W] $dTypeable_aGx :: Typeable * [Char] |

1134 | end stage canonicalization } |

1135 | runStage spontaneous solve { |

1136 | workitem = [W] $dTypeable_aGx :: Typeable * [Char] (CDictCan) |

1137 | Spont: no tyvar on lhs |

1138 | [W] $dTypeable_aGx :: Typeable * [Char] (CDictCan) |

1139 | end stage spontaneous solve } |

1140 | runStage interact with inerts { |

1141 | workitem = [W] $dTypeable_aGx :: Typeable * [Char] (CDictCan) |

1142 | interactWithInerts |

1143 | workitem = [W] $dTypeable_aGx :: Typeable * [Char] (CDictCan) |

1144 | relevant inerts are: {} |

1145 | end stage interact with inerts } |

1146 | runStage top-level reactions { |

1147 | workitem = [W] $dTypeable_aGx :: Typeable * [Char] (CDictCan) |

1148 | doTopReact [W] $dTypeable_aGx :: Typeable * [Char] (CDictCan) |

1149 | matchClassInst |

1150 | pred = Typeable * [Char] |

1151 | inerts= Equalities: |

1152 | Type-function equalities: |

1153 | Dictionaries: |

1154 | Irreds: |

1155 | Insolubles = {} |

1156 | Solved dicts 2 |

1157 | Solved funeqs 0 |

1158 | untouchables= 0 |

1159 | matchClass success |

1160 | dict Typeable * [Char] |

1161 | witness Data.Typeable.Internal.$fTypeableks forall (k :: BOX) |

1162 | (k1 :: BOX) |

1163 | (s :: k1 -> k) |

1164 | (a :: k1). |

1165 | (Typeable (k1 -> k) s, Typeable k1 a) => |

1166 | Typeable k (s a) |

1167 | newWantedEvVar/cache miss |

1168 | [W] $dTypeable_aGz :: Typeable (* -> *) [] |

1169 | newWantedEvVar/cache miss [W] $dTypeable_aGA :: Typeable * Char |

1170 | updSolvedSetTcs: [W] $dTypeable_aGx :: Typeable * [Char] |

1171 | doTopReact/found non-nullary instance for $dTypeable_aGx |

1172 | setEvBind |

1173 | ev = $dTypeable_aGx |

1174 | tm = Data.Typeable.Internal.$fTypeableks @[*, *, [], Char] |

1175 | [$dTypeable_aGz, $dTypeable_aGA] |

1176 | end stage top-level reactions } |

1177 | End solver pipeline (discharged) } |

1178 | inerts = Equalities: |

1179 | Type-function equalities: |

1180 | Dictionaries: |

1181 | Irreds: |

1182 | Insolubles = {} |

1183 | Solved dicts 3 |

1184 | Solved funeqs 0 |

1185 | Start solver pipeline { |

1186 | work item = [W] $dTypeable_aGz :: Typeable |

1187 | (* -> *) [] (CNonCanonical) |

1188 | inerts = Equalities: |

1189 | Type-function equalities: |

1190 | Dictionaries: |

1191 | Irreds: |

1192 | Insolubles = {} |

1193 | Solved dicts 3 |

1194 | Solved funeqs 0 |

1195 | runStage canonicalization { |

1196 | workitem = [W] $dTypeable_aGz :: Typeable |

1197 | (* -> *) [] (CNonCanonical) |

1198 | canonicalize (non-canonical) |

1199 | [W] $dTypeable_aGz :: Typeable (* -> *) [] (CNonCanonical) |

1200 | canEvNC:cls Typeable [* -> *, []] |

1201 | canClass |

1202 | [W] $dTypeable_aGz :: Typeable (* -> *) [] Typeable [* -> *, []] |

1203 | Typeable (* -> *) [] |

1204 | Just [W] $dTypeable_aGz :: Typeable (* -> *) [] |

1205 | end stage canonicalization } |

1206 | runStage spontaneous solve { |

1207 | workitem = [W] $dTypeable_aGz :: Typeable (* -> *) [] (CDictCan) |

1208 | Spont: no tyvar on lhs |

1209 | [W] $dTypeable_aGz :: Typeable (* -> *) [] (CDictCan) |

1210 | end stage spontaneous solve } |

1211 | runStage interact with inerts { |

1212 | workitem = [W] $dTypeable_aGz :: Typeable (* -> *) [] (CDictCan) |

1213 | interactWithInerts |

1214 | workitem = [W] $dTypeable_aGz :: Typeable (* -> *) [] (CDictCan) |

1215 | relevant inerts are: {} |

1216 | end stage interact with inerts } |

1217 | runStage top-level reactions { |

1218 | workitem = [W] $dTypeable_aGz :: Typeable (* -> *) [] (CDictCan) |

1219 | doTopReact [W] $dTypeable_aGz :: Typeable (* -> *) [] (CDictCan) |

1220 | matchClassInst |

1221 | pred = Typeable (* -> *) [] |

1222 | inerts= Equalities: |

1223 | Type-function equalities: |

1224 | Dictionaries: |

1225 | Irreds: |

1226 | Insolubles = {} |

1227 | Solved dicts 3 |

1228 | Solved funeqs 0 |

1229 | untouchables= 0 |

1230 | matchClass success |

1231 | dict Typeable (* -> *) [] |

1232 | witness Data.Typeable.Internal.$fTypeable[] Typeable (* -> *) [] |

1233 | updSolvedSetTcs: [W] $dTypeable_aGz :: Typeable (* -> *) [] |

1234 | doTopReact/found nullary instance for $dTypeable_aGz |

1235 | setEvBind |

1236 | ev = $dTypeable_aGz |

1237 | tm = Data.Typeable.Internal.$fTypeable[] @[] [] |

1238 | end stage top-level reactions } |

1239 | End solver pipeline (discharged) } |

1240 | inerts = Equalities: |

1241 | Type-function equalities: |

1242 | Dictionaries: |

1243 | Irreds: |

1244 | Insolubles = {} |

1245 | Solved dicts 4 |

1246 | Solved funeqs 0 |

1247 | Start solver pipeline { |

1248 | work item = [W] $dTypeable_aGA :: Typeable * Char (CNonCanonical) |

1249 | inerts = Equalities: |

1250 | Type-function equalities: |

1251 | Dictionaries: |

1252 | Irreds: |

1253 | Insolubles = {} |

1254 | Solved dicts 4 |

1255 | Solved funeqs 0 |

1256 | runStage canonicalization { |

1257 | workitem = [W] $dTypeable_aGA :: Typeable * Char (CNonCanonical) |

1258 | canonicalize (non-canonical) |

1259 | [W] $dTypeable_aGA :: Typeable * Char (CNonCanonical) |

1260 | canEvNC:cls Typeable [*, Char] |

1261 | canClass |

1262 | [W] $dTypeable_aGA :: Typeable * Char Typeable [*, Char] |

1263 | Typeable * Char |

1264 | Just [W] $dTypeable_aGA :: Typeable * Char |

1265 | end stage canonicalization } |

1266 | runStage spontaneous solve { |

1267 | workitem = [W] $dTypeable_aGA :: Typeable * Char (CDictCan) |

1268 | Spont: no tyvar on lhs |

1269 | [W] $dTypeable_aGA :: Typeable * Char (CDictCan) |

1270 | end stage spontaneous solve } |

1271 | runStage interact with inerts { |

1272 | workitem = [W] $dTypeable_aGA :: Typeable * Char (CDictCan) |

1273 | interactWithInerts |

1274 | workitem = [W] $dTypeable_aGA :: Typeable * Char (CDictCan) |

1275 | relevant inerts are: {} |

1276 | end stage interact with inerts } |

1277 | runStage top-level reactions { |

1278 | workitem = [W] $dTypeable_aGA :: Typeable * Char (CDictCan) |

1279 | doTopReact [W] $dTypeable_aGA :: Typeable * Char (CDictCan) |

1280 | matchClassInst |

1281 | pred = Typeable * Char |

1282 | inerts= Equalities: |

1283 | Type-function equalities: |

1284 | Dictionaries: |

1285 | Irreds: |

1286 | Insolubles = {} |

1287 | Solved dicts 4 |

1288 | Solved funeqs 0 |

1289 | untouchables= 0 |

1290 | matchClass success |

1291 | dict Typeable * Char |

1292 | witness Data.Typeable.Internal.$fTypeableChar Typeable * Char |

1293 | updSolvedSetTcs: [W] $dTypeable_aGA :: Typeable * Char |

1294 | doTopReact/found nullary instance for $dTypeable_aGA |

1295 | setEvBind |

1296 | ev = $dTypeable_aGA |

1297 | tm = Data.Typeable.Internal.$fTypeableChar @[] [] |

1298 | end stage top-level reactions } |

1299 | End solver pipeline (discharged) } |

1300 | inerts = Equalities: |

1301 | Type-function equalities: |

1302 | Dictionaries: |

1303 | Irreds: |

1304 | Insolubles = {} |

1305 | Solved dicts 5 |

1306 | Solved funeqs 0 |

1307 | Start solver pipeline { |

1308 | work item = [W] $dData_aGy :: Data Char (CNonCanonical) |

1309 | inerts = Equalities: |

1310 | Type-function equalities: |

1311 | Dictionaries: |

1312 | Irreds: |

1313 | Insolubles = {} |

1314 | Solved dicts 5 |

1315 | Solved funeqs 0 |

1316 | runStage canonicalization { |

1317 | workitem = [W] $dData_aGy :: Data Char (CNonCanonical) |

1318 | canonicalize (non-canonical) |

1319 | [W] $dData_aGy :: Data Char (CNonCanonical) |

1320 | canEvNC:cls Data [Char] |

1321 | canClass |

1322 | [W] $dData_aGy :: Data Char Data [Char] |

1323 | Data Char |

1324 | Just [W] $dData_aGy :: Data Char |

1325 | end stage canonicalization } |

1326 | runStage spontaneous solve { |

1327 | workitem = [W] $dData_aGy :: Data Char (CDictCan) |

1328 | Spont: no tyvar on lhs [W] $dData_aGy :: Data Char (CDictCan) |

1329 | end stage spontaneous solve } |

1330 | runStage interact with inerts { |

1331 | workitem = [W] $dData_aGy :: Data Char (CDictCan) |

1332 | interactWithInerts |

1333 | workitem = [W] $dData_aGy :: Data Char (CDictCan) |

1334 | relevant inerts are: {} |

1335 | end stage interact with inerts } |

1336 | runStage top-level reactions { |

1337 | workitem = [W] $dData_aGy :: Data Char (CDictCan) |

1338 | doTopReact [W] $dData_aGy :: Data Char (CDictCan) |

1339 | matchClassInst |

1340 | pred = Data Char |

1341 | inerts= Equalities: |

1342 | Type-function equalities: |

1343 | Dictionaries: |

1344 | Irreds: |

1345 | Insolubles = {} |

1346 | Solved dicts 5 |

1347 | Solved funeqs 0 |

1348 | untouchables= 0 |

1349 | matchClass success |

1350 | dict Data Char |

1351 | witness Data.Data.$fDataChar Data Char |

1352 | updSolvedSetTcs: [W] $dData_aGy :: Data Char |

1353 | doTopReact/found nullary instance for $dData_aGy |

1354 | setEvBind |

1355 | ev = $dData_aGy |

1356 | tm = Data.Data.$fDataChar @[] [] |

1357 | end stage top-level reactions } |

1358 | End solver pipeline (discharged) } |

1359 | inerts = Equalities: |

1360 | Type-function equalities: |

1361 | Dictionaries: |

1362 | Irreds: |

1363 | Insolubles = {} |

1364 | Solved dicts 6 |

1365 | Solved funeqs 0 |

1366 | Start solver pipeline { |

1367 | work item = [W] $dData_aGq :: Data String (CNonCanonical) |

1368 | inerts = Equalities: |

1369 | Type-function equalities: |

1370 | Dictionaries: |

1371 | Irreds: |

1372 | Insolubles = {} |

1373 | Solved dicts 6 |

1374 | Solved funeqs 0 |

1375 | runStage canonicalization { |

1376 | workitem = [W] $dData_aGq :: Data String (CNonCanonical) |

1377 | canonicalize (non-canonical) |

1378 | [W] $dData_aGq :: Data String (CNonCanonical) |

1379 | canEvNC:cls Data [String] |

1380 | canClass |

1381 | [W] $dData_aGq :: Data String Data [String] |

1382 | Data String |

1383 | Just [W] $dData_aGq :: Data String |

1384 | end stage canonicalization } |

1385 | runStage spontaneous solve { |

1386 | workitem = [W] $dData_aGq :: Data String (CDictCan) |

1387 | Spont: no tyvar on lhs [W] $dData_aGq :: Data String (CDictCan) |

1388 | end stage spontaneous solve } |

1389 | runStage interact with inerts { |

1390 | workitem = [W] $dData_aGq :: Data String (CDictCan) |

1391 | interactWithInerts |

1392 | workitem = [W] $dData_aGq :: Data String (CDictCan) |

1393 | relevant inerts are: {} |

1394 | end stage interact with inerts } |

1395 | runStage top-level reactions { |

1396 | workitem = [W] $dData_aGq :: Data String (CDictCan) |

1397 | doTopReact [W] $dData_aGq :: Data String (CDictCan) |

1398 | setEvBind |

1399 | ev = $dData_aGq |

1400 | tm = $dData_aGp |

1401 | end stage top-level reactions } |

1402 | End solver pipeline (discharged) } |

1403 | inerts = Equalities: |

1404 | Type-function equalities: |

1405 | Dictionaries: |

1406 | Irreds: |

1407 | Insolubles = {} |

1408 | Solved dicts 6 |

1409 | Solved funeqs 0 |

1410 | solveFlats end } {} |

1411 | solveWanteds } |

1412 | unsolved_flats = {} |

1413 | unsolved_implics = {} |

1414 | current evbinds = {$dTypeable_aGo |

1415 | = Type.Type.$fTypeableSrcSpan @[] [], |

1416 | $dData_aGp |

1417 | = Data.Data.$fData[] @[Char] [$dTypeable_aGx, $dData_aGy], |

1418 | $dData_aGq = $dData_aGp, |

1419 | $dTypeable_aGx |

1420 | = Data.Typeable.Internal.$fTypeableks @[*, *, [], Char] |

1421 | [$dTypeable_aGz, $dTypeable_aGA], |

1422 | $dData_aGy = Data.Data.$fDataChar @[] [], |

1423 | $dTypeable_aGz = Data.Typeable.Internal.$fTypeable[] @[] [], |

1424 | $dTypeable_aGA = Data.Typeable.Internal.$fTypeableChar @[] []} |

1425 | current tybinds = |

1426 | final wc = WC {} |

1427 | TcDeriv |

1428 | [Typeable * SrcSpan, Data String, Data String] |

1429 | [] |

1430 | simplifyDeriv |

1431 | e |

1432 | [Eq SrcSpan, Eq e] |

1433 | [[W] $dEq_aGC :: Eq SrcSpan (CNonCanonical), |

1434 | [W] $dEq_aGD :: Eq e (CNonCanonical)] |

1435 | deriving (Eq (Located e)) |

1436 | solveWantedsTcMWithEvBinds |

1437 | wanted= WC {wc_flat = [W] $dEq_aGC :: Eq SrcSpan (CNonCanonical) |

1438 | [W] $dEq_aGD :: Eq e (CNonCanonical)} |

1439 | solveWanteds { |

1440 | WC {wc_flat = [W] $dEq_aGC :: Eq SrcSpan (CNonCanonical) |

1441 | [W] $dEq_aGD :: Eq e (CNonCanonical)} |

1442 | solveFlats { |

1443 | Start solver pipeline { |

1444 | work item = [W] $dEq_aGC :: Eq SrcSpan (CNonCanonical) |

1445 | inerts = Equalities: |

1446 | Type-function equalities: |

1447 | Dictionaries: |

1448 | Irreds: |

1449 | Insolubles = {} |

1450 | Solved dicts 0 |

1451 | Solved funeqs 0 |

1452 | runStage canonicalization { |

1453 | workitem = [W] $dEq_aGC :: Eq SrcSpan (CNonCanonical) |

1454 | canonicalize (non-canonical) |

1455 | [W] $dEq_aGC :: Eq SrcSpan (CNonCanonical) |

1456 | canEvNC:cls Eq [SrcSpan] |

1457 | canClass |

1458 | [W] $dEq_aGC :: Eq SrcSpan Eq [SrcSpan] |

1459 | Eq SrcSpan |

1460 | Just [W] $dEq_aGC :: Eq SrcSpan |

1461 | end stage canonicalization } |

1462 | runStage spontaneous solve { |

1463 | workitem = [W] $dEq_aGC :: Eq SrcSpan (CDictCan) |

1464 | Spont: no tyvar on lhs [W] $dEq_aGC :: Eq SrcSpan (CDictCan) |

1465 | end stage spontaneous solve } |

1466 | runStage interact with inerts { |

1467 | workitem = [W] $dEq_aGC :: Eq SrcSpan (CDictCan) |

1468 | interactWithInerts |

1469 | workitem = [W] $dEq_aGC :: Eq SrcSpan (CDictCan) |

1470 | relevant inerts are: {} |

1471 | end stage interact with inerts } |

1472 | runStage top-level reactions { |

1473 | workitem = [W] $dEq_aGC :: Eq SrcSpan (CDictCan) |

1474 | doTopReact [W] $dEq_aGC :: Eq SrcSpan (CDictCan) |

1475 | matchClassInst |

1476 | pred = Eq SrcSpan |

1477 | inerts= Equalities: |

1478 | Type-function equalities: |

1479 | Dictionaries: |

1480 | Irreds: |

1481 | Insolubles = {} |

1482 | Solved dicts 0 |

1483 | Solved funeqs 0 |

1484 | untouchables= 0 |

1485 | matchClass success |

1486 | dict Eq SrcSpan |

1487 | witness Type.Type.$fEqSrcSpan Eq SrcSpan |

1488 | updSolvedSetTcs: [W] $dEq_aGC :: Eq SrcSpan |

1489 | doTopReact/found nullary instance for $dEq_aGC |

1490 | setEvBind |

1491 | ev = $dEq_aGC |

1492 | tm = Type.Type.$fEqSrcSpan @[] [] |

1493 | end stage top-level reactions } |

1494 | End solver pipeline (discharged) } |

1495 | inerts = Equalities: |

1496 | Type-function equalities: |

1497 | Dictionaries: |

1498 | Irreds: |

1499 | Insolubles = {} |

1500 | Solved dicts 1 |

1501 | Solved funeqs 0 |

1502 | Start solver pipeline { |

1503 | work item = [W] $dEq_aGD :: Eq e (CNonCanonical) |

1504 | inerts = Equalities: |

1505 | Type-function equalities: |

1506 | Dictionaries: |

1507 | Irreds: |

1508 | Insolubles = {} |

1509 | Solved dicts 1 |

1510 | Solved funeqs 0 |

1511 | runStage canonicalization { |

1512 | workitem = [W] $dEq_aGD :: Eq e (CNonCanonical) |

1513 | canonicalize (non-canonical) [W] $dEq_aGD :: Eq e (CNonCanonical) |

1514 | canEvNC:cls Eq [e] |

1515 | canClass |

1516 | [W] $dEq_aGD :: Eq e Eq [e] |

1517 | Eq e |

1518 | Just [W] $dEq_aGD :: Eq e |

1519 | newSCWork/Derived impr_theta = [] |

1520 | end stage canonicalization } |

1521 | runStage spontaneous solve { |

1522 | workitem = [W] $dEq_aGD :: Eq e (CDictCan) |

1523 | Spont: no tyvar on lhs [W] $dEq_aGD :: Eq e (CDictCan) |

1524 | end stage spontaneous solve } |

1525 | runStage interact with inerts { |

1526 | workitem = [W] $dEq_aGD :: Eq e (CDictCan) |

1527 | interactWithInerts workitem = [W] $dEq_aGD :: Eq e (CDictCan) |

1528 | relevant inerts are: {} |

1529 | end stage interact with inerts } |

1530 | runStage top-level reactions { |

1531 | workitem = [W] $dEq_aGD :: Eq e (CDictCan) |

1532 | doTopReact [W] $dEq_aGD :: Eq e (CDictCan) |

1533 | matchClassInst |

1534 | pred = Eq e |

1535 | inerts= Equalities: |

1536 | Type-function equalities: |

1537 | Dictionaries: |

1538 | Irreds: |

1539 | Insolubles = {} |

1540 | Solved dicts 1 |

1541 | Solved funeqs 0 |

1542 | untouchables= 0 |