afl-material: comparison handouts/ho06.tex

equal deleted inserted replaced

-:6ee22f196884
+:451a95e1bc25
 we are interested in transform our input into something
 ``different''\ldots for example into a tree, or if we implement the
 grammar for arithmetic expressions we might be interested in the
 actual integer number the arithmetic expression, say \texttt{1 + 2 *
 3}, stands for. In this way we can use parser combinators to
-implement relativaley easily a calculator.
+implement relatively easily a calculator.
 The main idea of parser combinators is that we can easily build parser
 combinators out of smaller components following very closely the
 structure of a grammar. In order to implement this in an
 object-oriented programming language, like Scala, we need to specify
 new AltParser(CharParser('a'), CharParser('b'))
 \end{lstlisting}
 \end{center}
 \noindent Later on we will use again Scala mechanism for introducing some
-more readable shorthand notation for this, like \texttt{"a" || "b"}. Let us look in detail at what this parser combinator produces with some somple strings
+more readable shorthand notation for this, like \texttt{"a" || "b"}. Let us look in detail at what this parser combinator produces with some sample strings
 \begin{center}
 \begin{tabular}{rcl}
 input strings & & output\medskip\\
 \texttt{\Grid{acde}} & $\rightarrow$ & $\left\{(\texttt{\Grid{a}}, \texttt{\Grid{cde}})\right\}$\\
 new AltParser(CharParser('a'), CharParser('b'))
 \end{lstlisting}
 \end{center}
 \noindent Later on we will use again Scala mechanism for introducing some
-more readable shorthand notation for this, like \texttt{"a" || "b"}. Let us look in detail at what this parser combinator produces with some somple strings
+more readable shorthand notation for this, like \texttt{"a" || "b"}. Let us look in detail at what this parser combinator produces with some sample strings
 \begin{center}
 \begin{tabular}{rcl}
 input strings & & output\medskip\\
 \texttt{\Grid{acde}} & $\rightarrow$ & $\left\{(\texttt{\Grid{a}}, \texttt{\Grid{cde}})\right\}$\\
 overall result of the sequence parser combinator is pairs of the form
 $((\textit{output}_1, \textit{output}_2), u_2)$. This means the
 unprocessed parts of both parsers is the unprocessed parts the second
 parser $q$ produces as left-over. The processed parts of both parsers
 is just the pair of the outputs
-$(\textit{output}_1, \textit{output}_2)$. This behavious can be
+$(\textit{output}_1, \textit{output}_2)$. This behaviour can be
 implemented in Scala as follows:
 \begin{center}
 \begin{lstlisting}[language=Scala,numbers=none]
 class SeqParser[I, T, S]
 \noindent
 If any of the runs of \textit{p} and \textit{q} fail, that is produce
 the empty set, then \texttt{parse} will also produce the empty set.
 Notice that we have now two output types for the sequence parser
 combinator, because in general \textit{p} and \textit{q} might produce
-differetn things (for example first we recognise a number and then a
+different things (for example first we recognise a number and then a
 string corresponding to an operator).
 We have not yet looked at this in detail, but Scala allows us to
 provide some shorthand notation for the sequence parser combinator. We
 \texttt{\Grid{bacde}} & $\rightarrow$ & $\{\}$\\
 \texttt{\Grid{cccde}} & $\rightarrow$ & $\{\}$
 \end{tabular}
 \end{center}
-\noindent In the first line we have a sucessful parse, because the
+\noindent In the first line we have a successful parse, because the
 string started with \texttt{ab}, which is the prefix we are looking
 for. But since the parsing combinator is constructed as sequence of
 the two simple (atomic) parsers for \texttt{a} and \texttt{b}, the
 result is a nested pair of the form \texttt{((a, b), cde)}. It is
-\emph{not} a simple pair \texttt{(ab, cde)} as one might errorneously
+\emph{not} a simple pair \texttt{(ab, cde)} as one might erroneously
-expects.  The parser returns the ampty set in the other examples,
+expects.  The parser returns the empty set in the other examples,
 because they do not fit with what the parser is supposed to parse.
 A slightly more complicated parser is \pcode{("a" || "b") ~ "c"}
 which parses as first character either an \texttt{a} or \texttt{b}

changeset 586	451a95e1bc25
parent 585	6ee22f196884
child 587	5ddedcd92d84