Shapeless：hlist编译时出现foldLeft

Question

Can not get foldLeft working on HList when folding to List, when i fold Hlist to a string everything works fine.

object wrapInList extends Poly1 {
  implicit def intCase = at[Int]{v => List(v)}
  implicit def stringCase = at[String]{v => List(v)}
}

object mergeToString extends Poly1 {
  implicit def intCase = at[Int](_.toString())
  implicit def stringCase = at[String](identity)
}

object foldListPoly extends Poly2 {
  implicit  def foldToList[T](implicit st: wrapInList.Case.Aux[T, List[T]]) =
    at[List[T], T]{ (acc, t) => acc ::: wrapInList(t) }
  implicit def foldToString[T](implicit st: mergeToString.Case.Aux[T, String]) =
    at[String, T]{ (acc, t) => acc + mergeToString(t)}
}

val hList = "aoeu" :: 42 :: HNil
val foldedHlist = hList.foldLeft("")(foldListPoly)
val foldedHList2 = hList.foldLeft(Nil)(foldListPoly)

---

Erorr on compiling foldedHList2

could not find implicit value for parameter folder:
shapeless.ops.hlist.LeftFolder[shapeless.::[String,shapeless.::[Int,shapeless.HNil]],scala.collection.immutable.Nil.type,com.test.Test.foldListPoly.type]

Answer 1

Please note that shapeless defines a runtimeList method on HList which efficiently computes a List[Any] from an HList , and also a toList method which converts an HList to a more precisely typed List . Nevertheless, it's interesting to see how this operation can be performed using fold .

There are a couple of wrinkles here. The first thing to consider is what the type of the List you are accumulating here should be. Most likely you would want the element type of the resulting list to be the least upper bound (LUB) of the types of the elements of the HList you're folding over. To get a result of that type we need to compute LUBs as we go.

We also need to accommodate Nil as the initial value. Nil is a value of type List[Nothing] and this is problematic in cases where we need to resolve an implicit indexed by List[T] . The type variable T would have to be instantiated at Nothing to match the type of Nil , but unfortunately Scala's type inferencer treats the type Nothing as the value of a type variable as meaning "unsolved" ... the result of this is that implicit resolution would fail spuriously. To work around this problem we have to provide an explicit case of foldListPoly for Nil.type .

Putting this together we end up with,

object wrapInList extends Poly1 {
  implicit def default[T] = at[T]{v => List(v)}
}

object foldListPoly extends Poly2 {
  implicit  def foldToListNil[U](implicit st: wrapInList.Case.Aux[U, List[U]]) =
    at[Nil.type, U]{ (acc, u) => wrapInList(u) }

  implicit  def foldToList[T, U, L, LL](
    implicit st: wrapInList.Case.Aux[U, List[U]],
    lub: Lub[T, U, L],
    llub: Lub[List[T], List[U], LL],
    ev: LL =:= List[L]
  ) = at[List[T], U]{ (acc, u) => llub.left(acc) ::: llub.right(wrapInList(u)) }
}

scala> ("aoeu" :: 42 :: HNil).foldLeft(Nil)(foldListPoly)
res0: List[Any] = List(aoeu, 42)

scala> (13 :: 23 :: HNil).foldLeft(Nil)(foldListPoly)
res1: List[Int] = List(13, 23)

scala> (23 :: true :: HNil).foldLeft(Nil)(foldListPoly)
res2: List[AnyVal] = List(23, true)

Notice that in each case the element type of the resulting list is the LUB of the element types of the HList .

Answer 2

The problem is that you generate a List[String] for "aoeu" in wrapInList which isn't compatible with the next element of hList (42, which is an Int ). If you can live with List[Any] (as opposed to the least upper bound), you can do it like this:

object wrapInList extends Poly1 {
  implicit def intCase = at[Int]{v => List[Any](v)}
  implicit def stringCase = at[String]{v => List[Any](v)}
}

object foldListPoly extends Poly2 {
  implicit  def foldToList[T](implicit st: wrapInList.Case.Aux[T, List[Any]]) =
    at[List[Any], T]{ (acc, t) => acc ::: wrapInList(t) }
}

Additionally, you have to explicitly type Nil as List[Any] :

val foldedHList2 = hList.foldLeft(Nil:List[Any])(foldListPoly)