Type constructor bounded by proper type

Question

Consider the following type parameter clause [F[_] <: Int] in

def h[F[_] <: Int] = ???

where a type constructor F is bounded by the proper type Int . Now both h[List] and h[Int] are illegal

scala> def h[F[_] <: Int] = ???
     |
def h[F[_] <: Int]: Nothing

scala> h[List]
        ^
       error: type arguments [List] do not conform to method h's type parameter bounds [F[_] <: Int]

scala> h[Int]
         ^
       error: Int takes no type parameters, expected: 1

so why is then [F[_] <: Int] legal?

Answer 1

The type parameter declaration F[_] <: Int means that every instantiation of F must be a subtype of Int . It's right in the syntax, though cryptic: F does not have to be a subtype of Int ; F[_] has to be a subtype of Int (for all types that may be placed in the _ ). An example of such an F is one which always returns Int :

type ConstInt[X] = Int
h[ConstInt] // compiles

Note that you can name the type in the _ . Eg I can declare a type parameter F[X] <: X . X is local to the declaration, defined by appearing under F on the left, used as a bound on the right, and going out of scope afterwards. This example means that F[X] must be a subtype of X , eg as in

def f[F[X] <: X] = ???
type Identity[X] = X
f[Identity] // works
type ConstNothing[X] = Nothing
f[ConstNothing] // works
// f[ConstInt] (ConstInt[X] = Int is not always a subtype of X; counterexample X = AnyRef)

Perhaps that drives home what the bound is supposed to mean.