Scala Natural Transformation from DSL to Function - scala

Question

I'm trying to perform a Natural Transformation between kinds of * -> * -> *
so I want to take F[A, B] => G[A, B]
Specifically I'm trying to define a DSL that I can then convert into actual function definitions, so MyDSL[A, B] => Function[A, B]
Here is the Natural Transformation definition:
trait ~~>[F[_, _], G[_, _]] {
def apply[A, B](fab: F[A, B]): G[A, B]
}
object ~~> {
def apply[F[_, _], G[_, _]](implicit f2g: F ~~> G): F ~~> G = f2g
}
The DSL looks like so:
sealed trait MyDSL[A, B]
object MyDSL {
case object Add1 extends MyDSL[Int, Int]
case object Show extends MyDSL[Int, String]
implicit def dsltoF: MyDSL ~~> Function = new ~~>[MyDSL, Function] {
override def apply[A, B](fab: MyDSL[A, B]): Function[A, B] = fab match {
case Add1 => i => i + 1
case Show => i => i.toString
}
}
}
Using the Natural Transformation directly works fine:
dsltoF(Add1)
output: res0: Function[Int,Int] = MyDSL$$anon$2$$Lambda$1816/700824958#6f3aa425
It even works in the case where the function returned is a method taking 2 type parameters.
When I try to define a DSL object that converts using a generic method of one type parameter it has issues.
case class Id[A]() extends MyDSL[A, A]
implicit def dsltoF: MyDSL ~~> Function = new ~~>[MyDSL, Function] {
override def apply[A, B](fab: MyDSL[A, B]): Function[A, B] = fab match {
case Id() => identity[A] _
case Add1 => i => i + 1
case Show => i => i.toString
}
}
I get a found A required B compilation error.
Scala doesn't recognize that B is A in this case.
I get why, as the type parameters A & B aren't necessarily correlated properly to the definition of the function I am returning, therefore even writing:
case Add1 => i => i + 1
there is red lines in IntelliJ as it doesn't realize that even though Add "is a" MyDSL[Int, Int]. Though Scala is ok with this.
The type parameters are open to all possibilities on the method signature of apply on the Natural Transformation, but in this case it needs some sort of restriction. My guess is since there is no value within the DSL case class to restrict the type parameter, it comes down to the pattern match, which is already past where Scala interprets the signature of the method, and therefore it expects a different type B and it barks.
I can of course get around this via .asInstanceOf nastiness, but I mean come on.
Any thoughts of a different strategy to get this to work would be appreciated.

Answer 1

That's a known restriction in the type inference system in the current versions of the language, which should be lifted in future versions.
In this case, you can use type variables in the pattern match to work around this restriction:
import scala.language.higherKinds
trait ~~>[F[_, _], G[_, _]] {
def apply[A, B](fab: F[A, B]): G[A, B]
}
object ~~> {
def apply[F[_, _], G[_, _]](implicit f2g: F ~~> G): F ~~> G = f2g
}
sealed trait MyDSL[A, B]
object MyDSL {
case class Id[A]() extends MyDSL[A, A]
case class Const[A, B](constantResult: B) extends MyDSL[A, B]
case object Add1 extends MyDSL[Int, Int]
case object Show extends MyDSL[Int, String]
implicit def dsltoF: MyDSL ~~> Function = new (MyDSL ~~> Function) {
override def apply[A, B](fab: MyDSL[A, B]): Function[A, B] = fab match {
case _: Id[x] => identity[x] _
case c: Const[a, b] => (_ => c.constantResult)
case Add1 => i => i + 1
case Show => i => i.toString
}
}
}
Essentially: if there is no "place" where the compiler could deposit more specific type information, just give it a type-variable in the pattern so it can attach the inferred type information to it.