Given a HList T0::T1:: ... Tn and type R is it possible to infer a function type T0=>T1 ...=> Tn => R?

Question

I want to create something that works like this

implicit class HListOps[AHList<:HList](value:AHList){
    def fold[R](folder: /*What here?*/)={

    }
}

so that it works like this

("HeY"::42::HNil).fold{string=>int=> string+int.toString} // returns "HeY42"

Answer 1

Well, after checking how this problem looks very similar to actually reversing an HList, I used a very similar approach and got this working:

import java.time.LocalDate

import scala.language.{higherKinds, reflectiveCalls}

import cats.Applicative
import shapeless._

trait HFolder[InL <: HList, Out] {
  type Fld
  def fold(inL: InL): Function1[Fld, Out]
}

object HFolder {

  implicit def nilHFolder[Out]: HFolder[HNil, Out] {type Fld = Out} = new HFolder[HNil, Out] {
    type Fld = Out

    override def fold(inL: HNil): Function1[Out, Out] = identity
  }

  implicit def consHFolder[InH, InT <: HList, Out]
  (implicit tailHFolder: HFolder[InT, Out]): HFolder[InH :: InT, Out] {type Fld = InH => tailHFolder.Fld} =
    new HFolder[InH :: InT, Out] {
      override type Fld = InH => tailHFolder.Fld

      override def fold(inL: InH :: InT): Function1[InH => tailHFolder.Fld, Out] = {
        folder =>
          inL match {
            case inH :: inT => tailHFolder.fold(inT)(folder(inH))
          }
      }
    }

  implicit class HListOps[InL <: HList](inL: InL) {
    def fold[Out](implicit hfolder: HFolder[InL, Out]): Function[hfolder.Fld, Out] = {
      hfolder.fold(inL)
    }

  }

  //Here compiler can infer correct info (in this case (String=>Int=>LocalDate)=>LocalDate)
  val folder= ("Alejo" :: 29 :: HNil).fold[LocalDate] 


}

Only small problem is that after calling the method fold I have to invoke it using the word apply without syntactic sugar because otherwise compiler thinks I'm passing the implicit explicitly.

Answer 2

I don't think it is directly possible using some type classes in Shapeless, but it is possible to do a similar thing for a function of type (T0, T1, ...) => R:

implicit class HListOps[L <: HList](value: L) {
  def fold[R, F](folder: F)(implicit ftp: FnToProduct.Aux[F, L => R]): R = {
    ftp(folder).apply(value)
  }
}

(1 :: "a" :: HNil).fold((x: Int, y: String) => y + x)

Unfortunately, you still have to specify parameters for the function type explicitly. It could be theoretically possible to define the extension class to this:

implicit class HListOps2[L <: HList, F, R](value: L)(implicit ftp: FnToProduct.Aux[F, L => R]) {
  def fold(folder: F): R = ftp(folder).apply(value)
}

This, however, would require you to know the result type "in advance", which is quite unergonomic (and won't really work with the definition above, but it is possible to make it work with a bit more code).

You can overcome the last problem by requiring the function to accept a tuple instead:

  implicit class HListOps3[L <: HList, T](value: L)(implicit tup: Tupler.Aux[L, T]) {
    def fold[R](folder: T => R): R = folder(tup(value))
  }

  (1 :: "a" :: HNil).fold { case (x, y) => y + x }

This way, you won't need to specify argument types for the function, but rather the function itself should accept a tuple, which is also a bit of ergonomic hit because you will have to use the partial function syntax to unpack arguments from the tuple argument.