:load matcher.scala

// some regular expressions

val LETTER = RANGE("abcdefghijklmnopqrstuvwxyz".toList)

val ID = PLUS(LETTER)

val DIGIT = RANGE("0123456789".toList)

val NONZERODIGIT = RANGE("123456789".toList)

val NUMBER = ALT(SEQ(NONZERODIGIT, STAR(DIGIT)), "0")

val LPAREN = CHAR('(')

val RPAREN = CHAR(')')

val WHITESPACE = PLUS(RANGE(" \n".toList))

val OPS = RANGE("+-*".toList)

// for classifying the strings that have been recognised

abstract class Token

case object T_WHITESPACE extends Token

case class T_NUM(s: String) extends Token

case class T_ID(s: String) extends Token

case class T_OP(s: String) extends Token

case object T_LPAREN extends Token

case object T_RPAREN extends Token

case object T_IF extends Token

case object T_THEN extends Token

case object T_ELSE extends Token

def tokenizer(rs: List[Rule[Token]], s: String) : List[Token] = 

  tokenize(rs, s.toList).filterNot(_ match {

    case T_WHITESPACE => true

    case _ => false

  })

// lexing rules for arithmetic expressions

val lexing_rules: List[Rule[Token]]= 

  List(("if", (s) => T_IF),

       ("then", (s) => T_THEN),

       ("else", (s) => T_ELSE),

       (NUMBER, (s) => T_NUM(s.mkString)),

       (ID, (s) => T_ID(s.mkString)),

       (WHITESPACE, (s) => T_WHITESPACE),

       (LPAREN, (s) => T_LPAREN),

       (RPAREN, (s) => T_RPAREN),

       (OPS, (s) => T_OP(s.mkString)))

// parser combinators with return type T

abstract class Parser[T] {

  def parse(ts: List[Token]): Set[(T, List[Token])]

  def parse_all(ts: List[Token]) : Set[T] =

    for ((head, tail) <- parse(ts); if (tail == Nil)) yield head

  def || (right : => Parser[T]) : Parser[T] = new AltParser(this, right)

  def ==>[S] (f: => T => S) : Parser [S] = new FunParser(this, f)

  def ~[S] (right : => Parser[S]) : Parser[(T, S)] = new SeqParser(this, right)

  def ~>[S] (right : => Parser[S]) : Parser[S] = this ~ right ==> (x => x._2)

  def <~[S] (right : => Parser[S]) : Parser[T] = this ~ right ==> (x => x._1)

}

class SeqParser[T, S](p: => Parser[T], q: => Parser[S]) extends Parser[(T, S)] {

  def parse(sb: List[Token]) = 

    for ((head1, tail1) <- p.parse(sb); 

         (head2, tail2) <- q.parse(tail1)) yield ((head1, head2), tail2)

}

class AltParser[T](p: => Parser[T], q: => Parser[T]) extends Parser[T] {

  def parse (sb: List[Token]) = p.parse(sb) ++ q.parse(sb)   

}

class FunParser[T, S](p: => Parser[T], f: T => S) extends Parser[S] {

  def parse (sb: List[Token]) = 

    for ((head, tail) <- p.parse(sb)) yield (f(head), tail)

}

case class TokParser(tok: Token) extends Parser[Token] {

  def parse(ts: List[Token]) = ts match {

    case t::ts if (t == tok) => Set((t, ts)) 

    case _ => Set ()

  }

}

implicit def token2tparser(t: Token) = TokParser(t)

case object NumParser extends Parser[Int] {

  def parse(ts: List[Token]) = ts match {

    case T_NUM(s)::ts => Set((s.toInt, ts)) 

    case _ => Set ()

  }

}

lazy val E: Parser[Int] = (T ~ T_OP("+") ~ E) ==> { case ((x, y), z) => x + z } || T  

lazy val T: Parser[Int] = (F ~ T_OP("*") ~ T) ==> { case ((x, y), z) => x * z } || F

lazy val F: Parser[Int] = (T_LPAREN ~> E <~ T_RPAREN) || NumParser

println(E.parse_all(tokenizer(lexing_rules, "1 + 2 + 3")))

println(E.parse_all(tokenizer(lexing_rules, "1 + 2 * 3")))

println(E.parse_all(tokenizer(lexing_rules, "(1 + 2) * 3")))

println(E.parse_all(tokenizer(lexing_rules, "(1 - 2) * 3")))

println(E.parse_all(tokenizer(lexing_rules, "(1 + 2) * - 3")))