Python-like parser example

[VinnyVicious]

Would be very useful to have an example on how to parse grammars like Python, where indentation is important.

[Just-Helpful]

If you're looking to parse indentation based grammars, a naïve way to implement this would be to use a "block parser":

use nom::{
  bytes::{is_not, tag},
  error::ParseError,
  multi::many0,
  sequence::{delimited, pair, preceded},
  Parser,
};

/// Parses an indented block of condent, returning the unindented string
pub fn indented_block<'a, E: ParseError<&'a str>>(
) -> impl Parser<&'a str, Output = String, Error = E> {
  // create parser
  let indented_parser = many0(preceded(tag("\n\t"), is_not("\n")));

  // collect lines
  indented_parser.map(|lines| {
    lines
      .into_iter()
      .map(|line| format!("\n{}", line))
      .collect::<String>()
  })
}

pub struct AstIf {
  /// @todo should be an AST expression
  condition: String,
  /// @todo should be a AST block of statements
  block: String,
}

/// Parses an if block that uses `String`s for condition an subblock
pub fn if_block<'a, E: ParseError<&'a str>>() -> impl Parser<&'a str, Output = AstIf, Error = E> {
  let parser = pair(
    delimited(tag("if "), is_not(":"), tag(":")),
    indented_block(),
  );

  parser.map(|(condition, block)| AstIf {
    condition: condition.into(),
    block,
  })
}

This is naïve because it repeatedly parses a block for every level that it is indented.
A more sophisticated parser could wrap the input in a custom type that strips a given number of indents whilst parsing...

[Just-Helpful]

Or you could parse in multiple steps:

1. a parser that separates lines and calculates indent levels
2. a parser that uses these levels to reconstruct the AST / Grammar