Rodzaj wywnioskować aby nic w Scala

Question

Kiedy próbuję skompilować mały przykład:

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) 
} 

pojawia się błąd:

[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) 

Najwyraźniej mechanizm typu wnioskowanie nie jest w stanie wyprowadzić i B poza prętem [A, B]. Działa to jednak, gdy ręcznie przekazuję wszystkie typy:

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

Czy istnieje sposób uniknięcia jawnego przekazywania typów?

Answer 1

będziesz musiał zmienić podpis callFoo do tego:

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

Musisz powiedzieć kompilatorowi, że FF jest rzeczywiście parametryzowanym typem.

Answer 2

Czy zamiast parametrów będą działać elementy typu ?

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) 
} 

Podczas korzystania członków typ, to warto wiedzieć, że mogą być powierzchniowe jako parametry typu używając wyrafinowania, jak w odpowiedzi Miles Sabin do: Why is this cyclic reference with a type projection illegal?

Zobacz także to ostatnie pytanie, które wydaje się podobne do Ciebie : Scala fails to infer the right type arguments