高等类型参数的（co | in）方差

Question

the code in question

trait Functor[F[_]] {
  def map[A, B](f: A => B): F[A] => F[B]
}

sealed abstract class Free[F[_], A]
case class Return[F[_], A](x: A) extends Free[F, A]
case class Suspend[F[_], A](x: F[Free[F, A]]) extends Free[F, A]
case class Bind[F[_], A, B](x: () => Free[F, A], f: A => Free[F, B]) extends Free[F, B]

// this is the problem child
def liftF[F[_], A](x: => F[A])(implicit F: Functor[F]) = 
  Suspend[F, A](F.map { Return[F, A] }(x))

Now for some reason in the eclipse scala ide I'm getting a error with liftF this error

- type mismatch; found : F[core01.Free.Return[F,A]] required: F[core01.Free[F,A]] Note: core01.Free.Return[F,A] <: core01.Free[F,A], but type 
 F is invariant in type _. You may wish to define _ as +_ instead. (SLS 4.5)

Now in the scalaz source there's no variance annotation, so what's the deal here? why the need for the variance annotation? is there are really need or is there a way around it?

Answer 1

I think you just have the functor arguments backwards on F.map . Give this a try:

  def liftF[F[_], A](x: => F[A])(implicit F: Functor[F]) =
    Suspend[F, A](F.map(x) { Return[F, A] } )

  println(liftF(List(1, 2)))
  "Suspend(List(Return(1), Return(2)))"

Note that either way you apply the elements to functor map you'll get the same result (you're version and the scalaz version):

def mapReverse[F[_], A, B](implicit F: Functor[F]) = {
  (f:A => B) => (fa:F[A]) => F.map(fa)(f)
}

val reverse = mapReverse(F)({
  Return[F, A]
})(x)

val normal = F.map(x)({
  Return[F, A]
})

In this case reverse and normal are both F[Return[F, A]] . The way you apply the parameters is only helpful in the context of Suspend :

Suspend[F, A](F.map(x)({ Return[F, A] })) // works great

Suspend[F, A](normal) // fails to compile
Suspend[F, A](reverse) // fails to compile

I'm sure if you dig through the scala language spec long enough you can find out why the type inference works this way. If I had to guess, when fa is applied to F.map you get a function that's of type (A => B) => F[B] . So the compiler probably looks and sees that Suspend takes a Free so it makes this (A => Free[F, A]) => F[Free[F, A]] which will gladly take Return[F, A].apply as an argument. When you apply the arguments the other way you're strongly typed to Return instead of inferring a function Free .