Btukfyl

I am writing a little toy language built on top of expressions. Here is some code to get the idea:

trait Expression[+T] {

  def eval: T

}



case class Literal[+T](value: T) extends Expression[T] {

  def eval = value

}

The parser builds a tree of expressions which are then evaluated by calling the eval method. Now I want to add a Sum expression that represents the sum of two other expressions:

case class Sum[+T: Numeric](left: Expression[T], right: Expression[T]) {

  def eval = implicitly[Numeric[T]].plus(left.eval, right.eval)

}

This works fine if the left and right expression have the same type (as specified by the constructor). But naturally I would like it to work in the following case as well:
Sum(Literal(1.1), Literal(1))

This does not work because the compiler does not find an implicit argument of type Numeric[AnyVal], which makes sense.

I came up with the following code, using type bounds, to try to fix the issue:

case class Sum2[+T: Numeric, L <% T, R <% T](left: Expression[L], right: Expression[R]) extends Expression[T] {

  def eval = implicitly[Numeric[T]].plus(left.eval, right.eval)

}

Now the compiler complains that left.eval and right.eval are not of type T. Casting to T using asInstanceOf[T] generates more compiler errors because of ambiguous implicit arguments.

What is the proper way to achieve this?

As it was pointed in the comments, the fact that there is safe conversion from Int to Double for your operation is not enough for the compiler to be able prove that this conversion is valid in all relevant contexts. I'm not aware of any simpler way to achieve what you want than this code (see also online):

trait Expression[+T] {

  def eval: T

}



trait TypeConverter[S, T] {

  def convert(value: S): T

}



trait TypeConverterLowPriority {

  implicit def compose[A, B, C](implicit aToB: TypeConverter[A, B], bToC: TypeConverter[B, C]): TypeConverter[A, C] = new TypeConverter.TypeConverterImpl(a => bToC.convert(aToB.convert(a)))

}



object TypeConverter extends TypeConverterLowPriority {



  class TypeConverterImpl[S, T](f: S => T) extends TypeConverter[S, T] {

    override def convert(value: S): T = f(value)

  }



  def sameType[T]: TypeConverter[T, T] = new TypeConverterImpl(identity)





  implicit val intToDouble: TypeConverter[Int, Double] = new TypeConverterImpl(_.toDouble)

  implicit val shortToInt: TypeConverter[Short, Int] = new TypeConverterImpl(_.toInt)

  // add more "primitive" type conversions here



}



case class Literal[+T](value: T) extends Expression[T] {

  def eval = value

}





trait BinaryOpImpl[A, B, R] {

  protected val numericR: Numeric[R]

  protected val aToR: TypeConverter[A, R]

  protected val bToR: TypeConverter[B, R]



  final def eval(left: A, right: B): R = evalImpl(aToR.convert(left), bToR.convert(right))



  protected def evalImpl(left: R, right: R): R

}





trait BinaryOpImplCompanionLowPriority[Ops[_, _, _]] {

  protected def build[A, B, R](numericR: Numeric[R], aToR: TypeConverter[A, R], bToR: TypeConverter[B, R]): Ops[A, B, R]



  implicit def castLeftToRight[L, R: Numeric](implicit tcl: TypeConverter[L, R]): Ops[L, R, R] = build(implicitly[Numeric[R]], tcl, TypeConverter.sameType)



  implicit def castRightToLeft[L: Numeric, R](implicit tcr: TypeConverter[R, L]): Ops[L, R, L] = build(implicitly[Numeric[L]], TypeConverter.sameType, tcr)



}



trait BinaryOpImplCompanion[Ops[_, _, _]] extends BinaryOpImplCompanionLowPriority[Ops] {

  implicit def sameType[T: Numeric]: Ops[T, T, T] = build(implicitly[Numeric[T]], TypeConverter.sameType, TypeConverter.sameType)

}



class SumImpl[A, B, R](val numericR: Numeric[R], val aToR: TypeConverter[A, R], val bToR: TypeConverter[B, R]) extends BinaryOpImpl[A, B, R] {

  override protected def evalImpl(left: R, right: R): R = numericR.plus(left, right)

}



object SumImpl extends BinaryOpImplCompanion[SumImpl] {

  override protected def build[A, B, R](numericR: Numeric[R], aToR: TypeConverter[A, R], bToR: TypeConverter[B, R]): SumImpl[A, B, R] = new SumImpl(numericR, aToR, bToR)

}



case class Sum[+T, L, R](left: Expression[L], right: Expression[R])(implicit impl: SumImpl[L, R, T]) extends Expression[T] {

  def eval = impl.eval(left.eval, right.eval)

}

usage example:

def test(): Unit = {

  println(Sum(Literal(3), Literal(1)).eval)

  println(Sum(Literal(1.1), Literal(1)).eval)

  println(Sum(Literal(1), Literal(1.1)).eval)

  println(Sum(Literal[Short](1), Literal(1.12)).eval) // composite conversion Short -> Int -> Double

}

Essentially the idea is to have one implicit variable that encapsulates all 3 relevant types instead of having 3 separate implicits. So the code complies if the compiler can build one composite evidence for a triplet LeftArgType-RightArgType-ResultType.

the problem specifically is that Sum(Literal(1.1), Literal(1)) has a Literal[Double] on the left and a Literal[Int] on the right. The LUB of Int and Double is indeed AnyVal as you have seen.

https://scalafiddle.io/sf/ALM9urR/1

works perfectly fine. I also think this is good behavior because adding different types can be a bit iffy but else you could introduce an implicit that lets you do the necessary conversions.