Устранение неполадок, связанных с аргументами функции для обработки списка дисков с использованием Shapeless

Question

Следующий гист имеет код для идеи, с которой я играю

package com.test1

import scala.language.implicitConversions
import shapeless._
import FromTraversable._
import Traversables._
import Nat._
import Tuples._

trait ToArity[P, N <: Nat]

object ToArity {
  implicit def prod1[P <: Product1[_]] = new ToArity[P, _1] {}
  implicit def prod2[P <: Product2[_, _]] = new ToArity[P, _2] {}
  // ad nauseum...
}

trait SizedHListAux[A, N <: Nat, T <: HList]

object SizedHListAux {
  implicit def base[A, H <: HList] = new SizedHListAux[A, _0, HNil] {}
  implicit def induct[A, H <: HList, N <: Nat, P <: Nat](implicit r: PredAux[N,P], k: SizedHListAux[A, P, H]) = new SizedHListAux[A, N, A :: H] {}
}

trait SomeFun {
  type Result
  def apply(): Result
}

// I want to abstract over A, the contained type in the List
// over P the Product type which is the arg notably its arity
// This means we need to recover arity of the Product type and render it in value space
// and also means that we need to compute the type of the intermediate HList
object SomeFun {
  def produce(m: SomeFun): m.Result = m()

  implicit def fromF1[T, A, P <: Product, N <: Nat, H <: HList](f1: (P => T, List[A]))(implicit k: ToArity[P, N], toI: ToInt[N], l: SizedHListAux[A, N, H], toHL: FromTraversable[H], tp: TuplerAux[H, P]) =
    new SomeFun {
      type Result = (T, List[A])
      def apply(): Result = {
        val (f, as) = f1
        val (ts, rest) = (as.take(toI()), as.drop(toI()))
        f((toHL(ts).get).tupled) -> rest
      }
    }
  // Debug Arity checker
  def printArity[P <: Product, N <: Nat](p: P)(implicit k: ToArity[P, N], toI: ToInt[N]) = println("Arity: " + toI())
}

object Test {
  val thedata = List("foo", "bar", "baz", "bob")
  val tfn = (x: (String, String)) => println("%s and %s".format(x._1, x._2))
  def foo = SomeFun.printArity("a" -> "b")
  //def doit = SomeFun.produce((tfn, thedata)) // Adding this line does not compile
}

Идея состоит в том, что вы используете аргументарность функции, в данном случае арентность типа Product, для анализа синтаксиса связанного List[A]. Вроде как использование клейкой ленты для отделения слоев графена от графита, то есть тип функций вытягивает вещи из списка. Это просто набросок с использованием одного отдельного типа, но я думаю, что он может быть обобщен. Важным аспектом является то, что сами функции не знают о обработке списка.

Тем не менее... концепция, кажется, терпит неудачу при попытке разрешить ToArity[P,N] неявно. Самостоятельно ToArity разрешима, о чем свидетельствует printArity().

Может кто-то пролить свет на то, почему это не разрешимо в контексте fromF1? Может быть, он не может разрешить все зависимые импликации, а затем регистрирует ошибку с первым, то есть не может быть найдено N, чтобы удовлетворить ToArity, ToInt и SizedHListAux?

Answer 1

Обновление: я только что видел ваше изменение, что означает, что вы уже обратились к проблеме, упомянутой в первых двух параграфах, но я надеюсь, что остальное будет полезно.

Проблема в том, что ваш SizedHListAux экземпляр не выводится:

scala> implicitly[SizedHListAux[String, _1, String :: HNil]]
<console>:25: error: could not find implicit value for parameter e...

К счастью, это легко исправить:

object SizedHListAux {
  implicit def base[A] = new SizedHListAux[A, _0, HNil] {}
  implicit def induct[A, H <: HList, N <: Nat, P <: Nat](implicit
    r: PredAux[N, P],
    k: SizedHListAux[A, P, H]
  ) = new SizedHListAux[A, N, A :: H] {}
}

Я только что удалил R <: PredAux[N, P] введите параметр и набрал r соответственно. Я также удалил параметр неиспользуемого типа H на baseхотя это не вызывало проблем - оно просто ничего не делало.

Это почти все - теперь все случаи для fromF1 получить вывод:

scala> SomeFun.fromF1((tfn, thedata))
res0: SomeFun{type Result = (Unit, List[String])} = SomeFun$$anon$1@7eacbeb

Вы все еще не собираетесь получить представление о типе (tfn, thedata) в SomeFun, хоть. Рассмотрим следующий упрощенный пример:

scala> trait Foo
defined trait Foo

scala> trait Bar[A, B]
defined trait Bar

scala> implicit def toInt[F <: Foo, X](f: F)(implicit ev: Bar[F, X]) = 42
toInt: [F <: Foo, X](f: F)(implicit ev: Bar[F,X])Int

scala> implicit object fooBar extends Bar[Foo, String]
defined module fooBar

scala> toInt(new Foo {})
res0: Int = 42

scala> implicitly[Foo => Int]
<console>:12: error: No implicit view available from Foo => Int.
              implicitly[Foo => Int]

Таким образом, хотя у нас есть неявный метод в области видимости, который преобразует Foo в Int, тот X создает проблемы для компилятора, когда он пытается найти представление из Foo в Int,

В вашем случае я бы избежал этого ограничения, пропустив SomeFun бизнес и имеющий метод, который занимает (P => T, List[A]) и возвращает (T, List[A]),

Я также буду наблюдать, что оба ToArity а также SizedHListAux кажется ненужным, так как вы можете собрать те же доказательства с TuplerAux, LengthAux, а также LUBConstraint, Например:

import shapeless._

trait SomeFun {
  type Result
  def apply(): Result
}

implicit def fromF1[T, A, P <: Product, N <: Nat, H <: HList](
  f1: (P => T, List[A])
)(implicit
  tp: TuplerAux[H, P],
  hl: LengthAux[H, N],
  toHL: FromTraversable[H],
  allA: LUBConstraint[H, A],
  toI: ToInt[N]
) = new SomeFun {
  type Result = (T, List[A])
  def apply(): Result = {
    val (f, as) = f1
    val (ts, rest) = (as.take(toI()), as.drop(toI()))
    f((toHL(ts).get).tupled) -> rest
  }
}

А потом:

val tfn = (x: (String, String)) => println("%s and %s".format(x._1, x._2))
val thedata = List("foo", "bar", "baz", "bob")
val sf = fromF1((tfn, thedata))

И наконец:

scala> sf()
foo and bar
res2: (Unit, List[String]) = ((),List(baz, bob))

Не раздражает prodN Образец необходим.