scala - kind-projector 返回奇怪的结果

Question

我有这些类型: SomeTypeClass
具有一个类型参数 kind * => * => *

的更高类型

trait SomeTypeClass[P[_, _]] {
    def test[F[_], S, T, A, B](f: (A => F[B]) => S => F[T])
                              (pab: P[A, B])
                              (implicit ev: Strong[P],
                              ev2: Choice[P],
                              ev3: Applicative[F]): P[S, T]
}

Target它接受三个类型参数:
type constructor F[_]和两个多态类型 A, B

case class Target[F[_], A, B](f: A => F[B])

我想实现一个 Target 的 SomeTypeClass 的实例。
我正在使用 kind-projector 插件来创建部分应用的类型。
我想要的方法签名应该是:

implicit def instance: SomeTypeClass[Target[F, *, *]] = new SomeTypeClass[Target[F, *, *]] {
  override def test[F[_], S, T, A, B](f: (A => F[B]) => S => F[T])
                                      (pab: Target[F, A, B])
                                      (implicit ev: Strong[Target[F, *, *]], 
                                       ev2: Choice[Target[F, *, *]], 
                                       ev3: Applicative[F]): Target[F, S, T] = ???
}

我试过用两个星形参数来使用这个语法:

 implicit def instance[F[_]]: SomeTypeClass[Target[F, *, *]] = new SomeTypeClass[Target[F, *, *]] {
    override def test[F[_], S, T, A, B](f: (A => F[B]) => S => F[T])
                                     (pab: Target[F, A, B])
                                     (implicit ev: Strong[Target[F, *, *]],
                                      ev2: Choice[Target[F, *, *]],
                                      ev3: Applicative[F]): Target[F, S, T] = ???
}

但是 F[_]在实例级别声明隐藏了 F[_]在测试方法中声明(我希望它们是相同的 F)，所以我转向了 λ 语法并得到了两个不同的不需要的结果。

第一个使用 λ[(F, A, B) => Target[F, A, B]]为 pab 生成参数， pab: Target[A, B, B]而不是 pab: Target[F, A, B]以及返回类型 Target[S, T, B]而不是 Target[F, S, T]

第二个使用三元组lambda参数末尾的F(为什么？？？)
λ[(A, B, F) => Target[F, A, B]]为 pab 生成了正确的类型参数和返回类型，但是对于每个隐式参数，类型 Strong[λ[(A, B, F) => Target[F, A, B]]]代替 Strong[Target[F, *, *]]]

完整代码:

  import cats.Applicative
  import cats.arrow.{Choice, Strong}

  final case class Target[F[_], A, B](f: A => F[B])

  trait SomeTypeClass[P[_, _]] {
    def test[F[_], S, T, A, B](f: (A => F[B]) => S => F[T])
                              (pab: P[A, B])
                              (implicit ev: Strong[P],
                               ev2: Choice[P],
                               ev3: Applicative[F]): P[S, T]
  }

  object SomeTypeClass {
    implicit def instance1: SomeTypeClass[λ[(F, A, B) => Target[F, A, B]]] = new SomeTypeClass[λ[(F, A, B) => Target[F, A, B]]] {
      override def test[F[_], S, T, A, B](f: (A => F[B]) => S => F[T])
                                         (pab: Target[A, B, B])
                                         (implicit ev: Strong[Target],
                                          ev2: Choice[Target],
                                          ev3: Applicative[F]): Target[S, T, B] = ???
    }

    implicit def instance2: SomeTypeClass[λ[(A, B, F) => Target[F, A, B]]] = new SomeTypeClass[λ[(A, B, F) => Target[F, A, B]]] {
      override def test[F[_], S, T, A, B](f: (A => F[B]) => S => F[T])
                                         (pab: Target[F, A, B])
                                         (implicit ev: Strong[λ[(A, B, F) => Target[F, A, B]]],
                                          ev2: Choice[λ[(A, B, F) => Target[F, A, B]]],
                                          ev3: Applicative[F]): Target[F, S, T] = ???
    }
  }

我可以使用这个插件实现我想要的语法吗？
为什么这个插件会生成不同的类型对于 lambda 的“参数”类型的不同顺序？

Answer 1

如果我明白了

But the F[_] declared at the instance level shadows the F[_] declared at the test method (I want them to be the same F)

正确地，您希望 SomeTypeClass[Target[...]] 的实例修复 test 的 F[_] 参数.但使用此 test 类型签名根本不可能做到这一点。一旦你有(例如)

val inst = implicitly[SomeTypeClass[Target[...]]

你可以打电话

val res1 = inst.test[List, ...]
val res2 = inst.test[Option, ...]

类型 lambda 不提供解决此问题的方法。您需要将 F[_] 参数移动到 SomeTypeClass 或实现

implicit def instance[F[_]]: SomeTypeClass[Target[F, *, *]] = new SomeTypeClass[Target[F, *, *]] {
  override def test[G[_], S, T, A, B](f: (A => G[B]) => S => G[T])
                                     (pab: Target[F, A, B])
                                     (implicit ev: Strong[Target[F, *, *]],
                                      ev2: Choice[Target[F, *, *]],
                                      ev3: Applicative[G]): Target[G, S, T] = ???
}

我认为这是不可能的，因为您不能将 pab.f 传递给 f。

编辑:漫游的类型

class (Choice p, Strong p) => Traversing p where
  traverse' :: Traversable f => p a b -> p (f a) (f b)
  traverse' = wander traverse

  wander :: (forall f. Applicative f => (a -> f b) -> s -> f t) -> p a b -> p s t
  wander f pab = dimap (\s -> Baz $ \afb -> f afb s) sold (traverse' pab)

是一个rank-2 type Scala 不直接支持这些；相反，您需要引入一个助手(不能只是类型别名 as it is in Control.Lens.Type )

trait Traversal[S, T, A, B] {
  def apply[F[_]: Applicative](f: A => F[B]): S => F[T]
}

然后

trait Traversing[P[_, _]] extends Strong[P] with Choice[P] {
  def wander[S, T, A, B](t: Traversal[S, T, A, B], pab: P[A, B]): P[S, T]
}

implicit def instance[F[_]: Applicative]: Traversing[Target[F, *, *]] = new Traversing[Target[F, *, *]] {
  def wander[S, T, A, B](t: Traversal[S, T, A, B], pab: Target[F, A, B]): Target[F, S, T] = Target(t(pab.f))
  // define Strong and Choice methods too
}

应该可以。 (虽然我不确定这是猫处理 Strong 和 Choice 要求的方式。)