2b526d3 · elk · git.iko.soy

20

21

22import Prelude hiding (round)

23+import qualified Data.Map as Map

23import Data.Monoid ((<>))

24import Data.Monoid ((<>))

24

25

26+import qualified AST.Canonical as Can

25import qualified Data.Index as Index

27import qualified Data.Index as Index

26import qualified Elm.Name as N

28import qualified Elm.Name as N

27import qualified Reporting.Doc as D

29import qualified Reporting.Doc as D

63 | CaseBranch Index.ZeroBased

65 | CaseBranch Index.ZeroBased

64 | CallArity MaybeName Int

66 | CallArity MaybeName Int

65 | CallArg MaybeName Index.ZeroBased

67 | CallArg MaybeName Index.ZeroBased

66− | TooManyArgs MaybeName Int

67 | RecordAccess N.Name

68 | RecordAccess N.Name

68− | RecordUpdate

69+ | RecordUpdate N.Name (Map.Map N.Name Can.Expr)

69 | Destructure

70 | Destructure

70

71

72

185 case expected of

186 case expected of

186 PNoExpectation expectedType ->

187 PNoExpectation expectedType ->

187 Report.toCodeSnippet source patternRegion Nothing $

188 Report.toCodeSnippet source patternRegion Nothing $

188− (

189− "This pattern is being used in an unexpected way:"

189+ ( "This pattern is being used in an unexpected way:"

190− ,

191− patternTypeComparison localizer tipe expectedType

190+ , patternTypeComparison localizer tipe expectedType

192− (

191+ (addPatternCategory "It is" category)

193− toPatternDescription category "It is"

194− ,

195− "But it needs to match values of type:"

192+ (singular "But it needs to match")

196− ,

197− []

193+ []

198− )

199 )

194 )

200

195

201 PFromContext region context expectedType ->

196 PFromContext region context expectedType ->

202 Report.toCodeSnippet source region (Just patternRegion) $

197 Report.toCodeSnippet source region (Just patternRegion) $

203 case context of

198 case context of

204 PTypedArg name index ->

199 PTypedArg name index ->

205− (

206− D.reflow $

200+ ( D.reflow $

207− "The " <> D.ordinalize (Index.toHuman index) <> " argument to `" <> N.toString name <> "` is weird."

201+ "The " <> D.ordinal index <> " argument to `" <> N.toString name <> "` is weird."

208− ,

209− patternTypeComparison localizer tipe expectedType

202+ , patternTypeComparison localizer tipe expectedType

210− (

211− toPatternDescription category $

212− "The argument is a pattern that matches"

203+ (addPatternCategory "The argument is a pattern that matches" category)

213− ,

204+ (singular $

214− "But the type annotation on `" <> N.toString name <> "` says the " <> D.ordinalize (Index.toHuman index) <> " argument should be:"

205+ "But the type annotation on `" <> N.toString name

215− ,

206+ <> "` says the " <> D.ordinal index <> " argument should be"

216− []

217 )

207 )

208+ []

218 )

209 )

219

210

220 PCaseMatch index ->

211 PCaseMatch index ->

224 "The 1st pattern in this `case` causing a mismatch:"

215 "The 1st pattern in this `case` causing a mismatch:"

225 ,

216 ,

226 patternTypeComparison localizer tipe expectedType

217 patternTypeComparison localizer tipe expectedType

227− (

228− toPatternDescription category "The first pattern is trying to match"

218+ (addPatternCategory "The first pattern is trying to match" category)

229− ,

219+ (singular "But the expression between `case` and `of` is")

230− "But it is supposed to match an expression of type:"

231− ,

232− [ D.reflow $

220+ [ D.reflow $

233− "Is the pattern the problem? Or is it the expression you are trying to match on?"

221+ "These can never match! Is the pattern the problem? Or is it the expression?"

234− ]

222+ ]

235− )

236 )

223 )

237 else

224 else

238− (

239− D.reflow $

225+ ( D.reflow $

240− "The " <> D.ordinalize (Index.toHuman index) <> " pattern in this `case` does not match the previous ones."

226+ "The " <> D.ordinal index <> " pattern in this `case` does not match the previous ones."

241− ,

242− patternTypeComparison localizer tipe expectedType

227+ , patternTypeComparison localizer tipe expectedType

243− (

244− toPatternDescription category $

245− "The " <> D.ordinalize (Index.toHuman index) <> " pattern is trying to match"

228+ (addPatternCategory ("The " <> D.ordinal index <> " pattern is trying to match") category)

246− ,

247− "But all the previous patterns match values of type:"

229+ (plural "But all the previous patterns match")

248− ,

230+ [ D.link "Note"

231+ "A `case` expression can only handle one type of value, so you may want to use"

232+ "union-types"

233+ "to handle “mixing” types."

249− []

234+ ]

250− )

251 )

235 )

252

236

253 PCtorArg name index ->

237 PCtorArg name index ->

254− (

255− D.reflow $

238+ ( D.reflow $

256− "The " <> D.ordinalize (Index.toHuman index) <> " argument to `" <> N.toString name <> "` is weird."

239+ "The " <> D.ordinal index <> " argument to `" <> N.toString name <> "` is weird."

257− ,

258− patternTypeComparison localizer tipe expectedType

240+ , patternTypeComparison localizer tipe expectedType

259− (

241+ (addPatternCategory "It is trying to match" category)

260− toPatternDescription category "It is trying to match"

242+ (singular $

261− ,

262− "But `" <> N.toString name <> "` needs its " <> D.ordinalize (Index.toHuman index) <> " argument to be:"

243+ "But `" <> N.toString name <> "` needs its "

263− ,

244+ <> D.ordinal index <> " argument to be"

264− []

265 )

245 )

246+ []

266 )

247 )

267

248

268 PListEntry index ->

249 PListEntry index ->

269− (

270− D.reflow $

250+ ( D.reflow $

271− "The " <> D.ordinalize (Index.toHuman index) <> " pattern in this list does not match all the previous ones:"

251+ "The " <> D.ordinal index <> " pattern in this list does not match all the previous ones:"

272− ,

273− patternTypeComparison localizer tipe expectedType

252+ , patternTypeComparison localizer tipe expectedType

274− (

275− toPatternDescription category $

276− "The " <> D.ordinalize (Index.toHuman index) <> " pattern is trying to match"

253+ (addPatternCategory ("The " <> D.ordinal index <> " pattern is trying to match") category)

277− ,

278− "But all the previous patterns in the list are:"

254+ (plural "But all the previous patterns in the list are")

279− ,

280− [ D.toSimpleHint $

255+ [ D.toSimpleHint $

281− "Everything in the list needs to be the same type of value.\

256+ "Everything in the list needs to be the same type of value.\

282− \ This way you never run into unexpected values partway through.\

257+ \ This way you never run into unexpected values partway through.\

283− \ To mix different types in a single list, create a \"union type\" as\

258+ \ To mix different types in a single list, create a \"union type\" as\

284− \ described in: <http://guide.elm-lang.org/types/union_types.html>"

259+ \ described in: <http://guide.elm-lang.org/types/union_types.html>"

285− ]

260+ ]

286− )

287 )

261 )

288

262

289 PTail ->

263 PTail ->

290− (

291− D.reflow $

264+ ( D.reflow $

292 "The pattern after (::) is causing issues."

265 "The pattern after (::) is causing issues."

293− ,

294− patternTypeComparison localizer tipe expectedType

266+ , patternTypeComparison localizer tipe expectedType

295− (

296− toPatternDescription category $

297− "The pattern after (::) is trying to match"

267+ (addPatternCategory "The pattern after (::) is trying to match" category)

298− ,

299− "But it needs to match lists like this:"

268+ (\_ -> "But it needs to match lists like this:")

300− ,

301− []

269+ []

302− )

303 )

270 )

304

271

305

272

307-- PATTERN HELPERS

274-- PATTERN HELPERS

308

275

309

276

310−patternTypeComparison :: L.Localizer -> T.Type -> T.Type -> ( String, String, [D.Doc] ) -> D.Doc

277+patternTypeComparison

278+ :: L.Localizer

279+ -> T.Type

280+ -> T.Type

281+ -> (Maybe N.Name -> D.Doc)

282+ -> (Maybe N.Name -> D.Doc)

283+ -> [D.Doc]

284+ -> D.Doc

311−patternTypeComparison localizer actual expected ( iAmSeeing, insteadOf, contextHints ) =

285+patternTypeComparison localizer actual expected iAmSeeing insteadOf contextHints =

312 let

286 let

313− (actualDoc, expectedDoc, problems) =

287+ (T.Comparison actualAlias actualDoc expectedAlias expectedDoc problems) =

314− T.toDiffDocs localizer actual expected

288+ T.toComparison localizer actual expected

315 in

289 in

316 D.stack $

290 D.stack $

317− [ D.reflow iAmSeeing

291+ [ iAmSeeing actualAlias

318 , D.indent 4 actualDoc

292 , D.indent 4 actualDoc

319− , D.reflow insteadOf

293+ , insteadOf expectedAlias

320 , D.indent 4 expectedDoc

294 , D.indent 4 expectedDoc

321 ]

295 ]

322 ++ problemsToHint problems

296 ++ problemsToHint problems

323 ++ contextHints

297 ++ contextHints

324

298

325

299

326−toPatternDescription :: PCategory -> String -> String

300+addPatternCategory :: String -> PCategory -> Maybe N.Name -> D.Doc

327−toPatternDescription category iAmTryingToMatch =

301+addPatternCategory iAmTryingToMatch category maybeAlias =

328− iAmTryingToMatch <>

302+ D.reflow $ iAmTryingToMatch <>

303+ case maybeAlias of

304+ Just alias ->

305+ " `" <> N.toString alias <> "` values:"

306+

307+ Nothing ->

329− case category of

308+ case category of

330− PRecord -> " record values of type:"

309+ PRecord -> " record values of type:"

331− PUnit -> " unit values:"

310+ PUnit -> " unit values:"

332− PTuple -> " tuples of type:"

311+ PTuple -> " tuples of type:"

333− PList -> " lists of type:"

312+ PList -> " lists of type:"

334− PCtor name -> " `" <> N.toString name <> "` values of type:"

313+ PCtor name -> " `" <> N.toString name <> "` values of type:"

335− PInt -> " integers:"

314+ PInt -> " integers:"

336− PStr -> " strings:"

315+ PStr -> " strings:"

337− PChr -> " characters:"

316+ PChr -> " characters:"

338

317

339

318

340

319

341-- EXPR HELPERS

320-- EXPR HELPERS

342

321

343

322

344−typeComparison :: L.Localizer -> T.Type -> T.Type -> ( String, String, [D.Doc] ) -> D.Doc

323+typeComparison

324+ :: L.Localizer

325+ -> T.Type

326+ -> T.Type

327+ -> (Maybe N.Name -> D.Doc)

328+ -> (Maybe N.Name -> D.Doc)

329+ -> [D.Doc]

330+ -> D.Doc

345−typeComparison localizer actual expected ( iAmSeeing, insteadOf, contextHints ) =

331+typeComparison localizer actual expected iAmSeeing insteadOf contextHints =

346 let

332 let

347− (actualDoc, expectedDoc, problems) =

333+ (T.Comparison actualAlias actualDoc expectedAlias expectedDoc problems) =

348− T.toDiffDocs localizer actual expected

334+ T.toComparison localizer actual expected

349 in

335 in

350 D.stack $

336 D.stack $

351− [ D.reflow iAmSeeing

337+ [ iAmSeeing actualAlias

352 , D.indent 4 actualDoc

338 , D.indent 4 actualDoc

353− , D.reflow insteadOf

339+ , insteadOf expectedAlias

354 , D.indent 4 expectedDoc

340 , D.indent 4 expectedDoc

355 ]

341 ]

356 ++ problemsToHint problems

342 ++ problemsToHint problems

357 ++ contextHints

343 ++ contextHints

358

344

359

345

346+loneType

360−loneType :: L.Localizer -> T.Type -> T.Type -> ( D.Doc, [D.Doc] ) -> D.Doc

347+ :: L.Localizer

348+ -> T.Type

349+ -> T.Type

350+ -> (Maybe N.Name -> D.Doc)

351+ -> [D.Doc]

352+ -> D.Doc

361−loneType localizer actual expected ( iAmSeeing, furtherDetails ) =

353+loneType localizer actual expected iAmSeeing furtherDetails =

362 let

354 let

363− (actualDoc, _, problems) =

355+ (T.Comparison actualAlias actualDoc _ _ problems) =

364− T.toDiffDocs localizer actual expected

356+ T.toComparison localizer actual expected

365 in

357 in

366 D.stack $

358 D.stack $

367− [ iAmSeeing

359+ [ iAmSeeing actualAlias

368 , D.indent 4 actualDoc

360 , D.indent 4 actualDoc

369 ]

361 ]

370 ++ furtherDetails

362 ++ furtherDetails

371 ++ problemsToHint problems

363 ++ problemsToHint problems

372

364

373

365

374−toDescription :: Category -> String -> String

366+singular :: String -> Maybe N.Name -> D.Doc

375−toDescription category thatThingIs =

367+singular insteadOf maybeAlias =

368+ D.reflow $ insteadOf <>

369+ case maybeAlias of

370+ Nothing -> ":"

371+ Just a -> " a `" <> N.toString a <> "` value:"

372+

373+

374+plural :: String -> Maybe N.Name -> D.Doc

375+plural insteadOf maybeAlias =

376+ D.reflow $ insteadOf <>

377+ case maybeAlias of

378+ Nothing -> ":"

379+ Just a -> " `" <> N.toString a <> "` values:"

380+

381+

382+addCategory :: String -> Category -> Maybe N.Name -> D.Doc

383+addCategory thisIs category maybeAlias =

384+ let

385+ definitely whatever =

386+ case maybeAlias of

387+ Just alias -> " a `" <> N.toString alias <> "` value:"

388+ Nothing -> whatever

389+ in

390+ D.reflow $

376 case category of

391 case category of

377− Local name -> "This `" <> N.toString name <> "` value has type:"

392+ Local name -> "This `" <> N.toString name <> "` value is" <> definitely " a:"

378− Foreign name -> "This `" <> N.toString name <> "` value has type:"

393+ Foreign name -> "This `" <> N.toString name <> "` value is" <> definitely " a:"

379− Access field -> "The value at ." <> N.toString field <> " has type:"

394+ Access field -> "The value at ." <> N.toString field <> " is" <> definitely " a:"

380 Accessor field -> "This ." <> N.toString field <> " field access function has type:"

395 Accessor field -> "This ." <> N.toString field <> " field access function has type:"

381− If -> "This `if` expression produces a value of type:"

396+ If -> "This `if` expression produces" <> definitely ":"

382− Case -> "This `case` expression produces a value of type:"

397+ Case -> "This `case` expression produces" <> definitely ":"

383− List -> thatThingIs <> " a list of type:"

398+ List -> thisIs <> definitely " a list of type:"

384− Number -> thatThingIs <> " a number of type:"

399+ Number -> thisIs <> definitely " a number of type:"

385− Float -> thatThingIs <> " a float of type:"

400+ Float -> thisIs <> definitely " a float of type:"

386− String -> thatThingIs <> " a string of type:"

401+ String -> thisIs <> definitely " a string of type:"

387− Char -> thatThingIs <> " a character of type:"

402+ Char -> thisIs <> definitely " a character of type:"

388− Lambda -> thatThingIs <> " an anonymous function of type:"

403+ Lambda -> thisIs <> definitely " an anonymous function of type:"

389− Record -> thatThingIs <> " a record of type:"

404+ Record -> thisIs <> definitely " a record of type:"

390− Tuple -> thatThingIs <> " a tuple of type:"

405+ Tuple -> thisIs <> definitely " a tuple of type:"

391− Unit -> thatThingIs <> " a unit value:"

406+ Unit -> thisIs <> definitely " a unit value:"

392− Shader -> thatThingIs <> " a GLSL shader of type:"

407+ Shader -> thisIs <> definitely " a GLSL shader of type:"

393− Effects -> thatThingIs <> " a thing for CORE LIBRARIES ONLY."

408+ Effects -> thisIs <> " a thing for CORE LIBRARIES ONLY."

394 CallResult maybeName ->

409 CallResult maybeName ->

395 case maybeName of

410 case maybeName of

396− NoName -> thatThingIs <> ":"

411+ NoName -> thisIs <> ":"

397− FuncName name -> "This `" <> N.toString name <> "` call produces:"

412+ FuncName name -> "This `" <> N.toString name <> "` call produces" <> definitely ":"

398− CtorName name -> "This `" <> N.toString name <> "` call produces:"

413+ CtorName name -> "This `" <> N.toString name <> "` call produces" <> definitely ":"

399− OpName _ -> thatThingIs <> ":"

414+ OpName _ -> thisIs <> definitely ":"

400

415

401

416

402problemsToHint :: [T.Problem] -> [D.Doc]

417problemsToHint :: [T.Problem] -> [D.Doc]

637

652

638toExprReport :: Code.Source -> L.Localizer -> R.Region -> Category -> T.Type -> Expected T.Type -> Report.Report

653toExprReport :: Code.Source -> L.Localizer -> R.Region -> Category -> T.Type -> Expected T.Type -> Report.Report

639toExprReport source localizer exprRegion category tipe expected =

654toExprReport source localizer exprRegion category tipe expected =

640− Report.Report "TYPE MISMATCH" exprRegion [] $

641 case expected of

655 case expected of

642 NoExpectation expectedType ->

656 NoExpectation expectedType ->

657+ Report.Report "TYPE MISMATCH" exprRegion [] $

643− Report.toCodeSnippet source exprRegion Nothing

658+ Report.toCodeSnippet source exprRegion Nothing

644− (

645− "This expression is being used in an unexpected way:"

659+ ( "This expression is being used in an unexpected way:"

646− ,

647− typeComparison localizer tipe expectedType

660+ , typeComparison localizer tipe expectedType

648− (

661+ (addCategory "It is" category)

649− toDescription category "It is"

650− ,

651− "But you are trying to use it as:"

662+ (singular "But you are trying to use it as")

652− ,

653 []

663 []

654− )

655− )

664+ )

656

665

657 FromAnnotation name _arity subContext expectedType ->

666 FromAnnotation name _arity subContext expectedType ->

667+ let

668+ thing =

669+ case subContext of

670+ TypedIfBranch index -> D.ordinal index <> " branch of this `if` expression:"

671+ TypedCaseBranch index -> D.ordinal index <> " branch of this `case` expression:"

672+ TypedBody -> "body of the `" <> N.toString name <> "` definition:"

673+

674+ itIs =

675+ case subContext of

676+ TypedIfBranch index -> "The " <> D.ordinal index <> " branch is"

677+ TypedCaseBranch index -> "The " <> D.ordinal index <> " branch is"

678+ TypedBody -> "The body is"

679+ in

680+ Report.Report "TYPE MISMATCH" exprRegion [] $

658− Report.toCodeSnippet source exprRegion Nothing

681+ Report.toCodeSnippet source exprRegion Nothing $

659− (

682+ ( D.reflow ("Something is off with the " <> thing)

660− D.reflow $

661− case subContext of

662− TypedIfBranch index ->

663− "Something is off with the " <> D.ordinalize (Index.toHuman index) <> " branch of this `if` expression:"

664−

665− TypedCaseBranch index ->

666− "Something is off with the " <> D.ordinalize (Index.toHuman index) <> " branch of this `case` expression:"

667−

668− TypedBody ->

669− "Something is off with the body of the `" <> N.toString name <> "` definition:"

670− ,

671− typeComparison localizer tipe expectedType

683+ , typeComparison localizer tipe expectedType

672− (

684+ (addCategory itIs category)

673− toDescription category $

674− case subContext of

675− TypedIfBranch index ->

676− "The " <> D.ordinalize (Index.toHuman index) <> " branch is"

677−

678− TypedCaseBranch index ->

679− "The " <> D.ordinalize (Index.toHuman index) <> " branch is"

680−

681− TypedBody ->

682− "The body is"

683− ,

684− "But the type annotation on `" <> N.toString name <> "` says it should be:"

685+ (singular $ "But the type annotation on `" <> N.toString name <> "` says it should be")

685− ,

686 []

687− )

688− )

687+ )

689

688

690 FromContext region context expectedType ->

689 FromContext region context expectedType ->

690+ let

691+ mismatch (maybeHighlight, problem, thisIs, insteadOf, furtherDetails) =

692+ Report.Report "TYPE MISMATCH" exprRegion [] $

693+ Report.toCodeSnippet source region maybeHighlight

694+ ( D.reflow problem

695+ , typeComparison localizer tipe expectedType (addCategory thisIs category) insteadOf furtherDetails

696+ )

697+

698+ badType (maybeHighlight, problem, thisIs, furtherDetails) =

699+ Report.Report "TYPE MISMATCH" exprRegion [] $

700+ Report.toCodeSnippet source region maybeHighlight

701+ ( D.reflow problem

702+ , loneType localizer tipe expectedType (addCategory thisIs category) furtherDetails

703+ )

704+ in

691 case context of

705 case context of

692 ListEntry index ->

706 ListEntry index ->

707+ let ith = D.ordinal index in

708+ mismatch

693− Report.toCodeSnippet source region (Just exprRegion)

709+ ( Just exprRegion

694− (

695− D.reflow $

696− "The " <> D.ordinalize (Index.toHuman index) <> " element of this list does not match all the previous elements:"

710+ , "The " <> ith <> " element of this list does not match all the previous elements:"

697− ,

698− typeComparison localizer tipe expectedType

699− (

700− toDescription category $

701− "The " <> D.ordinalize (Index.toHuman index) <> " element is"

711+ , "The " <> ith <> " element is"

702− ,

703− "But all the previous elements in the list are:"

712+ , plural "But all the previous elements in the list are"

704− ,

705− [ D.toSimpleHint $

713+ , [ D.toSimpleHint $

706− "Everything in the list needs to be the same type of value.\

714+ "Everything in the list needs to be the same type of value.\

707− \ This way you never run into unexpected values partway through.\

715+ \ This way you never run into unexpected values partway through.\

708− \ To mix different types in a single list, create a \"union type\" as\

716+ \ To mix different types in a single list, create a \"union type\" as\

709− \ described in: <http://guide.elm-lang.org/types/union_types.html>"

717+ \ described in: <http://guide.elm-lang.org/types/union_types.html>"

710− ]

718+ ]

711− )

712− )

719+ )

713

720

714 Negate ->

721 Negate ->

722+ badType

715− Report.toCodeSnippet source region (Just exprRegion)

723+ ( Just exprRegion

716− (

717− "I do not know how to negate this type of value:"

724+ , "I do not know how to negate this type of value:"

718− ,

725+ , "It is"

719− loneType localizer tipe expectedType

720− (

721− D.reflow $ toDescription category "It is"

722− ,

723− [ D.fillSep

726+ , [ D.fillSep

724− ["But","I","only","now","how","to","negate"

727+ ["But","I","only","now","how","to","negate"

725− ,D.dullyellow "Int","and",D.dullyellow "Float","values."

728+ ,D.dullyellow "Int","and",D.dullyellow "Float","values."

726− ]

729+ ]

727− ]

730+ ]

728− )

729− )

731+ )

730

732

731 OpLeft op ->

733 OpLeft op ->

734+ Report.Report "TYPE MISMATCH" exprRegion [] $

732− Report.toCodeSnippet source region (Just exprRegion) $

735+ Report.toCodeSnippet source region (Just exprRegion) $

733− opLeftToDocs localizer category op tipe expectedType

736+ opLeftToDocs localizer category op tipe expectedType

734

737

735 OpRight op ->

738 OpRight op ->

739+ Report.Report "TYPE MISMATCH" exprRegion [] $

736− case opRightToDocs localizer category op tipe expectedType of

740+ case opRightToDocs localizer category op tipe expectedType of

737− EmphBoth details ->

741+ EmphBoth details ->

738− Report.toCodeSnippet source region Nothing details

742+ Report.toCodeSnippet source region Nothing details

739

743

740− EmphRight details ->

744+ EmphRight details ->

741− Report.toCodeSnippet source region (Just exprRegion) details

745+ Report.toCodeSnippet source region (Just exprRegion) details

742

746

743 IfCondition ->

747 IfCondition ->

748+ badType

744− Report.toCodeSnippet source region (Just exprRegion)

749+ ( Just exprRegion

745− (

746− "This `if` condition does not evaluate to a boolean value, True or False."

750+ , "This `if` condition does not evaluate to a boolean value, True or False."

747− ,

751+ , "It is"

748− loneType localizer tipe expectedType

749− (

750− D.reflow $ toDescription category "It is"

751− ,

752− [ D.fillSep ["But","I","need","this","`if`","condition","to","be","a",D.dullyellow "Bool","value."]

752+ , [ D.fillSep ["But","I","need","this","`if`","condition","to","be","a",D.dullyellow "Bool","value."]

753− ]

753+ ]

754− )

755− )

754+ )

756

755

757 IfBranch index ->

756 IfBranch index ->

757+ let ith = D.ordinal index in

758+ mismatch

758− Report.toCodeSnippet source region (Just exprRegion)

759+ ( Just exprRegion

759− (

760− D.reflow $

761− "The " <> D.ordinalize (Index.toHuman index) <> " branch of this `if` does not match all the previous branches:"

760+ , "The " <> ith <> " branch of this `if` does not match all the previous branches:"

762− ,

763− typeComparison localizer tipe expectedType

764− (

765− toDescription category $

766− "The " <> D.ordinalize (Index.toHuman index) <> " branch is"

761+ , "The " <> ith <> " branch is"

767− ,

768− "But all the previous branches result in:"

762+ , plural "But all the previous branches result in"

769− ,

770− [ D.link "Hint"

763+ , [ D.link "Hint"

771− "All branches in an `if` must produce the same type of values. This way, no\

764+ "All branches in an `if` must produce the same type of values. This way, no\

772− \ matter which branch we take, the result is always a consistent shape. Read"

765+ \ matter which branch we take, the result is always a consistent shape. Read"

773− "union-types"

766+ "union-types"

774− "to learn how to “mix” types."

767+ "to learn how to “mix” types."

775− ]

768+ ]

776− )

777− )

769+ )

778

770

779 CaseBranch index ->

771 CaseBranch index ->

772+ let ith = D.ordinal index in

773+ mismatch

780− Report.toCodeSnippet source region (Just exprRegion)

774+ ( Just exprRegion

781− (

782− D.reflow $

783− "The " <> D.ordinalize (Index.toHuman index) <> " branch of this `case` does not match all the previous branches:"

775+ , "The " <> ith <> " branch of this `case` does not match all the previous branches:"

784− ,

785− typeComparison localizer tipe expectedType

786− (

787− toDescription category $

788− "The " <> D.ordinalize (Index.toHuman index) <> " branch is"

776+ , "The " <> ith <> " branch is"

789− ,

790− "But all the previous branches result in:"

777+ , plural "But all the previous branches result in"

791− ,

792− [ D.link "Hint"

778+ , [ D.link "Hint"

793− "All branches in a `case` must produce the same type of values. This way, no\

779+ "All branches in a `case` must produce the same type of values. This way, no\

794− \ matter which branch we take, the result is always a consistent shape. Read"

780+ \ matter which branch we take, the result is always a consistent shape. Read"

795− "union-types"

781+ "union-types"

796− "to learn how to “mix” types."

782+ "to learn how to “mix” types."

797− ]

783+ ]

798− )

799− )

784+ )

800

785

801− CallArity maybeFuncName numArgs ->

786+ CallArity maybeFuncName numGivenArgs ->

787+ Report.Report "TOO MANY ARGS" exprRegion [] $

788+ Report.toCodeSnippet source region (Just exprRegion) $

802 case countArgs tipe of

789 case countArgs tipe of

803 0 ->

790 0 ->

804− Report.toCodeSnippet source region (Just exprRegion)

791+ let

805− ( D.reflow $

792+ thisValue =

806− case maybeFuncName of

793+ case maybeFuncName of

807− NoName -> "This is not a function:"

794+ NoName -> "This value"

808− FuncName name -> "The `" <> N.toString name <> "` value is not a function:"

795+ FuncName name -> "The `" <> N.toString name <> "` value"

809− CtorName name -> "The `" <> N.toString name <> "` value is not a function:"

796+ CtorName name -> "The `" <> N.toString name <> "` value"

810− OpName op -> "The (" <> N.toString op <> ") operator is not a function:"

797+ OpName op -> "The (" <> N.toString op <> ") operator"

811− ,

798+ in

812− D.stack $

799+ ( D.reflow $ thisValue <> " is not a function, but it was given " <> D.args numGivenArgs <> "."

813− [ "It has type:"

800+ , D.reflow $ "Are there any missing commas? Or missing parentheses?"

814− , D.indent 4 $ D.dullyellow $ T.toDoc localizer RT.None tipe

815− , D.reflow $ "So it cannot accept arguments, but it got " <> show numArgs <> " anyway."

816− ]

817− )

801+ )

818

802

819 n ->

803 n ->

820− Report.toCodeSnippet source region (Just exprRegion)

804+ let

821− ( D.reflow $

805+ thisFunction =

822− case maybeFuncName of

806+ case maybeFuncName of

823− NoName -> "This function was given too many arguments:"

807+ NoName -> "This function"

824− FuncName name -> "The `" <> N.toString name <> "` function was given too many arguments:"

808+ FuncName name -> "The `" <> N.toString name <> "` function"

825− CtorName name -> "The `" <> N.toString name <> "` constructor was given too many arguments:"

809+ CtorName name -> "The `" <> N.toString name <> "` constructor"

826− OpName op -> "The (" <> N.toString op <> ") operator was given too many arguments:"

810+ OpName op -> "The (" <> N.toString op <> ") operator"

827− ,

811+ in

828− D.stack $

829− [ "It has type:"

830− , D.indent 4 $ D.dullyellow $ T.toDoc localizer RT.None tipe

831− , D.reflow $ "So it expects " <> D.args n <> ", but it got " <> show numArgs <> " instead."

812+ ( D.reflow $ thisFunction <> " expects " <> D.args n <> ", but it got " <> show numGivenArgs <> " instead."

832− ]

813+ , D.reflow $ "Are there any missing commas? Or missing parentheses?"

833− )

814+ )

834

815

835 CallArg maybeFuncName index ->

816 CallArg maybeFuncName index ->

836 let

817 let

818+ ith = D.ordinal index

819+

837 thisFunction =

820 thisFunction =

838 case maybeFuncName of

821 case maybeFuncName of

839 NoName -> "this function"

822 NoName -> "this function"

841 CtorName name -> "`" <> N.toString name <> "`"

824 CtorName name -> "`" <> N.toString name <> "`"

842 OpName op -> "(" <> N.toString op <> ")"

825 OpName op -> "(" <> N.toString op <> ")"

843 in

826 in

827+ mismatch

844− Report.toCodeSnippet source region (Just exprRegion)

828+ ( Just exprRegion

845− (

846− D.reflow $

847− "The " <> D.ordinalize (Index.toHuman index) <> " argument to " <> thisFunction <> " is not what I expect:"

829+ , "The " <> ith <> " argument to " <> thisFunction <> " is not what I expect:"

848− ,

849− typeComparison localizer tipe expectedType

850− (

851− toDescription category "This argument is"

830+ , "This argument is"

852− ,

853− "But " <> thisFunction <> " needs the " <> D.ordinalize (Index.toHuman index)

831+ , singular $ "But " <> thisFunction <> " needs the " <> ith <> " argument to be"

854− <> " argument to be:"

855− ,

832+ ,

856− if Index.toHuman index == 1 then

833+ if Index.toHuman index == 1 then

857− []

834+ []

858− else

835+ else

859− [ D.toSimpleHint $

836+ [ D.toSimpleHint $

860− "I always figure out the argument types from left to right. If an argument\

837+ "I always figure out the argument types from left to right. If an argument\

861− \ is acceptable, I assume it is “correct” and move on. So the problem may\

838+ \ is acceptable, I assume it is “correct” and move on. So the problem may\

862− \ actually be in one of the previous arguments!"

839+ \ actually be in one of the previous arguments!"

863− ]

840+ ]

864− )

865− )

866−

867− TooManyArgs maybeName numGivenArgs ->

868− case countArgs tipe of

869− 0 ->

870− Report.toCodeSnippet source region (Just exprRegion)

871− (

872− D.reflow $

873− case maybeName of

874− NoName ->

875− "You are giving " <> D.args numGivenArgs <> " to something that is not a function!"

876−

877− FuncName name ->

878− "`" <> N.toString name <> "` is not a function, but you are giving it " <> D.args numGivenArgs <> "!"

879−

880− CtorName name ->

881− "`" <> N.toString name <> "` is not a function, but you are giving it " <> D.args numGivenArgs <> "!"

882−

883− OpName op ->

884− "(" <> N.toString op <> ") is not a function, but you are giving it " <> D.args numGivenArgs <> "!"

885− ,

886− typeComparison localizer tipe expectedType

887− (

888− case maybeName of

889− NoName ->

890− "It is a value of type:"

891−

892− FuncName name ->

893− "`" <> N.toString name <> "` is a value of type:"

894−

895− CtorName name ->

896− "`" <> N.toString name <> "` is a constructor of type:"

897−

898− OpName op ->

899− "(" <> N.toString op <> ") is a value of type:"

900− ,

901− "But you are giving it " <> D.args numGivenArgs <> " as if its type was:"

902− ,

903− [ "Maybe you forgot some parentheses? Or a comma?"

904− ]

905− )

906− )

907−

908− numExpectedArgs ->

909− let

910− thisFunction =

911− case maybeName of

912− NoName ->

913− "This function"

914−

915− FuncName name ->

916− "The `" <> N.toString name <> "` function"

917−

918− CtorName name ->

919− "The `" <> N.toString name <> "` constructor"

920−

921− OpName op ->

922− "The (" <> N.toString op <> ") function"

923− in

924− Report.toCodeSnippet source region (Just exprRegion)

925− (

926− D.reflow $

927− thisFunction <> " is getting too many arguments:"

928− ,

929− typeComparison localizer tipe expectedType

930− (

931− thisFunction <> " is expecting to get " <> D.args numExpectedArgs <> " like this:"

932− ,

933− "But you are giving it " <> D.args numGivenArgs <> " as if its type was:"

934− ,

935− [ "Maybe you forgot some parentheses? Or a comma?"

936− , D.toSimpleNote $

937− "I am not good at figuring out which arguments are extra myself. The\

938− \ problem may even be that the FUNCTION is defined funny, and the arguments are\

939− \ actually fine. Anyway, I hope I gave enough info to help you figure it out!"

940− ]

941− )

942− )

841+ )

943

842

944 RecordAccess field ->

843 RecordAccess field ->

945− Report.toCodeSnippet source region (Just exprRegion) $

844+ badType $

946− case tipe of

845+ case T.getFields tipe of

947− T.Record _ _ ->

846+ Just _fields ->

948− (

847+ ( Just exprRegion

949− D.reflow $

950− "This record does not have a `" <> N.toString field <> "` field:"

848+ , "This record does not have a `" <> N.toString field <> "` field:"

951− ,

849+ , "It is"

952− loneType localizer tipe expectedType

850+ , [ -- TODO suggest what the typo is!

953− (

954− D.reflow $ "It is a record with this type:"

955− ,

956− [ D.fillSep

957− ["Is","the",D.dullyellow ("." <> D.fromName field)

958− ,"field","access","is","misspelled?"

959− ]

960− ]

851+ ]

961− )

962− )

852+ )

963

853

964− _ ->

854+ Nothing ->

965− (

855+ ( Just exprRegion

966− D.reflow $

967− "This is not a record, so it has no fields to access!"

856+ , "This is not a record, so it has no fields to access!"

968− ,

857+ , "It is"

969− loneType localizer tipe expectedType

970− ( D.reflow $ toDescription category "It is"

971− , [ D.fillSep

858+ , [ D.fillSep

972− ["But","I","need","a","record","with","a"

859+ ["But","I","need","a","record","with","a"

973− ,D.dullyellow (D.fromName field),"field!"

860+ ,D.dullyellow (D.fromName field),"field!"

974− ]

861+ ]

975− ]

862+ ]

976− )

977− )

863+ )

978

864

979− RecordUpdate ->

865+ RecordUpdate name updatedFields ->

866+ badType $

980− case T.iteratedDealias tipe of

867+ case T.getFields tipe of

981− T.Record _ _ ->

868+ Nothing ->

982− Report.toCodeSnippet source region Nothing $

869+ ( Just exprRegion

983− (

870+ , "I cannot update the `" <> N.toString name <> "` value:"

984− D.reflow $

871+ , "It is"

985− "I think there is a typo in one of these field names:"

872+ , [ D.reflow $ "It is not a record. It has no fields to update!"

986− ,

987− typeComparison localizer tipe expectedType

988− (

989− "The record you want to update has type:"

990− ,

991− "But you are saying it should have these fields:"

992− ,

993− [ D.reflow "Maybe there is some typo?"

994− ]

873+ ]

995− )

996− )

874+ )

997

875

998− _ ->

876+ Just _fields ->

999− Report.toCodeSnippet source region (Just exprRegion)

877+ case Map.keys updatedFields of

1000− (

878+ [field] ->

1001− "The record update syntax does not work with this value:"

879+ ( Nothing

1002− ,

880+ , "The `" <> N.toString name <> "` record does not have a `" <> N.toString field <> "` field."

1003− loneType localizer tipe expectedType

881+ , "It is"

1004− ( D.reflow $ toDescription category "It is"

882+ , [ -- TODO suggest what the typo is!

1005− , [ D.reflow $ "But I need some kind of record here!"

883+ ]

1006− ]

884+ )

1007− )

885+

886+ _ ->

887+ ( Nothing

888+ , "The `" <> N.toString name <> "` record does have all of these fields:"

889+ , "It is"

890+ , [ -- TODO suggest what the typo is!

891+ ]

1008− )

892+ )

1009

893

1010 Destructure ->

894 Destructure ->

1011− Report.toCodeSnippet source region Nothing

895+ mismatch

1012− (

896+ ( Nothing

1013− D.reflow $

897+ , "This definition is causing issues:"

1014− "I cannot destructure "

1015− ,

1016− typeComparison localizer tipe expectedType

1017− (

1018− toDescription category "You are defining"

898+ , "You are defining"

1019− ,

1020− "But then trying to destructure it as:"

899+ , singular "But then trying to destructure it as"

1021− ,

1022− []

900+ , []

1023− )

1024− )

901+ )

1025

902

1026

903

1027

904

1069

946

1070 "<|" ->

947 "<|" ->

1071 ( "The left side of (<|) needs to be a function so I can pipe arguments to it!"

948 ( "The left side of (<|) needs to be a function so I can pipe arguments to it!"

1072− ,

1073− loneType localizer tipe expected

949+ , loneType localizer tipe expected

1074− ( D.reflow $ toDescription category "I am seeing"

950+ (addCategory "I am seeing" category)

1075− , [ D.reflow $ "This needs to be some kind of function though!"

951+ [ D.reflow $ "This needs to be some kind of function though!"

1076− ]

952+ ]

1077− )

1078 )

953 )

1079

954

1080 _ ->

955 _ ->

1081− (

1082− D.reflow $

956+ ( D.reflow $

1083 "The left argument of (" <> N.toString op <> ") is causing problems:"

957 "The left argument of (" <> N.toString op <> ") is causing problems:"

1084− ,

1085− typeComparison localizer tipe expected

958+ , typeComparison localizer tipe expected

1086− (

1087− toDescription category "The left argument is"

959+ (addCategory "The left argument is" category)

1088− ,

1089− "But (" <> N.toString op <> ") needs the left argument to be:"

960+ (singular $ "But (" <> N.toString op <> ") needs the left argument to be")

1090− ,

1091− []

961+ []

1092− )

1093 )

962 )

1094

963

1095

964

1146

1015

1147 "<|" ->

1016 "<|" ->

1148 EmphRight

1017 EmphRight

1149− (

1150− D.reflow $

1151− "I cannot send this through the (<|) pipe:"

1018+ ( D.reflow $ "I cannot send this through the (<|) pipe:"

1152− ,

1153− typeComparison localizer tipe expected

1019+ , typeComparison localizer tipe expected

1154− (

1155− toDescription category "You are providing"

1020+ (addCategory "You are providing" category)

1156− ,

1157− "But (<|) is piping it a function that expects:"

1021+ (singular "But (<|) is piping it a function that expects")

1158− ,

1159− []

1022+ []

1160− )

1161 )

1023 )

1162

1024

1163 "|>" ->

1025 "|>" ->

1164 case (tipe, expected) of

1026 case (tipe, expected) of

1165 (T.Lambda expectedArgType _ _, T.Lambda argType _ _) ->

1027 (T.Lambda expectedArgType _ _, T.Lambda argType _ _) ->

1166 EmphRight

1028 EmphRight

1167− (

1168− "This function cannot handle the argument sent through the (|>) pipe:"

1029+ ( D.reflow $ "This function cannot handle the argument sent through the (|>) pipe:"

1169− ,

1170− typeComparison localizer argType expectedArgType

1030+ , typeComparison localizer argType expectedArgType

1171− (

1031+ (addCategory "The argument is" category)

1172− "You are providing an argument of type:"

1173− ,

1174− "But (|>) is piping it a function that expects its next argument to be:"

1032+ (singular "But (|>) is piping it a function that expects")

1175− ,

1176− []

1033+ []

1177− )

1178 )

1034 )

1179

1035

1180 _ ->

1036 _ ->

1181 EmphRight

1037 EmphRight

1182− (

1183− "The right side of (|>) needs to be a function so I can pipe arguments to it!"

1038+ ( D.reflow $ "The right side of (|>) needs to be a function so I can pipe arguments to it!"

1184− ,

1185− loneType localizer tipe expected

1039+ , loneType localizer tipe expected

1186− ( D.reflow $ toDescription category $

1187− "But instead of a function, I am seeing "

1040+ (addCategory "But instead of a function, I am seeing" category)

1188− , []

1041+ []

1189− )

1190 )

1042 )

1191

1043

1192 _ ->

1044 _ ->

1196badOpRightFallback :: L.Localizer -> Category -> N.Name -> T.Type -> T.Type -> RightDocs

1048badOpRightFallback :: L.Localizer -> Category -> N.Name -> T.Type -> T.Type -> RightDocs

1197badOpRightFallback localizer category op tipe expected =

1049badOpRightFallback localizer category op tipe expected =

1198 EmphRight

1050 EmphRight

1199− (

1200− D.reflow $

1051+ ( D.reflow $

1201 "The right argument of (" <> N.toString op <> ") is causing problems."

1052 "The right argument of (" <> N.toString op <> ") is causing problems."

1202− ,

1203− typeComparison localizer tipe expected

1053+ , typeComparison localizer tipe expected

1204− (

1054+ (addCategory "The right argument is" category)

1205− toDescription category "The right argument is"

1206− ,

1207− "But (" <> N.toString op <> ") needs the right argument to be:"

1055+ (singular $ "But (" <> N.toString op <> ") needs the right argument to be")

1208− ,

1209− [ D.toSimpleHint $

1056+ [ D.toSimpleHint $

1210− "With operators like (" ++ N.toString op ++ ") I always check the left\

1057+ "With operators like (" ++ N.toString op ++ ") I always check the left\

1211− \ side first. If it seems fine, I assume it is correct and check the right\

1058+ \ side first. If it seems fine, I assume it is correct and check the right\

1212− \ side. So the problem may be in how the left and right arguments interact!"

1059+ \ side. So the problem may be in how the left and right arguments interact!"

1213− ]

1060+ ]

1214− )

1215 )

1061 )

1216

1062

1217

1063

1266 case expected of

1112 case expected of

1267 T.Type home2 name2 [expectedElement] | T.isList home2 name2 ->

1113 T.Type home2 name2 [expectedElement] | T.isList home2 name2 ->

1268 EmphBoth

1114 EmphBoth

1269− (

1270− D.reflow "I am having trouble with this (::) operator:"

1115+ ( D.reflow "I am having trouble with this (::) operator:"

1271− ,

1272− typeComparison localizer expectedElement actualElement

1116+ , typeComparison localizer expectedElement actualElement

1273− (

1274− "The left side of (::) is an element of type:"

1117+ (singular "The left side of (::) is")

1275− ,

1118+ (plural "But you are trying to put that into a list filled with")

1276− "But the right side is a list filled with elements of type:"

1277− ,

1278− case expectedElement of

1119+ ( case expectedElement of

1279 T.Type home name [_] | T.isList home name ->

1120 T.Type home name [_] | T.isList home name ->

1280 [ D.toSimpleHint

1121 [ D.toSimpleHint

1281 "Are you trying to append two lists? The (++) operator\

1122 "Are you trying to append two lists? The (++) operator\

1295

1136

1296 _ ->

1137 _ ->

1297 EmphRight

1138 EmphRight

1298− (

1299− D.reflow "The (::) operator can only add elements onto lists."

1139+ ( D.reflow "The (::) operator can only add elements onto lists."

1300− ,

1301− loneType localizer tipe expected

1140+ , loneType localizer tipe expected

1302− (

1141+ (addCategory "The right side is" category)

1303− D.reflow $ toDescription category "The right side is"

1304− ,

1305− [D.fillSep ["But","(::)","needs","a",D.dullyellow "List","on","the","right."]

1142+ [D.fillSep ["But","(::)","needs","a",D.dullyellow "List","on","the","right."]

1306− ]

1143+ ]

1307− )

1308 )

1144 )

1309

1145

1310

1146

1337badAppendLeft localizer category tipe expected =

1173badAppendLeft localizer category tipe expected =

1338 case toAppendType tipe of

1174 case toAppendType tipe of

1339 ANumber thing stringFromThing ->

1175 ANumber thing stringFromThing ->

1340− (

1341− D.fillSep

1176+ ( D.fillSep

1342 ["The","(++)","operator","can","append","List","and","String"

1177 ["The","(++)","operator","can","append","List","and","String"

1343 ,"values,","but","not",D.dullyellow thing,"values","like","this:"

1178 ,"values,","but","not",D.dullyellow thing,"values","like","this:"

1344 ]

1179 ]

1345− ,

1346− D.fillSep

1180+ , D.fillSep

1347 ["Try","using",D.green stringFromThing,"to","turn","it","into","a","string?"

1181 ["Try","using",D.green stringFromThing,"to","turn","it","into","a","string?"

1348 ,"Or","put","it","in","[]","to","make","it","a","list?"

1182 ,"Or","put","it","in","[]","to","make","it","a","list?"

1349 ,"Or","switch","to","the","(::)","operator?"

1183 ,"Or","switch","to","the","(::)","operator?"

1351 )

1185 )

1352

1186

1353 _ ->

1187 _ ->

1354− (

1355− D.reflow $

1188+ ( D.reflow $

1356 "The (++) operator cannot append this type of value:"

1189 "The (++) operator cannot append this type of value:"

1357− ,

1358− loneType localizer tipe expected

1190+ , loneType localizer tipe expected

1359− ( D.reflow $ toDescription category "I am seeing"

1191+ (addCategory "I am seeing" category)

1360− ,

1361− [ D.fillSep

1192+ [ D.fillSep

1362− ["But","the","(++)","operator","is","only","for","appending"

1193+ ["But","the","(++)","operator","is","only","for","appending"

1363− ,D.dullyellow "List","and",D.dullyellow "String","values."

1194+ ,D.dullyellow "List","and",D.dullyellow "String","values."

1364− ,"Maybe","put","this","value","in","[]","to","make","it","a","list?"

1195+ ,"Maybe","put","this","value","in","[]","to","make","it","a","list?"

1365− ]

1366− ]

1196+ ]

1367− )

1197+ ]

1368 )

1198 )

1369

1199

1370

1200

1373 case (toAppendType expected, toAppendType tipe) of

1203 case (toAppendType expected, toAppendType tipe) of

1374 (AString, ANumber thing stringFromThing) ->

1204 (AString, ANumber thing stringFromThing) ->

1375 EmphRight

1205 EmphRight

1376− (

1377− D.fillSep

1206+ ( D.fillSep

1378 ["I","thought","I","was","appending",D.dullyellow "String","values","here,"

1207 ["I","thought","I","was","appending",D.dullyellow "String","values","here,"

1379 ,"not",D.dullyellow thing,"values","like","this:"

1208 ,"not",D.dullyellow thing,"values","like","this:"

1380 ]

1209 ]

1381− ,

1382− D.fillSep

1210+ , D.fillSep

1383− ["Try","using",D.green stringFromThing

1211+ ["Try","using",D.green stringFromThing,"to","turn","it","into","a","string?"]

1384− ,"to","turn","it","into","a","string?"

1385− ]

1386 )

1212 )

1387

1213

1388 (AList, ANumber thing _) ->

1214 (AList, ANumber thing _) ->

1389 EmphRight

1215 EmphRight

1390− (

1391− D.fillSep

1216+ ( D.fillSep

1392 ["I","thought","I","was","appending",D.dullyellow "List","values","here,"

1217 ["I","thought","I","was","appending",D.dullyellow "List","values","here,"

1393 ,"not",D.dullyellow thing,"values","like","this:"

1218 ,"not",D.dullyellow thing,"values","like","this:"

1394 ]

1219 ]

1395− ,

1396− D.reflow "Try putting it in [] to make it a list?"

1220+ , D.reflow "Try putting it in [] to make it a list?"

1397 )

1221 )

1398

1222

1399 (AString, AList) ->

1223 (AString, AList) ->

1400 EmphBoth

1224 EmphBoth

1401− (

1402− D.reflow $

1225+ ( D.reflow $

1403 "The (++) operator needs the same type of value on both sides:"

1226 "The (++) operator needs the same type of value on both sides:"

1404− ,

1405− D.fillSep

1227+ , D.fillSep

1406 ["I","see","a",D.dullyellow "String","on","the","left","and","a"

1228 ["I","see","a",D.dullyellow "String","on","the","left","and","a"

1407 ,D.dullyellow "List","on","the","right.","Which","should","it","be?"

1229 ,D.dullyellow "List","on","the","right.","Which","should","it","be?"

1408 ,"Does","the","string","need","[]","around","it","to","become","a","list?"

1230 ,"Does","the","string","need","[]","around","it","to","become","a","list?"

1411

1233

1412 (AList, AString) ->

1234 (AList, AString) ->

1413 EmphBoth

1235 EmphBoth

1414− (

1415− D.reflow $

1236+ ( D.reflow $

1416 "The (++) operator needs the same type of value on both sides:"

1237 "The (++) operator needs the same type of value on both sides:"

1417− ,

1418− D.fillSep

1238+ , D.fillSep

1419 ["I","see","a",D.dullyellow "List","on","the","left","and","a"

1239 ["I","see","a",D.dullyellow "List","on","the","left","and","a"

1420 ,D.dullyellow "String","on","the","right.","Which","should","it","be?"

1240 ,D.dullyellow "String","on","the","right.","Which","should","it","be?"

1421 ,"Does","the","string","need","[]","around","it","to","become","a","list?"

1241 ,"Does","the","string","need","[]","around","it","to","become","a","list?"

1424

1244

1425 (_,_) ->

1245 (_,_) ->

1426 EmphBoth

1246 EmphBoth

1427− (

1428− D.reflow $

1247+ ( D.reflow $

1429 "The (++) operator cannot append these two values:"

1248 "The (++) operator cannot append these two values:"

1430− ,

1431− typeComparison localizer expected tipe

1249+ , typeComparison localizer expected tipe

1432− (

1433− "I already figured out that the left side of (++) is:"

1250+ (singular "I already figured out that the left side of (++) is")

1434− ,

1435− toDescription category $

1436− "But this clashes with the right side, which is"

1251+ (addCategory "But this clashes with the right side, which is" category)

1437− ,

1438− []

1252+ []

1439− )

1440 )

1253 )

1441

1254

1442

1255

1450badCast :: N.Name -> ThisThenThat -> RightDocs

1263badCast :: N.Name -> ThisThenThat -> RightDocs

1451badCast op thisThenThat =

1264badCast op thisThenThat =

1452 EmphBoth

1265 EmphBoth

1453− (

1454− D.reflow $

1266+ ( D.reflow $

1455 "I need both sides of (" <> N.toString op <> ") to be the exact same type. Both Int or both Float."

1267 "I need both sides of (" <> N.toString op <> ") to be the exact same type. Both Int or both Float."

1456− ,

1457− let

1268+ , let

1458 anInt = ["an", D.dullyellow "Int"]

1269 anInt = ["an", D.dullyellow "Int"]

1459 aFloat = ["a", D.dullyellow "Float"]

1270 aFloat = ["a", D.dullyellow "Float"]

1460 toFloat = D.green "toFloat"

1271 toFloat = D.green "toFloat"

1508 "I cannot do addition with lists:"

1319 "I cannot do addition with lists:"

1509 ,

1320 ,

1510 loneType localizer tipe expected

1321 loneType localizer tipe expected

1511− (

1512− D.reflow $ toDescription category $

1513− "The " <> direction <> " side of (+) is"

1322+ (addCategory ("The " <> direction <> " side of (+) is") category)

1514− ,

1515− [ D.fillSep

1323+ [ D.fillSep

1516− ["But","(+)","only","works","with",D.dullyellow "Int","and",D.dullyellow "Float","values."

1324+ ["But","(+)","only","works","with",D.dullyellow "Int","and",D.dullyellow "Float","values."

1517− ]

1325+ ]

1518− , D.toFancyHint

1326+ , D.toFancyHint

1519− ["Switch","to","the",D.green "(++)","operator","to","append","lists!"

1327+ ["Switch","to","the",D.green "(++)","operator","to","append","lists!"

1520− ]

1521− ]

1328+ ]

1522− )

1329+ ]

1523 )

1330 )

1524

1331

1525

1332

1542 operation ++ " does not work with this value:"

1349 operation ++ " does not work with this value:"

1543 ,

1350 ,

1544 loneType localizer tipe expected

1351 loneType localizer tipe expected

1545− ( D.reflow $ toDescription category $

1546− "The " <> direction <> " side of (" <> op <> ") is"

1352+ (addCategory ("The " <> direction <> " side of (" <> op <> ") is") category)

1547− ,

1548− [ D.fillSep

1353+ ( [ D.fillSep

1549 ["But","(" <> D.fromString op <> ")","only","works","with"

1354 ["But","(" <> D.fromString op <> ")","only","works","with"

1550 ,D.dullyellow "Int","and",D.dullyellow "Float","values."

1355 ,D.dullyellow "Int","and",D.dullyellow "Float","values."

1551 ]

1356 ]

1578

1383

1579 else

1384 else

1580 loneType localizer tipe expected

1385 loneType localizer tipe expected

1581− (

1386+ (\_ ->

1582− D.fillSep

1387+ D.fillSep

1583− ["The",direction,"side","of","(/)","must","be","a"

1388+ ["The",direction,"side","of","(/)","must","be","a"

1584− ,D.dullyellow "Float" <> ","

1585− ,"but","instead","I","am","seeing:"

1389+ ,D.dullyellow "Float" <> ",","but","instead","I","am","seeing:"

1586− ]

1587− , []

1390+ ]

1588 )

1391 )

1392+ []

1589 )

1393 )

1590

1394

1591

1395

1614 ]

1418 ]

1615 else

1419 else

1616 loneType localizer tipe expected

1420 loneType localizer tipe expected

1617− (

1421+ ( \_ ->

1618− D.fillSep

1422+ D.fillSep

1619− ["The",direction,"side","of","(//)","must","be","an"

1423+ ["The",direction,"side","of","(//)","must","be","an"

1620− ,D.dullyellow "Int" <> ","

1621− ,"but","instead","I","am","seeing:"

1424+ ,D.dullyellow "Int" <> ",","but","instead","I","am","seeing:"

1622− ]

1623− , []

1425+ ]

1624 )

1426 )

1427+ []

1625 )

1428 )

1626

1429

1627

1430

1636 "I am struggling with this boolean operation:"

1439 "I am struggling with this boolean operation:"

1637 ,

1440 ,

1638 loneType localizer tipe expected

1441 loneType localizer tipe expected

1639− (

1442+ ( \_ ->

1640− D.fillSep

1443+ D.fillSep

1641− ["Both","sides","of","(" <> op <> ")","must","be"

1444+ ["Both","sides","of","(" <> op <> ")","must","be"

1642− ,D.dullyellow "Bool","values,","but","the",direction,"side","is:"

1445+ ,D.dullyellow "Bool","values,","but","the",direction,"side","is:"

1643− ]

1644− ,

1645− []

1446+ ]

1646 )

1447 )

1448+ []

1647 )

1449 )

1648

1450

1649

1451

1658 "I cannot do a comparison with this value:"

1460 "I cannot do a comparison with this value:"

1659 ,

1461 ,

1660 loneType localizer tipe expected

1462 loneType localizer tipe expected

1661− (

1662− D.reflow $ toDescription category $

1663− "The " <> direction <> " side of (" <> op <> ") is"

1463+ (addCategory ("The " <> direction <> " side of (" <> op <> ") is") category)

1664− ,

1665− [ D.fillSep

1464+ [ D.fillSep

1666− ["But","(" <> D.fromString op <> ")","only","works","on"

1465+ ["But","(" <> D.fromString op <> ")","only","works","on"

1667− ,D.dullyellow "Int" <> ","

1466+ ,D.dullyellow "Int" <> ","

1668− ,D.dullyellow "Float" <> ","

1467+ ,D.dullyellow "Float" <> ","

1669− ,D.dullyellow "Char" <> ","

1468+ ,D.dullyellow "Char" <> ","

1670− ,"and"

1469+ ,"and"

1671− ,D.dullyellow "String"

1470+ ,D.dullyellow "String"

1672− ,"values.","It","can","work","on","lists","and","tuples"

1471+ ,"values.","It","can","work","on","lists","and","tuples"

1673− ,"of","comparable","values","as","well,","but","it","is"

1472+ ,"of","comparable","values","as","well,","but","it","is"

1674− ,"usually","better","to","find","a","different","path."

1473+ ,"usually","better","to","find","a","different","path."

1675− ]

1676− ]

1474+ ]

1677− )

1475+ ]

1678 )

1476 )

1679

1477

1680

1478

1686 "I need both sides of (" <> op <> ") to be the same type:"

1484 "I need both sides of (" <> op <> ") to be the same type:"

1687 ,

1485 ,

1688 typeComparison localizer expected tipe

1486 typeComparison localizer expected tipe

1689− (

1690− "The left side of is:"

1487+ (singular "The left side of is")

1691− ,

1692− "But the right side is:"

1488+ (singular "But the right side is")

1693− ,

1694− [ D.reflow $

1489+ [ D.reflow $

1695− "I cannot compare different types though! Which side of (" <> op <> ") is the problem?"

1490+ "I cannot compare different types though! Which side of (" <> op <> ") is the problem?"

1696− ]

1491+ ]

1697− )

1698 )

1492 )

1699

1493

1700

1494

1710 "I need both sides of (" <> op <> ") to be the same type:"

1504 "I need both sides of (" <> op <> ") to be the same type:"

1711 ,

1505 ,

1712 typeComparison localizer expected tipe

1506 typeComparison localizer expected tipe

1713− (

1714− "The left side of is:"

1507+ (singular "The left side of is")

1715− ,

1716− "But the right side is:"

1508+ (singular "But the right side is")

1717− ,

1718− if isFloat tipe || isFloat expected then

1509+ [ if isFloat tipe || isFloat expected then

1719− [ D.toSimpleNote $

1510+ D.toSimpleNote $

1720− "Equality on floats is not 100% reliable due to the design of IEEE 754. I\

1511+ "Equality on floats is not 100% reliable due to the design of IEEE 754. I\

1721− \ recommend a check like (abs (x - y) < 0.0001) instead."

1512+ \ recommend a check like (abs (x - y) < 0.0001) instead."

1722− ]

1723 else

1513 else

1724− [ D.reflow $

1725− "Different types can never be equal though! Which side is messed up?"

1514+ D.reflow "Different types can never be equal though! Which side is messed up?"

1726− ]

1515+ ]

1727− )

1728 )

1516 )

1729

1517

1730

1518