Update text of error messages to match recent GHCs (#65)

Co-authored-by: Stanislav (Stanley) Modrak <44023416+smith558@users.noreply.github.com>

Author: Bodigrim

markdown/source_md/higher-order-functions.md

@@ -131,12 +131,10 @@ What happens if we try to just do `multThree 3 4` in GHCI instead of binding it
 
 ```{.haskell:hs}
 ghci> multThree 3 4
-<interactive>:1:0:
-    No instance for (Show (t -> t))
-      arising from a use of `print' at <interactive>:1:0-12
-    Possible fix: add an instance declaration for (Show (t -> t))
-    In the expression: print it
-    In a 'do' expression: print it
+<interactive>:1:1: error: [GHC-39999]
+    • No instance for ‘Show (a0 -> a0)’ arising from a use of ‘print’
+        (maybe you haven't applied a function to enough arguments?)
+    • In a stmt of an interactive GHCi command: print it
 ```
 
 GHCI is telling us that the expression produced a function of type `a -> a` but it doesn't know how to print it to the screen.

markdown/source_md/starting-out.md

@@ -85,8 +85,10 @@ What about doing `5 + "llama"` or `5 == True`?
 Well, if we try the first snippet, we get a big scary error message!
 
 ```{.haskell: .ghci}
-• No instance for (Num String) arising from a use of ‘+’
-    • In the expression: 5 + "llama"
+<interactive>:1:1: error: [GHC-39999]
+    • No instance for ‘Num String’ arising from the literal ‘5’
+    • In the first argument of ‘(+)’, namely ‘5’
+      In the expression: 5 + "llama"
       In an equation for ‘it’: it = 5 + "llama"
 ```
 
@@ -102,6 +104,13 @@ We'll take a closer look at types a bit later.
 Note: you can do `5 + 4.0` because `5` is sneaky and can act like an integer or a floating-point number.
 `4.0` can't act like an integer, so `5` is the one that has to adapt.
 
+::: {.hintbox}
+**Note:** GHC errors are all assigned unique identifiers such as `GHC-39999` above.
+Whenever you are stuck with a stubborn error, you can look it up at
+[https://errors.haskell.org/](https://errors.haskell.org/) to learn typical causes
+and solutions.
+:::
+
 You may not have known it but we've been using functions now all along.
 For instance, `*` is a function that takes two numbers and multiplies them.
 As you've seen, we call it by sandwiching it between them.
@@ -777,8 +786,9 @@ What if we tried to make a shape like `[(1,2),(8,11,5),(4,5)]`?
 Well, we'd get this error:
 
 ```{.haskell: .ghci}
-• Couldn't match expected type ‘(a, b)’
-                  with actual type ‘(a0, b0, c0)’
+<interactive>:1:8: error: [GHC-83865]
+    • Couldn't match expected type: (a, b)
+                  with actual type: (a0, b0, c0)
     • In the expression: (8, 11, 5)
       In the expression: [(1, 2), (8, 11, 5), (4, 5)]
       In an equation for ‘it’: it = [(1, 2), (8, 11, 5), (4, 5)]