Tipo inferido a Nada en Scala

Question

Cuando intento compilar el pequeño ejemplo:

trait Foo[A,B] { 
    type F[_,_] 
    def foo(): F[A,B] 
} 

class Bar[A,B] extends Foo[A,B] { 
    type F[D,E] = Bar[D,E] 
    def foo() = this 
} 

object Helper { 
    def callFoo[A,B,FF <: Foo[A,B]](f: FF): FF#F[A,B] = 
    f.foo() 
} 

object Run extends App { 
    val x = new Bar[Int,Double] 
    val y = Helper.callFoo(x) 
    println(y.getClass) 
} 

me sale el error:

[error] src/Issue.scala:20: inferred type arguments 
[Nothing,Nothing,issue.Bar[Int,Double]] do not conform to method callFoo's type 
parameter bounds [A,B,FF <: issue.Foo[A,B]] 
[error]  val y = Helper.callFoo(x) 

Al parecer, el mecanismo de inferencia de tipos no es capaz de inferir A y B de la barra [A, B]. Sin embargo, funciona si paso todos los tipos a mano:

val y = Helper.callFoo[Int,Double,Bar[Int,Double]](x) 

que hay una manera de evitar el paso tipos explícitamente?

Answer 1

Vas a tener que cambiar la firma de callFoo a esto:

def callFoo[A, B, FF[A, B] <: Foo[A, B]](f: FF[A, B]): FF[A, B]#F[A, B] = 

Tiene que decirle al compilador que FF es en realidad un tipo parametrizado.

Answer 2

¿Funcionaría utilizar los miembros del tipo en lugar de los parámetros?

trait Foo { 
    type A 
    type B 
    type F 
    def foo(): F 
} 

class Bar extends Foo { 
    type F = Bar 
    def foo() = this 
} 

object Helper { 
    def callFoo[FF <: Foo](f: FF): FF#F = 
    f.foo() 
} 

object Run extends App { 
    val x = new Bar{type A=Int; type B=Double} 
    val y = Helper.callFoo(x) 
    println(y.getClass) 
} 

Al usar miembros de tipo, es útil saber que pueden estar recubiertos según los parámetros de tipo utilizando refinamiento, como en la respuesta de Miles Sabin a: Why is this cyclic reference with a type projection illegal?

Véase también esta última pregunta, que parece similar a la suya : Scala fails to infer the right type arguments