Covariance and Contravariance in C# Part Seven: Why Do We Need A Syntax At All?

re: Covariance and Contravariance in C# Part Seven: Why Do We Need A Syntax At All?

Bryan Watts — Mon, 29 Oct 2007 19:27:51 GMT

I see the logical issues involved with inference.

The token is an explicit statement of intent which greatly reduces the scope of the problem - now you can tell the developer that their program is illegal.

Also, I like the variance token as a suffix; it reads like a property of the type parameter instead of an operator.

re: Covariance and Contravariance in C# Part Seven: Why Do We Need A Syntax At All?

Eric Lippert — Mon, 29 Oct 2007 19:35:16 GMT

I would prefer a suffix as well, though that does present a minor problem, as "interface IFoo<T->" would be lexed as INTERFACE ID LEFTANGLE ID ARROW. We'd have to do some minor surgery to the lexical grammar to make it work out.

re: Covariance and Contravariance in C# Part Seven: Why Do We Need A Syntax At All?

Richard — Mon, 29 Oct 2007 22:19:18 GMT

How about a syntax like:

interface I<:U, V:> {

U f(V);

}

Here, :T means covariant (a visual reminder of 'is derived from T'), and T: means contravariant (a visual reminder of 'derives from T'). It's not perfect, because derivation isn't the relationship we're capturing, but given:

class A {}

class B : A {}

interface I<:U, V:> { U f(V); }

It seems reasonable that this is OK:

class C : I<A, B> { B f(A); }

re: Covariance and Contravariance in C# Part Seven: Why Do We Need A Syntax At All?

Eric Lippert — Tue, 30 Oct 2007 02:03:19 GMT

Indeed, that is one of the syntaxes I will discuss next time, and the downside of it is exactly as you state. I would rather not further overburden the notion of "derivation". But it is a nice visual. (We were thinking of *:T, U:*, which is even more visually striking.)

re: Covariance and Contravariance in C# Part Seven: Why Do We Need A Syntax At All?

Allan P — Tue, 30 Oct 2007 03:02:27 GMT

I occasionally use variance at the IL level and am rather accustomed to the +- notation.

I think it would do just as well in C#.

re: Covariance and Contravariance in C# Part Seven: Why Do We Need A Syntax At All?

Gabe — Tue, 30 Oct 2007 11:22:40 GMT

Is it a bad idea to allow variance where deduceable and disallow it where it's ambiguous? Perhaps it means that changing an interface would make the new version incompatible with the old version.

re: Covariance and Contravariance in C# Part Seven: Why Do We Need A Syntax At All?

silky — Tue, 30 Oct 2007 14:16:43 GMT

instead of an operator why not an attribute.

[Variance(V=covariant,W=contravariant)]

interface M<V, W> {

}

i've got to be honest in that i find this whole thing quite confusing. (compilable examples obviously help...) but i think that an attribute-based system will be more readable.

it also seems a little more appropriate, imho.

also, it obviously trivialises the job to integrate this into the 'hypothetical' language.

re: Covariance and Contravariance in C# Part Seven: Why Do We Need A Syntax At All?

Matt — Tue, 30 Oct 2007 14:53:56 GMT

The attribute idea is an interesting one. I do prefer the more verbose syntax such things provide (You read and edit a class/interface many many more times than you write one) but appreciate it might make life harder for the compiler.

It also brings up the question of how such variance is expressed within the reflection system...

Making the attribute handle each iof the generic types could require some nasty hacks or etxtual code which could be messy. An alternate is to extend attribute locations to allow them to be placed on each generic type

e.g.

class Foo< [Variance(Variances.Covariant)] U, [Variance(Variances.Contravariant)] V>

{

}

I don't like how needlessly verbose this is though. Perhaps

class Foo< [Covariant] U, [Contravariant] V>

{

}

Which is two attributes but rather more readable (if a type is both add both).

Of course what happens if you apply the attributes within a language which doesn't support it :(

re: Covariance and Contravariance in C# Part Seven: Why Do We Need A Syntax At All?

Eric Lippert — Tue, 30 Oct 2007 16:48:52 GMT

> Is it a bad idea to allow variance where deduceable and disallow it where it's ambiguous?

If we disallow it when it is ambiguous then what do we do for the customer who wants variance, knows what variance they want, and has an ambiguous interface? That will be a very common case since ambiguities are easy to make. We have to provide a syntax for that case so that the user can disambiguate explicitly.

We would also want to provide a syntax for "no variance" that differed from "deduce variance".

Both facts speak to the need for variance to be always explicit, never inferred.

re: Covariance and Contravariance in C# Part Seven: Why Do We Need A Syntax At All?

Eric Lippert — Tue, 30 Oct 2007 16:51:06 GMT

> how such variance is expressed within the reflection system

That's easy to answer. See http://msdn2.microsoft.com/en-us/library/system.reflection.genericparameterattributes.aspx for details.

re: Covariance and Contravariance in C# Part Seven: Why Do We Need A Syntax At All?

Eric Lippert — Tue, 30 Oct 2007 16:54:03 GMT

> what happens if you apply the attributes within a language which doesn't support it

Then that language probably ignores the attributes as it always has.

Remember, variance as I am characterising it here is an extension to the assignability rules. A language implementer may choose to implement whatever assignability rules they want. C# 3.0 presently ignores the variance bits in Reflection; the feature I am proposing in this series would make some future C# start paying attention to those bits and allowing certain assignments which are presently illegal.

re: Covariance and Contravariance in C# Part Seven: Why Do We Need A Syntax At All?

brandf — Wed, 31 Oct 2007 09:50:28 GMT

How about extending the existing generic constraint syntax?

class Foo<T> where T: class, covariant, IBar

{

...

}

Community Convergence XXXV

Charlie Calvert's Community Blog — Mon, 05 Nov 2007 09:29:13 GMT

Welcome to the thirty-fifth edition of Community Convergence. We have an interesting and controversial

re: Covariance and Contravariance in C# Part Seven: Why Do We Need A Syntax At All?

Felipe — Fri, 16 May 2008 16:12:28 GMT

What do you mean by cycles?

Like here: "When we detect a cycle in base classes, we can throw..."

I am brazillian and dont undestand very well...

I can say that I'm your fan, and I think the articles of the blog incredible. I would like your permission to translate them, we do not have anything like that in Portuguese, would be of great help to the community

re: Covariance and Contravariance in C# Part Seven: Why Do We Need A Syntax At All?

Eric Lippert — Fri, 16 May 2008 16:24:07 GMT

By "cycles in base classes" I mean a situation such as:

class A : B {}

class B : C {}

class C : D {}

class D : A {}

That's not a legal class hierarchy. There is no way to eventually get to object as the base type.

Similarly, it's not legal to have

class C<T, U>

where T : U

where U : T

And similarly with interface "inheritance".

Glad you like the blog!

re: Covariance and Contravariance in C# Part Seven: Why Do We Need A Syntax At All?

Felipe — Fri, 16 May 2008 19:36:16 GMT

Thank you, but you did not say if I can translate and publish this series

re: Covariance and Contravariance in C# Part Seven: Why Do We Need A Syntax At All?

Eric Lippert — Fri, 16 May 2008 19:48:43 GMT

Fine by me, so long as you:

* recognize that by doing so, it becomes impossible for me to update the content, fix errors, and so on, in your copy. I do not want this to turn into more work for me.

* do not quote me out of context.

* take responsibility for any errors introduced by the translation process.

* recognize that I am not the copyright holder. Microsoft Corporation owns the copyright to this blog. If in the unlikely event that Microsoft decides in the future that they don't want you to republish their content, please honour their requests.

re: Covariance and Contravariance in C# Part Seven: Why Do We Need A Syntax At All?

Eric Lippert — Fri, 16 May 2008 21:06:15 GMT

Also, something you might consider: rather than doing a direct translation of my work, why not write a blog of your own about these topics in Portuguese? You can certainly use my blog as a resource; that's what it's for.

I frequently blog about topics that I do not actually understand very well. (This may be obvious to some people!) I find that by deciding to write an article about a topic, I force myself to understand the topic well enough to explain to other people. I learn a lot from writing this blog.

C# 4.0: Covariance and Contravariance on generics…sort of…

LA.NET [EN] — Thu, 30 Oct 2008 16:46:11 GMT

One of the things that we’ll have in C# 4.0 is covariance/contravariace working on generics…I mean, sort

WAW!!! What a serie of blog posts for "Covariance and Contravariance" - C# Future...

Journal of Abu Sayed Mohammad Ismail — Wed, 24 Dec 2008 09:36:37 GMT

So nicely step by step blogged by Eric Lippert for "Covariance and Contravariance" as "Fabulous