--- a/progs/parser-combinators/comb2.sc	Fri Sep 15 10:49:33 2023 +0100
+++ b/progs/parser-combinators/comb2.sc	Sun Sep 17 19:12:57 2023 +0100
@@ -43,7 +43,7 @@
 }
 
 // map parser
-class MapParser[I, T, S](p: => Parser[I, T], 
+class maparser[I, T, S](p: => Parser[I, T], 
                          f: T => S)(using I => Seq[_]) extends Parser[I, S] {
   def parse(in: I) = for ((hd, tl) <- p.parse(in)) yield (f(hd), tl)
 }
@@ -93,7 +93,7 @@
 extension [I, T](p: Parser[I, T])(using I => Seq[_]) {
   def ||(q : => Parser[I, T]) = new AltParser[I, T](p, q)
   def ~[S] (q : => Parser[I, S]) = new SeqParser[I, T, S](p, q)
-  def mapp[S](f: => T => S) = new MapParser[I, T, S](p, f)
+  def map[S](f: => T => S) = new maparser[I, T, S](p, f)
 }
 
 
@@ -125,47 +125,47 @@
 
 // arithmetic expressions
 lazy val AExp: Parser[String, AExp] = 
-  (Te ~ p"+" ~ AExp).mapp[AExp]{ case x ~ _ ~ z => Aop("+", x, z) } ||
-  (Te ~ p"-" ~ AExp).mapp[AExp]{ case x ~ _ ~ z => Aop("-", x, z) } || Te
+  (Te ~ p"+" ~ AExp).map[AExp]{ case x ~ _ ~ z => Aop("+", x, z) } ||
+  (Te ~ p"-" ~ AExp).map[AExp]{ case x ~ _ ~ z => Aop("-", x, z) } || Te
 lazy val Te: Parser[String, AExp] = 
-  (Fa ~ p"*" ~ Te).mapp[AExp]{ case x ~ _ ~ z => Aop("*", x, z) } || 
-  (Fa ~ p"/" ~ Te).mapp[AExp]{ case x ~ _ ~ z => Aop("/", x, z) } || Fa  
+  (Fa ~ p"*" ~ Te).map[AExp]{ case x ~ _ ~ z => Aop("*", x, z) } || 
+  (Fa ~ p"/" ~ Te).map[AExp]{ case x ~ _ ~ z => Aop("/", x, z) } || Fa  
 lazy val Fa: Parser[String, AExp] = 
-   (p"(" ~ AExp ~ p")").mapp{ case _ ~ y ~ _ => y } || 
-   IdParser.mapp(Var) || 
-   NumParser.mapp(Num)
+   (p"(" ~ AExp ~ p")").map{ case _ ~ y ~ _ => y } || 
+   IdParser.map(Var) || 
+   NumParser.map(Num)
 
 // boolean expressions with some simple nesting
 lazy val BExp: Parser[String, BExp] = 
-   (AExp ~ p"==" ~ AExp).mapp[BExp]{ case x ~ _ ~ z => Bop("==", x, z) } || 
-   (AExp ~ p"!=" ~ AExp).mapp[BExp]{ case x ~ _ ~ z => Bop("!=", x, z) } || 
-   (AExp ~ p"<" ~ AExp).mapp[BExp]{ case x ~ _ ~ z => Bop("<", x, z) } || 
-   (AExp ~ p">" ~ AExp).mapp[BExp]{ case x ~ _ ~ z => Bop(">", x, z) } ||
-   (p"(" ~ BExp ~ p")" ~ p"&&" ~ BExp).mapp[BExp]{ case _ ~ y ~ _ ~ _ ~ v => And(y, v) } ||
-   (p"(" ~ BExp ~ p")" ~ p"||" ~ BExp).mapp[BExp]{ case _ ~ y ~ _ ~ _ ~ v => Or(y, v) } ||
-   (p"true".mapp[BExp]{ _ => True }) || 
-   (p"false".mapp[BExp]{ _ => False }) ||
-   (p"(" ~ BExp ~ p")").mapp[BExp]{ case _ ~ x ~ _ => x }
+   (AExp ~ p"==" ~ AExp).map[BExp]{ case x ~ _ ~ z => Bop("==", x, z) } || 
+   (AExp ~ p"!=" ~ AExp).map[BExp]{ case x ~ _ ~ z => Bop("!=", x, z) } || 
+   (AExp ~ p"<" ~ AExp).map[BExp]{ case x ~ _ ~ z => Bop("<", x, z) } || 
+   (AExp ~ p">" ~ AExp).map[BExp]{ case x ~ _ ~ z => Bop(">", x, z) } ||
+   (p"(" ~ BExp ~ p")" ~ p"&&" ~ BExp).map[BExp]{ case _ ~ y ~ _ ~ _ ~ v => And(y, v) } ||
+   (p"(" ~ BExp ~ p")" ~ p"||" ~ BExp).map[BExp]{ case _ ~ y ~ _ ~ _ ~ v => Or(y, v) } ||
+   (p"true".map[BExp]{ _ => True }) || 
+   (p"false".map[BExp]{ _ => False }) ||
+   (p"(" ~ BExp ~ p")").map[BExp]{ case _ ~ x ~ _ => x }
 
 // a single statement 
 lazy val Stmt: Parser[String, Stmt] =
-  ((p"skip".mapp[Stmt]{_ => Skip }) ||
-   (IdParser ~ p":=" ~ AExp).mapp[Stmt]{ case x ~ _ ~ z => Assign(x, z) } ||
-   (p"write(" ~ IdParser ~ p")").mapp[Stmt]{ case _ ~ y ~ _ => Write(y) } ||
+  ((p"skip".map[Stmt]{_ => Skip }) ||
+   (IdParser ~ p":=" ~ AExp).map[Stmt]{ case x ~ _ ~ z => Assign(x, z) } ||
+   (p"write(" ~ IdParser ~ p")").map[Stmt]{ case _ ~ y ~ _ => Write(y) } ||
    (p"if" ~ BExp ~ p"then" ~ Block ~ p"else" ~ Block)
-     .mapp[Stmt]{ case _ ~ y ~ _ ~ u ~ _ ~ w => If(y, u, w) } ||
-   (p"while" ~ BExp ~ p"do" ~ Block).mapp[Stmt]{ case _ ~ y ~ _ ~ w => While(y, w) })   
+     .map[Stmt]{ case _ ~ y ~ _ ~ u ~ _ ~ w => If(y, u, w) } ||
+   (p"while" ~ BExp ~ p"do" ~ Block).map[Stmt]{ case _ ~ y ~ _ ~ w => While(y, w) })   
  
  
 // statements
 lazy val Stmts: Parser[String, Block] =
-  (Stmt ~ p";" ~ Stmts).mapp[Block]{ case x ~ _ ~ z => x :: z } ||
-  (Stmt.mapp[Block]{ s => List(s) })
+  (Stmt ~ p";" ~ Stmts).map[Block]{ case x ~ _ ~ z => x :: z } ||
+  (Stmt.map[Block]{ s => List(s) })
 
 // blocks (enclosed in curly braces)
 lazy val Block: Parser[String, Block] =
-  ((p"{" ~ Stmts ~ p"}").mapp{ case _ ~ y ~ _ => y } || 
-   (Stmt.mapp(s => List(s))))
+  ((p"{" ~ Stmts ~ p"}").map{ case _ ~ y ~ _ => y } || 
+   (Stmt.map(s => List(s))))
 
 
 // Examples