why does this compile/not compile?

> object A {
> class Z[T]
> class B[T] {
> def foo(x: T) = x
> }
> def foo[T]: Z[T] = new Z[T]
> def goo[T](x: T): B[T] = new B[T]
> goo(foo) foo (new Z[Int]) //doesn't compile

Is `def goo[T](x: T): B[T]` as intended? With `def goo[T](x: Z[T]):
B[T]`, it seems to work.

Apart from that, scalac seems to be happy to infer a type parameter
based on the parameter type of a method which is called on the method
result.

I assume you already now that, but for the records,

scala> goo1(foo1)
res10: B[Nothing] = B@22007d90

scala> res10 foo 1
:13: error: type mismatch;
found : Int(1)
required: Nothing
res10 foo 1
^

i've found a bug in the idea scala plugin (or scalac, not sure yet),
reported it to jetbrains, and that piece of code along with a "wtf is
the difference" was the response. now i'm trying to understand why the
second case compiles, but the first doesn't.

in the second case, the type "Int" is "reverse-inferred" into (each of
them) parameter type T. if that works, why doesn't it work for Z[Int] in
the first case? does this type of type parameter inference only work
with simple, non-nested type parameters?

in the second type, anything is fine, no matter its type. but in the
first, the compiler insists on the parameter being a Z[Nothing] and
accepts nothing else.

Am 06.01.2012 14:21, schrieb Lars Hupel:
>> object A {
>> class Z[T]
>> class B[T] {
>> def foo(x: T) = x
>> }
>> def foo[T]: Z[T] = new Z[T]
>> def goo[T](x: T): B[T] = new B[T]
>> goo(foo) foo (new Z[Int]) //doesn't compile
> Is `def goo[T](x: T): B[T]` as intended? With `def goo[T](x: Z[T]):
> B[T]`, it seems to work.
>
> Apart from that, scalac seems to be happy to infer a type parameter
> based on the parameter type of a method which is called on the method
> result.
>
> I assume you already now that, but for the records,
>
> scala> goo1(foo1)
> res10: B[Nothing] = B@22007d90
>
> scala> res10 foo 1
> :13: error: type mismatch;
> found : Int(1)
> required: Nothing
> res10 foo 1
> ^
>
>