Write You a Haskell Stephen Diehl

Parsing
Parser Combinators
For parsing in Haskell it is quite common to use a family of libraries known as parser combinators which
let us compose higher order functions to generate parsers. Parser combinators are a particularly expressive
pattern that allows us to quickly prototype language grammars in an small embedded domain language
inside of Haskell itself. Most notably we can embed custom Haskell logic inside of the parser.
NanoParsec
So now let’s build our own toy parser combinator library which we’ll call NanoParsec just to get the feel
of how these things are built.
{-# OPTIONS_GHC -fno-warn-unused-do-bind #-}
module NanoParsec where
import Data.Char
import Control.Monad
import Control.Applicative
Structurally a parser is a function which takes an input stream of characters and yields a parse tree by
applying the parser logic over sections of the character stream (called lexemes) to build up a composite
data structure for the AST.
newtype Parser a = Parser { parse :: String -> [(a,String)] }
Running the function will result in traversing the stream of characters yielding a value of type a that
usually represents the AST for the parsed expression, or failing with a parse error for malformed input,
or failing by not consuming the entire stream of input. A more robust implementation would track the
position information of failures for error reporting.
runParser :: Parser a -> String -> a
runParser m s =
31