Scala, interesting Puzzle with Implicits - scala

Question

here is an interesting puzzle that I can not solve for a few days.
A class takes a function and gives out a string. Main thing is that it puts parentheses when a priority of an argument becomes negative. The goal is to find such a relationship of value, literal and operation, that the parentheses will be at initial place
Known is that:
literal * variable is e.g 2X and not 2 * X
Priority of X (or any other variable) is 5
Priority of 42 (e.g 42.lit or 4.lit * 2.lit which one is unknown) is 4
Priority of X * Y * 2 is 3
Priority of -X * Y * 3 is 1
object Main {
trait Expr[T] {
def literalInt(value: Int): T
def variable(name: String): T
def times(x: T, y: T): T
def plus(x: T, y: T): T
def minus(x: T, y: T): T = plus(x, negate(y))
def negate(x: T): T = times(x, literalInt(-1))
}
object exprSyntax {
def literalInt[T](value: Int)(implicit expr: Expr[T]): T = expr.literalInt(value)
def X[T](implicit expr: Expr[T]): T = expr.variable("x")
def Y[T](implicit expr: Expr[T]): T = expr.variable("y")
def Z[T](implicit expr: Expr[T]): T = expr.variable("z")
implicit class IntToExpr[T](x: Int)(implicit expr: Expr[T]) {
def lit: T = expr.literalInt(x)
}
implicit class NumOps[T](val x: T) extends AnyVal {
def +(y: T)(implicit expr: Expr[T]): T = expr.plus(x, y)
def -(y: T)(implicit expr: Expr[T]): T = expr.minus(x, y)
def *(y: T)(implicit expr: Expr[T]): T = expr.times(x, y)
def unary_-(implicit expr: Expr[T]): T = expr.negate(x)
}
}
final case class Print(s: String, priority: Int, isLit: Boolean = false) {
def print(outer: Int = 0) = if (outer <= priority) s else s"($s)"
}
// interesting starts from here
object Expr {
implicit val stringOrderExpr: Expr[Print] = new Expr[Print] {
override def literalInt(value: Int): Print = Print(value.toString, priority = ???, isLit = true)
override def variable(name: String): Print = Print(name.toUpperCase, priority = ???)
override def times(x: Print, y: Print): Print = {
if (x.isLit){
val print = Print(s"${x.s}${y.s}", priority = ???).print()
Print(print, priority = ???)
}
else {
val print = Print(s"${x.s}*${y.s}", priority = ???).print()
Print(print, priority = ???)
}
}
override def plus(x: Print, y: Print): Print = {
val print = Print(s"${x.s}+${y.s}".toUpperCase, priority = ???).print()
Print(print, y.priority - x.priority)
}
override def minus(x: Print, y: Print): Print = {
val print = Print(s"${x.s}-${y.s}", priority = ???).print()
Print(print, priority = ???)
}
override def negate(x: Print): Print = {
val print = Print(s"-${x.s}", priority = ???).print()
Print(print, priority = ???)
}
}
}
def main(args: Array[String]): Unit = {
import Main.exprSyntax._
def function[T: Main.Expr]: T = X * X + 2.lit * (Y + Z * X * 2.lit) - 7.lit * Z + 4.lit
println(function[Main.Print].priority) // X*X+2(Y+Z*X*2)-7Z+4
}
}