How can I add my parentheses back into my expression when printing? - scala

Question

I wrote an expression simplifier that takes a string as input, converts it into a syntax tree, simplifies that tree, and then finally walks through the tree to convert the output back to a string. I am having a hard time figuring out how to get my parenthesis back into my expression when I am printing a nested solution such as: (a || !b) && c Right now my code gives me a solution of a || !b && c. It seems as though my solution is correct because the simplified tree outputs correctly, I just don't know how to add the parentheses when walking through it.
Here is my code:
import scala.util.parsing.combinator._
import scala.io.StdIn.readLine
abstract class Expression
case class And(l: Expression, r: Expression) extends Expression
case class Or(l: Expression, r: Expression) extends Expression
case class Not(arg: Expression) extends Expression
case class Var(n: Char) extends Expression
case object True extends Expression
case object False extends Expression
object Simplifier extends Combinators {
def eval(e: Expression): Expression = e match {
case Or(True, _) => True
case Or(_, True) => True
case Or(l, False) => l
case Or(False, r) => r
case Or(l, r) => {
val leval = eval(l)
val reval = eval(r)
(leval, reval) match {
case (True, _) => True
case (_, True) => True
case (l, False) => l
case (False, r) => r
case (leval, reval) => Or(eval(l),eval(r))
}
}
case And(True, r) => if(r == True) {return True} else {return r}
case And(l, True) => if(l == True) {return True} else {return l}
case And(False, _) => False
case And(_, False) => False
case And(l, r) => {
val leval = eval(l)
val reval = eval(r)
(leval, reval) match {
case (True, r) => if(r == True) {return True} else {return r}
case (l, True) => if(l == True) {return True} else {return l}
case (False, _) => False
case (_, False) => False
case (leval, reval) => And(eval(l), eval(r))
}
}
case Not(True) => False
case Not(False) => True
case Not(arg) => Not(eval(arg))
case Var(n) => Var(n)
}
def stringify(e: Expression): String = e match{
case Or(l, r) => {
stringify(l) + " || " + stringify(r)
}
case And(l, r) => {
stringify(l) + " && " + stringify(r)
}
case Not(arg) => {
"!" + stringify(arg)
}
case Var(n) => n.toString()
case True => "true"
case False => "false"
}
def main(args:Array[String]): Unit = {
var response: String = ""
do {
println("expression? ")
val input = readLine()
val expr: Expression = parseAll(e, input).get
println(eval(expr))
val simplifiedExpression: String = stringify(eval(expr))
println(simplifiedExpression)
println("Would you like to enter another expression? (y/n): ")
response = readLine()
} while (response != "n")
}
}
class Combinators extends JavaTokenParsers {
def e: Parser[Expression] = t ~ or ~ e ^^ {case l ~ _ ~ r => Or(l, r)} | t
def t: Parser[Expression] = f ~ and ~ t ^^ {case l ~ _ ~ r => And(l, r)} | f
def f: Parser[Expression] = not ~ a ^^ {case _ ~ arg => Not(arg)} | a
def a: Parser[Expression] = openparen ~ e ~ closeparen ^^ {case _ ~ e ~ _ => e} | c
def c: Parser[Expression] = "true" ^^ {case "true" => True} | "false" ^^ {case "false" => False} | z
def z: Parser[Var] = "[a-c]".r ^^ {str => Var(str.head)}
def and[Expression] = "&&"
def or[Expression] = "||"
def not[Expression] = "!"
def openparen[Expression] = "("
def closeparen[Expression] = ")"
}

Answer 1

Your stringify method never puts any parentheses, so that cannot be correct, as you figured out. The easiest improvement would be to always put parentheses instead. For example:
case Or(l, r) => {
"(" + stringify(l) + " || " + stringify(r) + ")"
}
And similarly for the other cases.