Poly fold return type not inferred correctly - scala

Question

I am trying to create a poly function that folds over a tuple of Foos:
case class Foo[A](a: A)
object extractFold extends Poly2 {
implicit def default[A, As <: HList]: Case.Aux[Foo[A], Foo[As], Foo[A :: As]] = {
???
}
}
def extract[In, A <: HList, B <: HList](keys: In)
(implicit
gen: Generic.Aux[In, A],
folder: RightFolder.Aux[A, Foo[HNil], extractFold.type, Foo[B]],
tupler: Tupler[B])
: Foo[tupler.Out] = {
???
}
val result = extract((Foo(1), Foo("a")))
The function works at runtime, but the compiler inferred result type is always Foo[Unit] which is not right - in this example it should be Foo[(Int, String)]

Answer 1

Why do you think that
the compiler inferred result type is always Foo[Unit]
?
The following code
import shapeless.ops.hlist.{RightFolder, Tupler}
import shapeless.{::, Generic, HList, HNil, Poly2}
import scala.reflect.runtime.universe.{typeOf, Type, TypeTag}
object App {
def getType[T: TypeTag](t: T): Type = typeOf[T]
case class Foo[A](a: A)
object extractFold extends Poly2 {
implicit def default[A, As <: HList]: Case.Aux[Foo[A], Foo[As], Foo[A :: As]] =
at { case (Foo(a), Foo(as)) => Foo(a :: as) }
}
def extract[In, A <: HList, B <: HList](keys: In)(implicit
gen: Generic.Aux[In, A],
folder: RightFolder.Aux[A, Foo[HNil], extractFold.type, Foo[B]],
tupler: Tupler[B]
): Foo[tupler.Out] =
Foo(tupler(folder(gen.to(keys), Foo(HNil)).a))
val result = extract((Foo(1), Foo("a")))
def main(args: Array[String]): Unit = {
println(
getType(result)
)
}
}
prints
App.Foo[(Int, java.lang.String)]
Moreover, if you change the line
val result: Foo[Unit] = extract((Foo(1), Foo("a")))
the code doesn't compile.
By the way, the same can be done with
import shapeless.PolyDefns.~>
import shapeless.ops.hlist.{Comapped, NatTRel, Tupler}
import shapeless.{Generic, HList, Id}
object App {
case class Foo[A](a: A)
def extract[In, A <: HList, B <: HList](keys: In)(implicit
gen: Generic.Aux[In, A],
comapped: Comapped.Aux[A, Foo, B],
natTRel: NatTRel[A, Foo, B, Id],
tupler: Tupler[B]
): Foo[tupler.Out] =
Foo(tupler(natTRel.map(new (Foo ~> Id) { def apply[T](foo: Foo[T]) = foo.a }, gen.to(keys))))
val result = extract((Foo(1), Foo("a")))
def main(args: Array[String]): Unit = {
println(result)//Foo((1,a))
}
}

Answer 2

Maybe someone with a better understanding of shapeless can provide you a better answer. According to my understanding the problem lies at the type inference step. If you specify all the types explicitly as in
val result: Foo[(Int, String)] = extract[(Foo[Int], Foo[String]),
Foo[Int] :: Foo[String] :: HNil,
Int :: String :: HNil]((Foo(1), Foo("a")))
the code correctly typechecks. Obviously you don't want to specify those types explicitly though.
According to my understanding the compiler can't infer good B and tupler.Out because they are not coupled tight enough to In and A. One way you can work this around is by introducing an intermediate trait like this:
trait Extractor[L <: HList, HF] {
type FR <: HList
type TR
val folder: RightFolder.Aux[L, Foo[HNil], HF, Foo[FR]]
val tupler: Tupler.Aux[FR, TR]
}
object Extractor {
type Aux[L <: HList, HF, FR0 <: HList, TR0] = Extractor[L, HF] {type FR = FR0; type TR = TR0}
implicit def wrap[L <: HList, In, HF, FR0 <: HList, TR0](implicit folder0: RightFolder.Aux[L, Foo[HNil], HF, Foo[FR0]],
tupler0: Tupler.Aux[FR0, TR0]) = new Extractor[L, HF] {
type FR = FR0
type TR = TR0
override val folder = folder0
override val tupler = tupler0
}
}
and then using it like this:
def extract[In, A <: HList, B <: HList, C](keys: In)
(implicit gen: Generic.Aux[In, A],
extractor: Extractor.Aux[A, extractFold.type, B, C])
: Foo[C] = {
val hli = gen.to(keys)
val fr = extractor.folder(hli, Foo(HNil))
Foo(extractor.tupler(fr.a))
}
This is a hacky solution but at least it seem to work (see also online demo).