Fix errors in the parsing docs

content/courses/hoon-school/Q2-parsing.md

@@ -39,9 +39,9 @@ we have to wade directly into a sea of new types and processes.  To wit:
 -   A {% tooltip label="tape" href="/glossary/tape" /%} is the string to
     be parsed.
 -   A `hair` is the position in the text the parser is at, as a cell of
-    column & line, `[p=@ud q=@ud]`.
+    line & column, `[p=@ud q=@ud]`.
 -   A `nail` is parser input, a cell of `hair` and `tape`.
--   An `edge` is parser output, a cell of `hair` and a `unit` of `hair`
+-   An `edge` is parser output, a cell of `hair` and a `unit` of `*`
     and `nail`.  (There are some subtleties around failure-to-parse here
     that we'll defer a moment.)
 -   A `rule` is a parser, a gate which applies a `nail` to yield an

content/language/hoon/guides/parsing.md

@@ -100,7 +100,7 @@ A `hair` is a pair of `@ud` used to keep track of what has already been parsed
 for stack tracing purposes. This allows the parser to reveal where the problem
 is in case it hits something unexpected during parsing.
 
-`p` represents the column and `q` represents the line.
+`p` represents the line and `q` represents the column.
 
 ### `nail`
 
@@ -173,7 +173,7 @@ We note that `p.edg` is `[p=1 q=2]`, indicating that the next character to be
 parsed is in line 1, column 2. `q.edg` is not null, indicating that parsing
 succeeded. `p.q.edg` is `'a'`, which is the result of the parse. `p.q.q.edg` is the same as `p.edg`, which is always the case for
 `rule`s built using standard library functions when parsing succeeds. Lastly,
-`q.q.edg` is `"bc"`, which is the part of the input `tape` that has yet to be parsed.
+`q.q.q.edg` is `"bc"`, which is the part of the input `tape` that has yet to be parsed.
 
 Now let's see what happens when parsing fails.
 
@@ -208,7 +208,7 @@ Let's see what happens when we successfully parse the entire input `tape`.
 line 1, column 4. Of course, this does not exist since the input `tape` was only
 3 characters long, so this actually indicates that the entire `tape` has been
 successfully parsed (since the `hair` does not advance in the case of failure).
-`p.q.edg` is `'abc'`, as expected. `q.q.edg` is `""`, indicating that nothing
+`p.q.edg` is `'abc'`, as expected. `q.q.q.edg` is `""`, indicating that nothing
 remains to be parsed.
 
 What happens if we only match some of the input `tape`?
@@ -267,7 +267,7 @@ is `%foo`.
 
 ```
 > ((cold %foo (just 'a')) [[1 1] "abc"])
-[p=[p=1 q=2] q=[~ u=[p=%foo q=[p=[p=1 q=2] q="bc"]]]]
+[p=[p=1 q=2] q=[~ [p=%foo q=[p=[p=1 q=2] q="bc"]]]]
 ```
 
 One common scenario where `+cold` sees play is when writing [command line