Unexpected Typing

On Sat, Sep 17, 2011 at 11:52 AM, Mehdi wrote:
> it creates value listSub1 of type "List[Any]" but it is supposed to be
> of type "List[_ >: B]"

List[Any] and List[_ >: B] are the same type. (To see this, try to
construct an example of a List[Any] which is not a List[_ >: B], and
try the reverse as well.)

You will get the type you expect if you use an invariant container,
e.g. use Set instead of List.

I know they are same and you can assign variables of either type to
each other, but when you create a value as:

val listSub2: List[X] forSome {type X >: T} = List(new A);

the interpreter says that its type is "List[_ >: B]" which is more
readable. Why shouldn't it do the same for TypeConst[T]#ListSub?

On Sep 18, 8:11 am, Paul Phillips wrote:
> On Sat, Sep 17, 2011 at 11:52 AM, Mehdi wrote:
> > it creates value listSub1 of type "List[Any]" but it is supposed to be
> > of type "List[_ >: B]"
>
> List[Any] and List[_ >: B] are the same type.  (To see this, try to
> construct an example of a List[Any] which is not a List[_ >: B], and
> try the reverse as well.)
>
> You will get the type you expect if you use an invariant container,
> e.g. use Set instead of List.

let me correct:

val listSub2: List[X] forSome {type X >: B} = List(new A);

On Sep 18, 11:04 am, Mehdi Bahribayli wrote:
> I know they are same and you can assign variables of either type to
> each other, but when you create a value as:
>
> val listSub2: List[X] forSome {type X >: T} = List(new A);
>
> the interpreter says that its type is "List[_ >: B]" which is more
> readable. Why shouldn't it do the same for TypeConst[T]#ListSub?
>
> On Sep 18, 8:11 am, Paul Phillips wrote:
>
>
>
>
>
>
>
> > On Sat, Sep 17, 2011 at 11:52 AM, Mehdi wrote:
> > > it creates value listSub1 of type "List[Any]" but it is supposed to be
> > > of type "List[_ >: B]"
>
> > List[Any] and List[_ >: B] are the same type.  (To see this, try to
> > construct an example of a List[Any] which is not a List[_ >: B], and
> > try the reverse as well.)
>
> > You will get the type you expect if you use an invariant container,
> > e.g. use Set instead of List.

On Sun, Sep 18, 2011 at 12:04 AM, Mehdi Bahribayli
wrote:
> I know they are same and you can assign variables of either type to
> each other, but when you create a value as:
>
> val listSub2: List[X] forSome {type X >: T} = List(new A);
>
> the interpreter says that its type is "List[_ >: B]" which is more
> readable. Why shouldn't it do the same for TypeConst[T]#ListSub?

The compiler applies the specified simplification rules for
existentials and given a chance that type will simplify to List[Any].
It's an artifact of the repl implementation that the wildcard form
even survives long enough for you to see it.

scala> class A ; class B extends A
defined class A
defined class B

scala> val listSub2: List[X] forSome {type X >: B} = List(new A);
listSub2: List[_ >: B] = List(A@370c488c)

scala> val x = listSub2
x: List[Any] = List(A@370c488c)

scala> listSub2
res1: List[Any] = List(A@370c488c)

Thanks Paul

On Sep 19, 6:31 am, Paul Phillips wrote:
> On Sun, Sep 18, 2011 at 12:04 AM, Mehdi Bahribayli
>
> wrote:
> > I know they are same and you can assign variables of either type to
> > each other, but when you create a value as:
>
> > val listSub2: List[X] forSome {type X >: T} = List(new A);
>
> > the interpreter says that its type is "List[_ >: B]" which is more
> > readable. Why shouldn't it do the same for TypeConst[T]#ListSub?
>
> The compiler applies the specified simplification rules for
> existentials and given a chance that type will simplify to List[Any].
> It's an artifact of the repl implementation that the wildcard form
> even survives long enough for you to see it.
>
> scala> class A ; class B extends A
> defined class A
> defined class B
>
> scala> val listSub2: List[X] forSome {type X >: B} = List(new A);
> listSub2: List[_ >: B] = List(A@370c488c)
>
> scala> val x = listSub2
> x: List[Any] = List(A@370c488c)
>
> scala> listSub2
> res1: List[Any] = List(A@370c488c)