Foolish consistency is foolish

Foolish consistency is foolish

Rate This
  • Comments 29

Once again today's posting is presented as a dialogue, as is my wont.

Why is var sometimes required on an implicitly-typed local variable and sometimes illegal on an implicitly typed local variable?

That's a good question but can you make it more precise? Start by listing the situations in which an implicitly-typed local variable either must or must not use var.

Sure. An implicitly-typed local variable must be declared with var in the following statements:

var x1 = whatever;
for(var x2 = whatever; ;) {}
using(var x3 = whatever) {}
foreach(var x4 in whatever) {}

And an implicitly-typed local variable must not be declared with var in the following expressions:

from c in customers select c.Name
customers.Select(c => c.Name)

In both cases it is not legal to put var before c, though it would be legal to say:

from Customer c in customers select c.Name
customers.Select((Customer c) => c.Name)

Why is that?

Well, let me delay answering that by criticizing your question further. In the query expression and lambda expression cases, are those in fact implicitly typed locals in the first place?

Hmm, you're right; technically neither of those cases have local variables. In the lambda case, that is a formal parameter. But a formal parameter behaves almost exactly like a local variable, so it seems reasonable to conflate the two in casual conversation. In the query expression, the compiler is going to syntactically transform the range variable into an untyped lambda formal parameter regardless of whether the range variable is typed or not.

Can you expand on that last point a bit?

Sure. When you say

from Customer c in customers select c.Name

that is not transformed by the compiler into

customers.Select((Customer c) => c.Name)

Rather, it is transformed into

customers.Cast<Customer>().Select(c => c.Name)

Correct. Discussing why that is might be better left for another day.

Indeed; the point here is that regardless of whether a type appears in the query expression, the lambda expression in the transformed code is going to have an untyped formal parameter.

So now that we've clarified the situation, what is your question?

C# is inconsistent; var is required on an implicitly-typed local variable (regardless of the "container" of the local declaration), but var is illegal on an implicitly-typed lambda parameter (regardless of whether the lambda parameter is "natural" or is the result of a query expression transformation). Why is that?

You keep on asking "why?" questions, which I find difficult to answer because your question is secretly a "why not?" question. That is, the question you really mean to ask is "I have a notion of how the language obviously ought to have been designed; why is it not like that?"  But since I do not know what your notion is, it's hard to compare its pros and cons to the actual feature that you find inconsistent.

The problem you are raising is one of inconsistency; I agree that you have identified a bona fide inconsistency, and I agree that a foolish, unnecessary inconsistency is bad design. Our language is designed to be easy to comprehend; foolish inconsistencies work against comprehensibility. But what I don't understand is how you think that inconsistency ought to have been addressed.

I can see three ways to address that inconsistency. First, make var required on lambdas and query expressions, so that it is consistently required. Second, make var illegal on all locals, so that it is consistently illegal. And third, make it optional everywhere. What is the real "why not?" question?

You're right; I've identified an inconsistency but have not described how I think that inconsistency could be removed. I don't know what my real "why not?" is so let's look at all of them; what are the pros and cons of each?

Let's start by considering the first: require var everywhere. That would then mean that you have to write:

from var c in customers join var o in orders...

instead of

from c in customers join o in orders...

And you have to write

customers.Select((var c) => c.Name)

instead of

customers.Select(c => c.Name)

This seems clunky. What function does adding var in these locations serve? It does not make the code any more readable; it makes it less readable. We have purchased consistency at a high cost here. The first option seems untenable.

Now consider the second option: make var illegal on all locals. That means that your earlier uses of var on locals would become:

x1 = whatever;
for(x2 = whatever; ;) {}
using(x3 = whatever) {}
foreach(x4 in whatever) {}

The last case presents no problem; we know that the variable declared in a foreach loop is always a new local variable. But in the other three cases we have just added a new feature to the language; we now have not just implicitly typed locals, we now have implicitly declared locals. Now all you need to do to declare a new local is to assign to an identifier you haven't used before.

There are plenty of languages with implicitly declared locals, but it seems like a very "un-C#-ish" feature. That's the sort of thing we see in languages like VB and VBScript, and even in them you have to make sure that Option Explicit is turned off. The price we pay for consistency here is very different, but it is still very high. I don't think we want to pay that price.

The third option -- make var optional everywhere-- is just a special case of the second option; again, we end up introducing implicitly declared locals.

Design is the art of compromising amongst various incompatible design goals. In this case, consistency is a goal but it loses to more practical concerns. This would be a foolish consistency.

Is the fact that there is no good way out of this inconsistency an indication that there is a deeper design problem here?

Yes. When I gave three options for removing the inconsistency, you'll notice that I made certain assumptions about what was and was not allowed to change. If we were willing to make larger changes, or if we had made different design decisions in C# 1.0, then we wouldn't be in this mess in the first place. The deeper design problem here is that the fact that a local variable declaration has the form

type identifier ;

This is not a great statement syntax in the first place. Suppose C# 1.0 had instead said that a local variable must be declared like this:

var identifier : type ;

I see where you are going; JScript.NET does use that syntax, and makes the type annotation clause optional. And of course Visual Basic uses the moral equivalent of that syntax, with Dim instead of var and As instead of :.

That's right. So in typing-required C# 1.0 we would have

var x1 : int = whatever;
for(var x2 : int = whatever; ;) {}
using(var x3 : IDisposable = whatever) {}
foreach(var x4 : int in whatever) {}

This is somewhat more verbose, yes. But this is very easy to parse, both by the compiler and the reader, and is probably more clear to the novice reader. It is crystal clear that a new local variable is being introduced by a statement. And it is also nicely reminiscent of base class declaration, which is a logically similar annotation. (You could have just as easily asked "Why does the constraining type come to the left of the identifier in a local, parameter, field, property, event, method and indexer, and to the right of the identifier in a class, struct, interface and type parameter?" Inconsistencies abound!)

Then in C# 3.0 we could introduce implicitly typed locals by simply making the annotation portion optional, and allowing all of the following statements and expressions:

var x1 = whatever;
for(var x2  = whatever; ;) {}
using(var x3  = whatever) {}
foreach(var x4 in whatever) {}

from c in customers select c.Name
from c : Customer in customers select c.Name
customers.Select(c => c.Name)
customers.Select((c : Customer) => c.Name)

If this syntax has nicer properties then why didn't you go with it in C# 1.0?

Because we wanted to be familiar to users of C and C++. So here we have one kind of consistency -- consistency of experience for C programmers -- leading a decade later to a problem of C# self-consistency.

The moral of the story is: good design requires being either impossibly far-sighted, or accepting that you're going to have to live with some small inconsistencies as a language evolves over decades.

  • @MK: Then I'd argue for typedefs in C# (something I'd argue for anyway - along with partially constrained generics aka generic typedefs).

  • > var a : int, b : int, c : int;

    In practically every language that uses this syntax, you can (or have to) write:

    var a, b, c: int;

    Indeed, if you restrict var such that it only allows declaring variables of a single type in a single var, the above is unambiguous - if the type is there, it applies to all listed variables, and if not, then it means "infer types" (which would then be illegal for the lack of initializers here).

    Indeed, though sometimes this changes. In VB6, "Dim Curly, Larry, Moe as Stooge" meant to annotate Moe as Stooge and Curly and Larry were variants. In Visual Basic .NET, all three are stooges. -- Eric

  • @Eamon Nerbonne: How does that solve anything? If all you do is change a token, you still got the same problems, but now you're writing pascal instead of c.

    One thing not mentioned in the blogpost: If you remove all variable declarations you get a problem writing to global values.

    x = 0;

    void foo() {

         x = 2; // does this write to global variable x or create a new local variable x?


    Python solves that with extra keywords.. (and even worse, "global" alone isn't enough - you need a second classifier if lambdas or nested functions are allowed). Although making global writes explicit appeals to my functional side - so not sure if that's necessarily bad.

    I'd hate having to write `var x = 0` in python, but at the same time I'm just fine with variable declarations in C# - different languages have different goals and take different tradeoffs.

  • @Carl Daniel: The 'using alias = class;' syntax fulfills most typedef scenarios already, e.g.

    using ShortName = NameSpace.OthernameSpace.IncrediblyLongClassNameNoOneWantsToTypeFiftyTimes;


  • @Jonathan Allen

    I want Option Infer Off, and still have the ability to make the compiler infer a single variable.  I don't like programming with "option infer on", it feels sloppy and makes the code harder to read and understand, but there are some places, mostly linq, where it is required for a specific variable.

  • RaceProUK: Yes, the type aliasing ability of "using" is great, but it only works within a single file. The value of typedef is greatly amplified by C's #include mechanism, making it really easy to have a single typedef apply throughout your project. If you want to alias a type globally (possibly to make it easy to change), there's no easy way to do that.

  • @Gabe I agree with the linux styleguide and most other C/C++ I've seen there: 95% of all typedefs only make the code much harder to read for no purpose whatsoever.

    Especially in C# where you can use well named classes anyhow and don't have void* everywhere there's almost never a reason for them in a well written code base (i.e. the situations where a typedef would make good sense in C/C++ rarely ever come up in C#).

  • Your are talking about implicit parameters not variables. And from that point of view it is consistent.

    You can't write:

    public void Something(var value) {}

    Also in the matter of delegates it does make sense not be able to use var since a C# delegate is not simply a function / method pointer as in c++ for example, people should know that.

  • How can one answer "Why is `var` sometimes required?" without at least mentioning unnameable types (I think Eric's already written several posts elaborating on these, linking is of course better than repeating the explanation)?

  • But why 'var' declaration doesn't allow initialization to null ?

  • Moral of the story is a story in itself. Best line. Should be read and remembered by every one...

  • @Randy

    >I realize it could match other delegate types as well, but I want the Action<> and Func<> types to be the default, and make me specify when another delegate type is desired.

    Better yet, make all delegate types with the same type signature compatible. The incompatibility of identical delegates and identical interface unions drives me mad sometimes.

    @Richard Deeming

    >The problem is that the compiler doesn't know whether "a" should be "Action" or "Expression<Action>", since the same syntax is used for both.

    It's easy: the Expression<Action> one is a very special case which should only be activated when the Expression<Action> type is explicitly written.

  • Just for the record - the original quote seemed already good enough: A foolish consistency is the hobgoblin of little minds. I do wish Emmerson had also thrown in the opposite: A foolish inconsistency is the hobgoblin of arrogant designers. :)

    Either way, the operative word there is 'foolish'...

  • I think it is towards more high level c# closer to vb and likes.

Page 2 of 2 (29 items) 12