Such as List.contains ,here is the source code from scala api.
def contains[A1 >: A](elem: A1): Boolean = { var these = this while (!these.isEmpty) { if (these.head == elem) return true these = these.tail } false I understand the inter code theory, But what's about type A1 >: A ?
I guess >: just like isInstanceOf or something like to limit the input param's type?
Could some one give a concise explanation or some docs so i can get some research
The meaning:
A1 is the nearest common ancestor of A and supplied argument type.
The purpose:
since List is declared as List[+A] where +A means "covariant on type A", using A as an argument type is not allowed:
scala> :pa // Entering paste mode (ctrl-D to finish) class List[+A] { def m(x: A) = x } // Exiting paste mode, now interpreting. <console>:15: error: covariant type A occurs in contravariant position in type A of value x def m(x: A) = x UPDATE
Naive explanation why not (just a guess, it's hard to prove since compiler won't allow it):
class List[+A] { def m(x: A) = x } class Fruit class Apple extends Fruit class Pear extends Fruit // list is covariant, which means // List[Fruit] is a supertype of List[Apple] val l: List[Fruit] = new List[Apple] // i.e. l.m has to accept Fruit l.m(new Pear) // Apple? in reality:
class List[+A] { def m[A1 >: A](x: A1) = x } ... l.m(new Pear) // Fruit, the nearest common ancestor of Apple and Pear 
Object, it's the nearset common ancestor of Pear and Apple. So it's not any type.val ls: List[Int] = List(1,2,3,4). Now according to the contains method signature the argument of type A1 has to be a super type of Int. But, we can pass an argument of any type whatsoever to contains and the compiler doesnt complain. This is confusing to me.List[Int] is a subtype of List[Any], so if you call List(1).contains(new Pear) it's a valid call (the result is obviously false). Both 1 and new Pear are instances of Any, so you can apply ==.A in the contains signature is an Int. And the signature says that A1 has to be Int or a supertype of Int. But, this constraint is not holding, since I am able to pass an argument of any type to the contains method; Whats the point of having that lower bound type constraint if its allowing any type to be passed as an argument?A >: B means B is the lower type bound of A
