Question

我有和ADT基本上是Function1的包装：

case class Abstract[M[_], A, B](f:M[A] => M[B]) {
    def fn: M[A] => M[B] = { case x: M[A] => f(x) }
}

我想映射这些，所以我定义了一个类似的Functor：

trait AbstractAPI[E] {
    type AbsO[T] = Abstract[List, E, T]
    // type AbsO[T] = Abstract[List, _, T] => does not work (?)

    implicit val abstractO: Functor[AbsO] = new Functor[AbsO] {
        def map[A, B](fa: AbsO[A])(f: A => B): AbsO[B] = {
            new Abstract(fa.fn andThen { x: List[A] => x.map{ y => f(y) } })
        }
    }
}

现在，要实际映射抽象，我需要AbstractAPI[Int]，如

case object IntAbstractAPI extends AbstractAPI[Int]

object A {
    import IntAbstractAPI._

    val f:List[Int] => List[String] = { case x: List[Int] => x.map{ _.toString.toLowerCase } }
    val hey = (new Abstract(f)).map{ x => x.toInt }
}

或

object A extends AbstractAPI[Int] {

    val f:List[Int] => List[String] = { case x: List[Int] => x.map{ _.toString.toLowerCase } }

    // FINALLY!
    val res = (new Abstract(f)).map{ x => x.toInt }.map{ _.toFloat + 10f }
    // Abstract[List, Int, Float] = Abstract(<function1>)
}

但是，在这种模式中，我必须为每个可能的E定义案例对象。以下是我的问题：

这是使用Functors的正确方法吗？
如何为每个可能的E自动创建案例对象（或让编译器推断它？）

编辑1：进一步说明：上述实施方案有效，但这个没有：

object A extends AbstractAPI {

    val f:List[Int] => List[String] = { case x: List[Int] => x.map{ _.toString.toLowerCase } }

    val res = (new Abstract(f)).map{ x => x.toInt }.map{ _.toFloat + 10f }
    // Abstract[List, Int, Float] = Abstract(<function1>)
}

给出了编译错误：

value map is not a member of Abstract[List,Int,String]

我认为这是因为编译器无法为Abstract[List,Int,String]派生一个仿函数？

Answer 1

回答第二个问题，你可以试试这个隐含的AbstractAPI[T]工厂：

implicit def abstractAPI[T]: AbstractAPI[T] = new AbstractAPI[T] {}

AbstractAPI[T]所需的任何隐含证据均应有效，例如：

def f[T : AbstractAPI]: Unit = ()
f

Answer 2

你可以派生一个你不关心的类型参数的仿函数。

import cats.Functor
import cats.syntax.functor._

我会将Abstract上的第二个类型参数重命名为X，它会帮助

case class Abstract[M[_], X, A](f: M[X] => M[A]) // forget the fn bit for now

您不仅可以使用val创建类型类实例，还可以使用def创建类型类实例。它允许有类型参数，也可以采用其他隐式（但只是隐式）参数。

type Abs1[X] = ({ type L[A] = Abstract[List, X, A] })

/*implicit*/ def abstract1[X]: Functor[Abs1[X]#L] = new Functor[Abs1[X]#L] {
override def map[A, B](fa: Abstract[List, X, A])(f: A => B): Abstract[List, X, B] =
      Abstract(mx => fa.f(mx).map(f))
}

如果您需要map List，则可以进一步推广任何M[_]实例的Functor。将它放入Abstract的伴随对象中也可以在没有额外导入/继承/等的情况下找到它。

object Abstract {
  // Abstract.MX[M, X]#L can be replaced with Abstract[M, X, ?] if you use kind-projector
  type MX[M[_], X] = ({ type L[A] = Abstract[M, X, A] })

  implicit def genericFunctor[M[_]: Functor, X] = new Functor[MX[M, X]#L] {
    override def map[A, B](fa: Abstract[M, X, A])(f: A => B): Abstract[M, X, B] =
      Abstract(mx => fa.f(mx).map(f)) // the implementation is the same
  }
}

如果你为M[_]

的任何内容导入实例，它就可以了

assert {
  import cats.instances.list._ // get Functor[List]

  // map is automatically picked up from Functor[Abstract[List, Int, ?]]
  Abstract(identity[List[Int]])
    .map(Vector.range(0, _))
    .map(_.mkString(""))
    .f(List(1, 2, 3)) == List("0", "01", "012")
}

assert {
  import cats.instances.option._

  Abstract(identity[Option[Int]])
    .map(_ min 42)
    .map(i => Range(i, i + 3))
    .f(Some(11)) == Some(Range(11, 14))
}

您可以尝试代码there

Scala：如何将Functors用于多类型参数特征

2 个答案: