parser.ns

external record-fix(a : top) : top :=
  "{ [key in keyof a]: a[key] }"
external record-empty : top :=
  "{ }"
external record-singleton(key : string, value : top) : top :=
  "{ [k in key]: value }"
external record-merge(a : top, b : top) : top :=
  "(a & b)"
external space : string :=
  '" " | "\\n"'

enum unit :=
| mk-unit

enum result(a : top) :=
| ok(value : a, rest : string)
| fail

def parse-string(str : string, s : string) : result(unit) :=
  match s with
  | <.str, s> := ok(unit, mk-unit, s)
  | _ := fail(unit)
  end

def parse-space(s : string) : result(unit) :=
  match s with
  | <.space, s> := parse-space(s)
  | _ := ok(unit, mk-unit, s)
  end

def parse-name(s : string) : result(string) :=
  match s with
  | <name, ":", s> := ok(string, name, <":", s>)
  | _ := fail(string)
  end

mutual
  def parse-type(s : string) : result(top) :=
    match s with
    | <"number", s> := ok(top, number, s)
    | <"string", s> := ok(top, string, s)
    | <"boolean", s> := ok(top, boolean, s)
    | _ := parse-record(s)
    end

  def parse-field(s : string) : result(top) :=
    match parse-name(s) with
    | fail(string) := fail(top)
    | ok(string, (name : string), s) :=
      match parse-string(": ", s) with
      | fail(unit) := fail(top)
      | ok(unit, mk-unit, s) :=
        match parse-type(s) with
        | fail(top) := fail(top)
        | ok(top, type_, s) :=
          ok(top, record-singleton(name, type_), s)
        end
      end
    end

  def parse-fields(s : string) : result(top) :=
    match parse-field(s) with
    | fail(top) := ok(top, record-empty, s)
    | ok(top, field, s) :=
      match parse-string(",", s) with
      | fail(unit) := ok(top, field, s)
      | ok(unit, mk-unit, s) :=
        match parse-space(s) with
        | fail(unit) := fail(top)
        | ok(unit, mk-unit, s) :=
          match parse-fields(s) with
          | fail(top) := fail(top)
          | ok(top, fields, s) :=
            ok(top, record-merge(field, fields), s)
          end
        end
      end
    end

  def parse-record(s : string) : result(top) :=
    match parse-string("{", s) with
    | fail(unit) := fail(top)
    | ok(unit, mk-unit, s) :=
      match parse-space(s) with
      | fail(unit) := fail(top)
      | ok(unit, mk-unit, s) :=
        match parse-fields(s) with
        | fail(top) := fail(top)
        | ok(top, fields, s) :=
          match parse-space(s) with
          | fail(unit) := fail(top)
          | ok(unit, mk-unit, s) :=
            match parse-string("}", s) with
            | fail(unit) := fail(top)
            | ok(unit, mk-unit, s) :=
              ok(top, record-fix(fields), s)
            end
          end
        end
      end
    end
end

def run-type-result(result : result(top)) : top :=
  match result with
  | ok(top, value, "") := value
  | _ := bottom
  end

def result-number : top :=
  run-type-result(parse-type("number"))

def result-record : top :=
  run-type-result(
    parse-type(
      < "{\n"
      , "  a: number,  e: boolean,\n"
      , "    b: { c: string, d: string   } \n"
      , "  }"
      >
    )
  )