Question

Given type erasure, what is the most efficient and elegant way to solve the following overloading definition:

trait Signal

trait Step[T] {
  def ar(implicit ev: T <:< Boolean): Signal
  def ar(implicit ev: T <:< Float  ): Signal
}

without using different names for Boolean and Float parametrisation? Ideally it would be T <:< Boolean union Float but that does not exist… Can I do without an extra implicit indirection?

Answer 1

The extra indirection would be this:

object Step {
  sealed trait SignalSource[T] { def toFloat(t: T): Float }
  implicit object BooleanSource extends SignalSource[Boolean] {
    def toFloat(t: Boolean) = if (t) 1f else 0f
  }
  implicit object FloatSource extends SignalSource[Float] {
    def toFloat(t: Float) = t
  }
}
trait Step[T] {
  def ar(implicit ev: Step.SignalSource[T]) : Signal
}