afl-material: comparison solutions/cw3/parser.sc

equal deleted inserted replaced

-:c7009356ddd8
+:c0600f8b6427
 // CW3
-import $file.lexer
+//> using file project.scala
-import lexer._
+//> using file lexer.sc
+import lexer.*
 case class ~[+A, +B](x: A, y: B)
 // parser combinators
+//
-abstract class Parser[I, T](using is: I => Seq[_])  {
+type IsSeq[I] = I => Seq[?]
-def parse(in: I): Set[(T, I)]
+abstract class Parser[I : IsSeq, T](using is: I => Seq[?])  {
+def parse(in: I): Set[(T, I)]
 def parse_all(in: I) : Set[T] =
 for ((hd, tl) <- parse(in);
 if is(tl).isEmpty) yield hd
 }
+// parser combinators
 // alternative parser
-class AltParser[I, T](p: => Parser[I, T],
+class AltParser[I : IsSeq, T](p: => Parser[I, T],
-q: => Parser[I, T])(using I => Seq[_]) extends Parser[I, T] {
+q: => Parser[I, T]) extends Parser[I, T] {
 def parse(in: I) = p.parse(in) ++ q.parse(in)
 }
 // sequence parser
-class SeqParser[I, T, S](p: => Parser[I, T],
+class SeqParser[I : IsSeq, T, S](p: => Parser[I, T],
-q: => Parser[I, S])(using I => Seq[_]) extends Parser[I, ~[T, S]] {
+q: => Parser[I, S]) extends Parser[I, ~[T, S]] {
 def parse(in: I) =
 for ((hd1, tl1) <- p.parse(in);
 (hd2, tl2) <- q.parse(tl1)) yield (new ~(hd1, hd2), tl2)
 }
 // map parser
-class MapParser[I, T, S](p: => Parser[I, T],
+class MapParser[I : IsSeq, T, S](p: => Parser[I, T],
-f: T => S)(using I => Seq[_]) extends Parser[I, S] {
+f: T => S) extends Parser[I, S] {
 def parse(in: I) = for ((hd, tl) <- p.parse(in)) yield (f(hd), tl)
 }
 /*
 // atomic parser for (particular) strings
 case class StrParser(s: String) extends Parser[String, String] {
 val (prefix, suffix) = sb.splitAt(s.length)
 if (prefix == s) Set((prefix, suffix)) else Set()
 }
 }
 extension (sc: StringContext)
 def p(args: Any*) = StrParser(sc.s(args:_*))
 */
 // more convenient syntax for parser combinators
-extension [I, T](p: Parser[I, T])(using I => Seq[_]) {
+extension [I : IsSeq, T](p: Parser[I, T]) {
-def ||(q : => Parser[I, T]) = new AltParser[I, T](p, q)
+def ||(q : => Parser[I, T]) = AltParser[I, T](p, q)
-def ~[S] (q : => Parser[I, S]) = new SeqParser[I, T, S](p, q)
+def ~[S] (q : => Parser[I, S]) = SeqParser[I, T, S](p, q)
-def map[S](f: => T => S) = new MapParser[I, T, S](p, f)
+def map[S](f: => T => S) = MapParser[I, T, S](p, f)
 }
 // New parser that takes as input a list of tokens
 case class TokenParser(t: Token) extends Parser[List[Token], Token] {
 def parse(in: List[Token]) = {
 // an example of an atomic parser for characters
 if (!in.isEmpty && in.head == t) Set((t, in.tail)) else Set()
 }
 }
 case class TokenListParser(ts: List[Token]) extends Parser[List[Token], List[Token]] {
 def parse(tsb: List[Token]) = {
 val (prefix, suffix) = tsb.splitAt(ts.length)
 if (prefix == ts) Set((prefix, suffix)) else Set()
 }
 }
 // Implicit definitions to go from a token
 // or a list of tokens to a TokenListParser
 implicit def token2parser(t: Token) : Parser[List[Token], Token] =
 TokenParser(t)
 extension (t: Token) {
-def || (q : => Parser[List[Token], Token]) =
+def || (q : => Parser[List[Token], Token]) = AltParser[List[Token], Token](t, q)
-new AltParser[List[Token], Token](t, q)
+def ~[S](q : => Parser[List[Token], S]) = SeqParser[List[Token], Token, S](t, q)
-def ~[S](q : => Parser[List[Token], S]) =
-new SeqParser[List[Token], Token, S](t, q)
 }
 // Abstract Syntax Trees
 abstract class Stmt
 }
 }
 // WHILE Language Parsing
 lazy val AExp: Parser[List[Token], AExp] =
 (Te ~ T_OP("+") ~ AExp).map{ case x ~ _ ~ z => Aop("+", x, z): AExp } ||
 (Te ~ T_OP("-") ~ AExp).map{ case x ~ _ ~ z => Aop("-", x, z): AExp } || Te
 lazy val Te: Parser[List[Token], AExp] =
 (Fa ~ T_OP("*") ~ Te).map{ case x ~ _ ~ z => Aop("*", x, z): AExp } ||
 (Fa ~ T_OP("/") ~ Te).map{ case x ~ _ ~ z => Aop("/", x, z): AExp } ||
 (Fa ~ T_OP("%") ~ Te).map{ case x ~ _ ~ z => Aop("%", x, z): AExp } || Fa
 lazy val Fa: Parser[List[Token], AExp] =
 (T_PAREN("(") ~ AExp ~ T_PAREN(")")).map{ case _ ~ y ~ _ => y } ||
 IdParser().map{Var(_)}  ||
 NumParser().map{Num(_)}
 lazy val BExp: Parser[List[Token], BExp] =
 (AExp ~ T_OP("==") ~ AExp).map{ case x ~ _ ~ z => Bop("==", x, z): BExp } ||
 (AExp ~ T_OP("!=") ~ AExp).map{ case x ~ _ ~ z => Bop("!=", x, z): BExp } ||
 (AExp ~ T_OP("<") ~ AExp).map{ case x ~ _ ~ z => Bop("<", x, z): BExp } ||
 (AExp ~ T_OP(">") ~ AExp).map{ case x ~ _ ~ z => Bop(">", x, z): BExp } ||
 (T_PAREN("(") ~ BExp ~ T_PAREN(")") ~ T_OP("&&") ~ BExp).map{ case _ ~ y ~ _ ~ _ ~ v => And(y, v): BExp } ||
 (T_PAREN("(") ~ BExp ~ T_PAREN(")") ~ T_OP("||") ~ BExp).map{ case _ ~ y ~ _ ~ _ ~ v => Or(y, v): BExp } ||
 (T_KEYWORD("true").map(_ => True: BExp )) ||
 (T_KEYWORD("false").map(_ => False: BExp )) ||
 (T_PAREN("(") ~ BExp ~ T_PAREN(")")).map{ case _ ~ x ~ _ => x }
 lazy val Stmt: Parser[List[Token], Stmt] =
 T_KEYWORD("skip").map(_ => Skip: Stmt) ||
 (IdParser() ~ T_OP(":=") ~ AExp).map{ case id ~ _ ~ z => Assign(id, z): Stmt } ||
 (T_KEYWORD("if") ~ BExp ~ T_KEYWORD("then") ~ Block ~ T_KEYWORD("else") ~ Block).map{ case _ ~ y ~ _ ~ u ~ _ ~ w => If(y, u, w): Stmt } ||
 (T_KEYWORD("while") ~ BExp ~ T_KEYWORD("do") ~ Block).map{ case _ ~ y ~ _ ~ w => While(y, w) : Stmt } ||
 (T_KEYWORD("read") ~ IdParser()).map{ case _ ~ id => Read(id): Stmt} ||
 (T_KEYWORD("write") ~ IdParser()).map{ case _ ~ id => WriteId(id): Stmt} ||
 (T_KEYWORD("write") ~ StringParser()).map{ case _ ~ s => WriteString(s): Stmt} ||
 (T_KEYWORD("write") ~ T_PAREN("(") ~ IdParser() ~ T_PAREN(")")).map{ case _ ~ _ ~ id ~ _ => WriteId(id): Stmt} ||
 (T_KEYWORD("write") ~  T_PAREN("(") ~ StringParser() ~ T_PAREN(")")).map{ case _ ~ _ ~ s ~ _ => WriteString(s): Stmt}
 lazy val Stmts: Parser[List[Token], Block] =
 (Stmt ~ T_SEMI ~ Stmts).map{ case x ~ _ ~ z => x :: z : Block } ||
 import scala.io.StdIn.readInt
 def eval_stmt(s: Stmt, env: Env) : Env = s match {
 case Skip => env
 case Assign(x, a) => env + (x -> eval_aexp(a, env))
 case If(b, bl1, bl2) => if (eval_bexp(b, env)) eval_bl(bl1, env) else eval_bl(bl2, env)
 case While(b, bl) =>
 if (eval_bexp(b, env)) eval_stmt(While(b, bl), eval_bl(bl, env))
 else env
 case WriteId(x) => { print(env(x)) ; env }
 case WriteString(x) => {
 print(x.replaceAll("\"", "").replaceAll("""\\n""", "\n")) ;
 env
 }
 case Read(x) => {
 println("Enter an integer and press ENTER:") ;
 val n = readInt() ; // Note: Does not work when using the REPL
 eval_stmt(Assign(x, Num(n)), env)
 }
 }
 def eval_bl(bl: Block, env: Env) : Env = bl match {
 case Nil => env
 //println(eval(Stmts.parse_all(tokenise(os.read(os.pwd / "primes.while"))).head))
-@main
+//@main
 def run(file: String) = {
 val contents = os.read(os.pwd / file)
 println(s"Lex $file: ")
 println(tokenise(contents))
 println(s"Parse $file: ")
 println(Stmts.parse_all(tokenise(contents)).head)
 println(s"Eval $file: ")
 println(eval(Stmts.parse_all(tokenise(contents)).head))
 }
-@main
+//@main
 def test(file: String) = {
 val contents = os.read(os.pwd / file)
 println(s"Lex $file: ")
 println(tokenise(contents))
 println(s"Parse $file: ")
 println(eval(Stmts.parse_all(tokenise(os.read(os.pwd / "primes.while"))).head))
 val end = System.nanoTime()
 println("Time taken in seconds: ")
 println((end - start)/(1.0e9))
 */
+test("primes.while")
+run("primes.while")

changeset 961	c0600f8b6427
parent 959	64ec1884d860
child 974	0cb4bf2469d1