Lambda the Ultimate

Comments, anyone?

I guess variance and constraints are important for library writers: it allows them to finetune their libraries so as that type violations are minimal. From a user's perspective, I doubt it will make much of a difference. Maybe catching a few bugs here and there.

I also agree with Chris Rathman about the usage of symbols + and -. It would have been better if they used a keyword.

It seems like C#, Java, and to a lesser extent C++ (when it gets constraints), will converge at some point to the same language.

Although I'd agree that this is perhaps more important from a library design standpoint, I think that ultimately cleaner libraries are in the best interest of all users. I also happen think that most users are designers of ad hoc libraries, so it will help them as well, though perhaps not as dramatically. I do notice that I've been using the current offering in generics more and more in C# and that it does make my life easier - the more I use them, the more I like them. So my personal opinion would be that although these sorts of things seem esoteric at first, they slowly creep into your toolbox and become second nature. (Of course, the dynamic PL crowd will tell us that generics is a symptom of static typing - but that's a different issue).

As for convergence, well C# and Java started as basically the same language, so it wouldn't be that surprising if they are on parallel projectories. From a language design standpoint, I think that Java and C# are somewhat good for each other - though there's friction between the communities based on competing interests.

[Edit Note] Probably obvious, but I meant this in reply to Achilleas.

Excellent work from the authors, as always. There is much tension in exposing variance specifiers in a language that assumes mutability everywhere and has no means of specifying constant references and constant operations. The use of "where" constraints further implies complex nonlocal reasoning both in typechecking and on the human side when we read the code and try to understand why it works. These extensions stretch the C language family to an impressive new local optima, but at some point the world is going to have to move away from this imperative-everywhere, broken-const model of programming.

why is it necessary (apart from backwards compatability) to require annotation in these cases? why not make all generic parameters covariant and all return values contravariant? or, at least, make that the default - if one wants to limit a generic expression to be exactly equal to the class then require extra syntax. this seems to work fine with ordinary methods, classes, etc.

i assume i've got something mixed up - do you end up with something inconsistent?

It is about 3 years that I am programming in C#. I have done 3 or 4 Windows Application/Web Application in C# 2.0. Does anyone tried to see what is the type of a generic object? (i.e. a list). According to my experiences in using C# generics and some additional studies I tell you C# generics are just a code generation tool that is integrated to .NET 2.0 SDK. They are not real types. There is no inheritance and there is no base class for a generic type!!! What the hell is that? I told : just a coge generation tool that Microsoft just named it as "Generics"! You can try it and you will see it is a shame to ship such thing as a language feature! See Java 5.0 generics in comparission to find out what is missed. And about that dynamic functions and closures; they cause easily many bugs i.e. for GC to collect objects. I had seen this in (especially) ASP.NET. I am forced to use microsoft for my job but I know all these are fake. (Maybe you say it works after all. Yes because microsoft provide other tools to make these failures correct and continue to make product oriented languages)

Not familiar enough with Java generics, but there has been some grumbling about the Type Erasure among other things.

As for C#, if I do something like:

   List<string> stringList = new List<string>();
   Console.WriteLine(stringList.GetType());
   Console.WriteLine(stringList.GetType() == typeof(List<string>));
   Console.WriteLine(stringList.GetType() == typeof(List<int>));

I get back:

   System.Collections.Generic.List`1[System.String]
   True
   False

Playing a little further, arrays of generics like the following are said not to work in Java:

    Pair<Integer,Integer>[] intPairArr = new Pair<Integer,Integer>[10]; // illegal

Whereas the following should work in C#:

    class Pair
    {
        public T1 First;
        public T2 Second;
    }

   Pair<string, string>[] intPairArr = new Pair<string, string>[10];
   Console.WriteLine(intPairArr.GetType());
   // output: Pair`2[System.String,System.String][]

Finally, C# and Java share the property that List<Object> is not a supertype of List<String>