A module for constructing indentation aware tokeniser that can be used in conjuction with Token. All the combinator takes a TokenParser as its first argument. For every field foo of TokenParser this module exports a combinator foo. To define a tokeniser for an indentation based language a user first defines the appropriate LanguageDef record, applies the combinator makeTokenParser to get a TokenParser record say tokP and then, instead of selecting the field foo of tokP, applies the combinator foo exported from this module to tokP. The semantics of the combinator foo is essentially same as that of the field foo of TokenParser but the returned parsers are indentation aware. Apart from these there are certain new combinators that are defined specifically for parsing certain indentation based syntactic constructs. (We have not defined squares use brackets instead)

There are two important classes of parser combinator exported by this module:

Grouping Parser Combinator

A grouping parser combinator takes as input a parser say p and returns a parser that parses p between two grouping delimiters. There are three flavours of grouping parsers: foo, fooOrBlock and fooOrLineFold where foo can be one of angles, braces, parens, brackets. To illustrate we take foo to be braces. The parser braces tokP p parses p delimited by '{' and '}'. In this case p does not care about indentation (i.e. the parser p is run in NoIndent mode). The parser bracesOrBlock tokP p is like braces tokP p but if no explicit delimiting braces are given parses p within an indented block. Similarly bracesOrLineFold tokP p parses p between '{' and '}' and uses line fold when no explicit braces are given. These can be two varients can be defined as follows

 bracesOrBlock tokP p    = braces tokP p <|> block p
 bracesOrLineFold tokP p = braces tokP p <|> lineFold p

Seperator Parser Combinator

A seperator parser combinator takes as input a parser say p and returns a parser that parses a list of p seperated by a seperator. The module exports the combinators fooSep, fooSep1, fooOrNewLineSep and fooOrNewLineSep1, where foo is either semi (in which case the seperator is a semicolon ';') or comma (in which case the seperator is a comma ',').

To illustrate the use of this module we now give, as an incomplete example, a parser that parses a where clause in Haskell which illustrates the use of this module.

   import qualified Text.ParserCombinators.Parsec.Language as L
   import qualified Text.ParserCombinators.Parsec.Toke as T
   import qualified Text.ParserCombinator.Parsec.IndentToken as IT

   tokP = T.makeTokenParser L.haskellDef
   semiOrNewLineSep = IT.semiOrNewLineSep tokP
   bracesOrBlock = IT.bracesOrBlock tokP
   identifier = IT.identifier tokP
   ....
   symbol = IT.symbol tokP

   binding = semiOrNewLineSep bind
   bind    = do id <- identifier
                symbol (char '=')
                e <- expr
                return (id,e)
  whereClause = do reserved "where"; braceOrBlock binding