parser.plm

require "mod:thomasvergne/plume-combinator"
require "mod:thomasvergne/plume-combinator/library/char"

type Request {
  Request(
    str, // method
    str, // path
    Map<str, str> // headers
  )
}

fn cat_maybes<A extends equality>(ls: list<Option<A>>): list<A> =>
  ls.foldl(fn(acc, x) => switch x {
    case Some(x) => [x] + acc
    case None => acc
  }, [])

extend show<Request> {
  fn show_prec(m, i) => switch m {
    case Request(method, path, headers) =>
      "Request($method, $path, " + headers.show() + ")"
  }
}

parse_first_line: Parser<Option<(str, str)>> = 
  none_of([' ', '\n', '\r'])
    .many1()
    .map(implode)
    .sep_by_1(space)
    .lex()
  >>= fn (ls) => switch ls {
    case [method, path, ?] => pure(Some((method, path)))
    case ? => pure(None)
  }

parse_header: Parser<Option<(str, str)>> =
  none_of(['\n', '\r', ':'])
    .many1().lex()
    .map(implode)
    .sep_by_1(character(':'))
    .lex()
  >>= fn (ls) => switch ls {
    case [key, ..vs] => pure(Some((key, vs.join_str(":"))))
    case ? => pure(None)
  }

parse_http: Parser<Option<Request>> =
  parse_first_line
    .bind(fn (first_line) => switch first_line {
      case Some((method, path)) =>
        newline.many() >>
        parse_header
          .sep_by_1(newline.many1())
          .lex()
          .bind(fn (headers) {
            return pure(Some(Request(method, path, headers.cat_maybes())))
          }) << newline.many()
      case None => pure(None)
    })

fn parse_request(s: str): Result<Request, str> {
  s_ = s.explode()

  return parse_http.bind(fn(p) => switch p {
    case Some(r) => pure(r)
    case None => parse_error("parse err")
  }).run_parser(s_).fst()
}