docs: Misplaced comma in Kaleidoscope tutorial

[modocache]

Summary

Match the convention in the rest of the documentation by placing a space
after the comma, not before.

[dblaikie]

Looks good, thanks!

(let me know if you need someone to commit it for you)

[modocache]

@dblaikie So sorry for the late reply. Yes, I don't have commit access, so I'd appreciate if you could commit this for me. Thanks!!

[Eugene.Zelenko]

Current documentation doesn't contain typos, but it hard to trace when this was fixed because of files moves.

docs/tutorial/LangImpl2.rst

 map makes it easy to add new operators and makes it clear that the
 algorithm doesn't depend on the specific operators involved, but it
 would be easy enough to eliminate the map and do the comparisons in the
 ``GetTokPrecedence`` function. (Or just use a fixed-size array).
 
 With the helper above defined, we can now start parsing binary
 expressions. The basic idea of operator precedence parsing is to break
 down an expression with potentially ambiguous binary operators into
-pieces. Consider ,for example, the expression "a+b+(c+d)\*e\*f+g".
+pieces. Consider, for example, the expression "a+b+(c+d)\*e\*f+g".
 Operator precedence parsing considers this as a stream of primary
 expressions separated by binary operators. As such, it will first parse
 the leading primary expression "a", then it will see the pairs [+, b]
 [+, (c+d)] [\*, e] [\*, f] and [+, g]. Note that because parentheses are
 primary expressions, the binary expression parser doesn't need to worry
 about nested subexpressions like (c+d) at all.
 
 To start, an expression is a primary expression potentially followed by

docs/tutorial/OCamlLangImpl2.rst

 the algorithm doesn't depend on the specific operators involved, but it
 would be easy enough to eliminate the ``Hashtbl.t`` and do the
 comparisons in the ``Parser.precedence`` function. (Or just use a
 fixed-size array).
 
 With the helper above defined, we can now start parsing binary
 expressions. The basic idea of operator precedence parsing is to break
 down an expression with potentially ambiguous binary operators into
-pieces. Consider ,for example, the expression "a+b+(c+d)\*e\*f+g".
+pieces. Consider, for example, the expression "a+b+(c+d)\*e\*f+g".
 Operator precedence parsing considers this as a stream of primary
 expressions separated by binary operators. As such, it will first parse
 the leading primary expression "a", then it will see the pairs [+, b]
 [+, (c+d)] [\*, e] [\*, f] and [+, g]. Note that because parentheses are
 primary expressions, the binary expression parser doesn't need to worry
 about nested subexpressions like (c+d) at all.
 
 To start, an expression is a primary expression potentially followed by