How to transform an HList to another HList with foldRight/foldLeft

Question

This question is derived from my previous question: What does HList#foldLeft() return?

I have this scenario:

class Cursor {
}

trait Column[T] {
   def read(c: Cursor, index: Int): T
}

object Columns {
    object readColumn extends Poly2 {
        implicit def a[A, B <: HList] = at[Column[A], (B, Cursor, Int)] { case (col, (values, cursor, index)) ⇒
            (col.read(cursor, index) :: values, cursor, index+1)
        }
    }

    def readColumns[A <: HList, B <: HList](c: Cursor, columns: A)(implicit l: RightFolder.Aux[A, (HNil.type, Cursor, Int), readColumn.type, (B, Cursor, Int)]): B =
        columnas.foldRight((HNil, c, 0))(readColumn)._1
}

This code, tries to read the values of several columns.

If I call readColumns(cursor, new Column[String] :: new Column[Int] :: HNil), I expect to get String :: Int :: HNil.

The readColumns() method compiles ok, but the compiler complains about implicits in concrete invocations.

What is the right way of working?.

UPDATE 1:

Here is the exact error message I'm receiving when invoking with 2 columns:

could not find implicit value for parameter l: 
shapeless.ops.hlist.RightFolder.Aux[shapeless.::[Column[String],shapeless.::
[Column[String],shapeless.HNil]],(shapeless.HNil.type, android.database.Cursor, Int),readColumn.type,(B, android.database.Cursor, Int)]

Don't know how to help the compiler. :-(

UPDATE 2:

Question: why specify HNil.type in the implicit parameter of readColumns(): RightFolder.Aux[A, (HNil.type, Cursor, Int), readColumn.type, (B, Cursor, Int)] ?

Travis Brown · Accepted Answer · 2015-01-24T19:42:20.620

Update to address edits

Here's a complete working example:

class Cursor {}

trait Column[T] {
   def read(c: Cursor, index: Int): T
}

import shapeless._, ops.hlist.RightFolder

object Columns {
  object readColumn extends Poly2 {
    implicit def a[A, B <: HList]: Case.Aux[
      Column[A],
      (B, Cursor, Int),
      (A :: B, Cursor, Int)
    ] = at[Column[A], (B, Cursor, Int)] {
      case (col, (values, cursor, index)) =>
        (col.read(cursor, index) :: values, cursor, index + 1)
    }
  }

  def readColumns[A <: HList, B <: HList](c: Cursor, columns: A)(implicit
    l: RightFolder.Aux[
      A,
      (HNil, Cursor, Int),
      readColumn.type,
      (B, Cursor, Int)
    ]
  ): B = columns.foldRight((HNil: HNil, c, 0))(readColumn)._1
}

And then:

val stringColumn = new Column[String] {
  def read(c: Cursor, index: Int) = "foo"
}

val intColumn = new Column[Int] {
  def read(c: Cursor, index: Int) = 10
}

Columns.readColumns(new Cursor, stringColumn :: intColumn :: HNil)

This compiles just fine and does what I'd expect on both 2.0.0 and 2.1.0-RC1.

And I should have mentioned in my original answer that using HNil.type like that isn't ideal—it works just fine, but explicitly typing the HNil in the argument to foldRight as HNil is a better solution. Note that you have to do one or the other, since the static type of HNil is HNil.type, and RightFolder isn't covariant in its second argument.

Original answer

There's a very minor error in your readColumn definition—you're returning a Tuple4, but you want to return a Tuple3. The following should work:

    object readColumn extends Poly2 {
       implicit def a[A, B <: HList]: Case.Aux[
         Column[A],
         (B, Cursor, Int),
         (A :: B, Cursor, Int)
       ] = at[Column[A], (B, Cursor, Int)] {
          case (col, (values, cursor, index)) =>
           (col.read(cursor, index) :: values, cursor, index+1)
       }
    }

It's usually a good idea to provide an explicit return type for any implicit method for unrelated reasons having to do with implicit resolution, but in this case being explicit about the return type also turns up the error pretty quickly.

Thanks, it is now better. Why do I have to specify `HNil.type` for `readColumns()` implicit parameter?. It still doesn't work for concrete invocations. :-( — david.perez, Oct 29 '14 at 14:42
Hmm, invoking `readColumns` worked for me when I set up a simple example. I'll take a look, but probably won't have a chance until later this afternoon. — Travis Brown, Oct 29 '14 at 14:54
I've updated the question with the exact error message I'm receiving, for better diagnostic. — david.perez, Oct 30 '14 at 10:52
Note that in the expression `HNil: HNil`, the first term refers to `object HNil` whereas the 2nd to `trait HNil`. — david.perez, Feb 26 '15 at 08:32
Your sample works ok in the Scala REPL, but not in regular source files. I keep having the problem with compiler not being able to generate the implicit parameter to `readColumns()`. Shapeless is powerful but tricky. :-( — david.perez, Feb 26 '15 at 08:42

How to transform an HList to another HList with foldRight/foldLeft

1 Answers1

Update to address edits

Original answer