Upper-Bound/Lower-Bound Inferences and fixing

Question

In the C# 4.0 Spec 7.5.2.9:

A lower-bound inference from a type U to a type V is made as follows:

• If V is one of the unfixed X_i, then U is added to the set of lower bounds for X_i.
• [...]

I've gone over this section many times. Lacking a section reference, this definition reads like a circular reference. So, I expect to find a grammer production or section reference nearby to clarify..which I do not. This section also ties in Fixing which suffers from similar definition issues.

What is an upper-bound inference vs a lower-bound inference?

Answer 1

I'll try my best to describe it more clearly. Worst case, I describe it differently.

The upper/lower inference is one part of a phased approach to type inference with regard to type arguments that are used for a particular generic method call. Obviously, upper/lower inference won't be applied if in the first phase if the argument (E) is explicitly typed. e.g.:

given

public static T Choose<T>(T first, T second) {
        return (rand.Next(2) == 0)? first: second;
    }

I can invoke Choose with explicit type arguments:

Choose<String>("first", "second");

With regard to the upper- or lower-bounds inference, there are some implications throughout 7.5.2 that decide whether lower- or upper-bounds inference is even applicable. For example, 7.5.2.9 (and .10) detail that the type parameter is unfixed for either upper- or lower-bounds inference to occur. 7.5.2.5 details that a type parameter is only unfixed when that type parameter depends on another unfixed type parameter. For example

IEnumerable<TResult> Select<TSource, TResult>(IEnumerable<TSource> e,
    Func<TSource, Result> f)

TResult "depends on" TSource, because the type of TSource could possibly determine the type of TResult. e.g. with a call like Select(c, e->Name), TResult depends on the type of Name in TSource.

In terms of upper- and lower-bounds inferences, for a given unfixed type parameter (X) whose type (V) is not explicitly declared (see first paragraph), upper or lower bounds of type argument (E) of type U are deduced. If the type parameter is covariant (has out modifier) and one of the types in the lower-bound set is a candidate for the parameter, then a lower-bound inference occurred. Conversely, if the type parameter is contravariant (has 'in' modifier) and one of the types in the upper-bound set is a candidate for the parameter, then an upper-bound inference occurred. e.g. with Select(c, e->e.Name) and c was IEnumerable<Mammal> then the compiler would infer an lower bound of Mammal because the type parameter in IEnumerable is covariant (e.g. it's declared IEnumerable<out T>. If it were declared IEnumerable<in T> then an upper-bound would be inferred. And if it were declared Enumerabale<T>--with no in or out then it would be invariant and neither upper- nor lower-bounds inference would apply.)

Clearly, if parameter type can be neither covariant nor contravariant then an exact match must occur