我正在尝试实现一个函数,该函数可以处理具有mapflatMap方法的类型。 我已经为Traversable了它,但是这不包括FutureOption 所以我决定使用我自己的界面,使用类型类:

trait CanMap[A, M[_]] {
  def map[B](l: M[A])(f: A => B): M[B]
  def flatMap[B](l: M[A])(f: A => M[B]): M[B]
}

我已经为Option实现了这个:

  implicit def canmapopt[A] = new CanMap[A, Option] {
    def map[B](l: Option[A])(f: A => B): Option[B] = l.map(f)
    def flatMap[B](l: Option[A])(f: A => Option[B]): Option[B] = l.flatMap(f)
  }

而且这个效果很好。 现在我想为Traversable任何子类型实现它,我尝试了一个非常接近Option的实现:

  implicit def canmaptrav[A, B, T[B] <: Traversable[B]] = new CanMap[A, T] {
    def map[B](l: T[A])(f: A => B): T[B] = l.map(f)
    def flatMap[B](l: T[A])(f: A => T[B]): T[B] = l.flatMap(f)
  }

但我得到错误:

  type mismatch;  found   : Traversable[B]  required: T[B]  Note: implicit method canmaptrav is not applicable here because it comes after the application point and it lacks an explicit result type

对于l.map的返回类型。 我无法理解为什么l.map(f)会返回Traversable而不是特定类型T[B] 所以我试着在上下文中明确地输入正确类型的CanBuildFrom:

  implicit def canmaptrav[A, B, T[B] <: Traversable[B]](implicit cbf: CanBuildFrom[T[A], B, T[B]]) = new CanMap[A, T] {
    def map[B](l: T[A])(f: A => B): T[B] = l.map(f)
    def flatMap[B](l: T[A])(f: A => T[B]): T[B] = l.flatMap(f)
  }

错误仍然存​​在。

知道我哪里错了吗? 这可能是显而易见的,但我对我猜的通用类型签名感到困惑。

更新:解决方案

首先,正如答案所指出的, CanMap主要是Functor / Monad,所以如果你敢,你可以使用scalaz来实现它。 但是,如果你像我一样想在没有它的情况下尝试,那么根据Kipton Barros的答案,这是解决方案:

trait CanMap[A, B, M[_]] {
  def map(l: M[A])(f: A => B): M[B]
  def flatMap(l: M[A])(f: A => M[B]): M[B]
}

implicit def canmapopt[A, B] = new CanMap[A, B, Option] {
  def map(l: Option[A])(f: A => B): Option[B] = l.map(f)
  def flatMap(l: Option[A])(f: A => Option[B]): Option[B] = l.flatMap(f)
}

implicit def canmaptrav[A, B, M[+_]](implicit bf: CanBuildFrom[M[A], B, M[B]], ev: M[A] => TraversableLike[A, M[A]], eb: M[B] => TraversableLike[B, M[B]]) = new CanMap[A, B, M] {
  def map(l: M[A])(f: (A) => B): M[B] = l.map(f)
  def flatMap(l: M[A])(f: A => M[B]): M[B] = l.flatMap[B, M[B]] { (a: A) =>
    f(a)
  }
} 

诀窍是使用隐式转换M[A] => TraversableLike[A, M[A]]而不是尝试子类型Traversable

===============>>#1 票数:4 已采纳

第一个问题是Traversable map方法中的“引擎盖下”有很多问题。 返回最具体的集合类型需要做一些工作,这就是你需要CanBuildFrom 第二个问题是Option没有实现Traversable接口,因此它的map方法不会使用CanBuildFrom

这是我能得到的最接近的,

import scala.collection.generic.CanBuildFrom
import collection.TraversableLike

trait CanMap[A, M[_]] {
  def map[B](l: M[A])(f: A => B)(implicit bf: CanBuildFrom[M[A], B, M[B]]): M[B]
}

object Test {

  // ugly hack to work around nonexistent CanBuildFrom for Option
  implicit def optionBuilder[A, B]: CanBuildFrom[Option[A], B, Option[B]] = null

  implicit def canmapopt[A] = new CanMap[A, Option] {
    def map[B](l: Option[A])(f: A => B)(implicit bf: CanBuildFrom[Option[A], B, Option[B]]): Option[B] = l.map(f)
  }

  implicit def canmaptrav[A, M[_]](implicit ev: M[A] => TraversableLike[A, M[A]]) = new CanMap[A, M] {
    def map[B](l: M[A])(f: (A) => B)(implicit bf: CanBuildFrom[M[A], B, M[B]]): M[B] = l.map(f)
  }

  // example usage

  def mapper[A, B, M[_]](l: M[A])(f: A => B)(implicit cm: CanMap[A,M], bf: CanBuildFrom[M[A], B, M[B]]) = {
    cm.map(l)(f)
  }
  mapper(List(1,2,3))(_ + 1)          // List(2,3,4)
  mapper(Some(2): Option[Int])(_ + 1) // Some(3)
  // (cast to Option[Int] is needed to find the canmapopt implicit)
}

顺便说一句,隐式转换为TraversableLike使得它也适用于数组,

 mapper(Array(1,2,3))(_ + 1)         // Array(2, 3, 4)

===============>>#2 票数:2

首先,我尝试了两次失败的尝试,并没有从中得到很多。 然后我决定简单地做我自己的CanMap实现。 我最终得到了这个:

  def canmaptrav[A] = new CanMap[A, Traversable]{
    def map[B](l: Traversable[A])(f: A => B): Traversable[B]= l.map(f)
    def flatMap[B](l: Traversable[A])(f: A => Traversable[B]): Traversable[B] = l.flatMap(f)
  }

完全看CanMap[_,Option] 假设您正在寻找的子类型是这样的用例:

canmaptrav[Int].map(List(1,2,3,4))(_ + 1)       //> res0: Traversable[Int] = List(2, 3, 4, 5)
canmaptrav[Int].map(Vector(1,2,3,4))(_ + 1)     //> res1: Traversable[Int] = Vector(2, 3, 4, 5)

现在,如果你想让res1和res0类型成为具体类型(List,Vector),那么方法确实要依赖于CanBuildFrom

顺便说一下,你知道CanMap几乎就是Monad界面吗?

===============>>#3 票数:2

Scalaz已经包含了这些类型类,它们被称为MonadFunctor 一个简短的例子:

// map
def foo[F[_] : Functor](xs: F[Int]) = xs.map(_ + 1)

scala> foo(List(1,2,3))
res2: List[Int] = List(2, 3, 4)

// flatMap
def flatten[M[_] : Monad](xs: M[M[Int]]) = xs.flatMap(identity)

scala> flatten(List(List(1,2,3)))
res3: List[Int] = List(1, 2, 3)

编辑

Future的仿函数实例可能如下所示:

implicit object FutureFunctor extends Functor[Future] {
  def map[A,B](fa: Future[A])(f: A => B) = fa.map(f)
}

  ask by Mortimer translate from so

未解决问题?本站智能推荐: