O código a seguir é deProgramação dinâmica do Pathikrit repositório. Estou confuso por sua beleza e peculiaridade.

def subsetSum(s: List[Int], t: Int) = {
  type DP = Memo[(List[Int], Int), (Int, Int), Seq[Seq[Int]]]
  implicit def encode(key: (List[Int], Int)) = (key._1.length, key._2)

  lazy val f: DP = Memo {
    case (Nil, 0) => Seq(Nil)
    case (Nil, _) => Nil
    case (a :: as, x) => (f(as, x - a) map {_ :+ a}) ++ f(as, x)
  }

  f(s, t)
}

O tipoMemo é implementado em outro arquivo:

case class Memo[I <% K, K, O](f: I => O) extends (I => O) {
  import collection.mutable.{Map => Dict}
  val cache = Dict.empty[K, O]
  override def apply(x: I) = cache getOrElseUpdate (x, f(x))
}

Minhas perguntas são:

Porque étype K declarado como(Int, Int) no subsetSum?

O que faz oint no(Int, Int) representam respectivamente?

3. Como(List[Int], Int) converter implicitamente para(Int, Int)?
Não vejoimplicit def foo(x:(List[Int],Int)) = (x._1.toInt,x._2). (nem mesmo noImplicits.scala arquivo que importa.

* Edit: Bem, eu sinto falta disso:

implicit def encode(key: (List[Int], Int)) = (key._1.length, key._2)

Gosto da biblioteca de Pathikritscalgos muito. Há muitas pérolas Scala nele. Por favor, me ajude com isso para que eu possa apreciar a inteligência de Pathikrit. Obrigado. (: