Month: May 2008

At Ann Arbor Dot Net Developers meeting last night, Eric Maino was there. I don’t think he meant to open up the giant can of worms that is me when he asked “What kind of things would you like to see in the next version of C#?” Here is my list.

• Static Imports

  yes like java!

  Sometimes extension methods aren’t as readable as just a method call. Ability to import static methods and call them without the class name would be super.

• Drop var.

  Type inference rules. Can we drop the var? its noise.
  var x = 1;
x = 1;
which of these lines is more concise? At least make it optional. I don’t mind if you want to say var. Just don’t make me do it.

• Better type inference

  Optional type parameters, since the compiler knows what I mean!
  peeps = List(new string[] {“Bob”,”Dorothy”,”Jane”});
  This is a List<T>, but I don’t need to say List<string> the type can be inferred via the List<T>(IEnumerable<T>) constructor.

• Optional Whitespace Significance

  We all use whitespace formatted code anyway. Why not just drop the parenthesis and semicolons and make the whitespace actually mean something. Of course I say “optional” because not everyone will like it. It would be really cool to be able to toggle it throughout a file.
  #pragma whitespace significance enable
public class Employee
  public Employee()
    name = string.Empty
    hireDate = DateTime.Now
  public string Name
    get
    set
  public DateTime HireDate
    get
    set
#pragma whitespace significance disable
public GiveRaise() {
salary *=1.10;
}
#pragma whitespace significance enable
  public Promote()
    CLevel--
  The file would have to end in the same mode in which it were started, or the compiler can figure things out.

• A hook into the compiler pipeline

  See boo.

• A hybrid compiler

  At CodeMash, Joe O’Brien and Michael Letterle about how nice it would be to use the better suited language for any given task in .NET. We don’t want separate projects. We don’t want separate netmodules.

  I want it right down to partial classes. VB’s XML Literals and late binding are sweet. I want to use those if I need. C#’s everything else are what I prefer to work with.

  ReadYourFeed.cs:
public partial class ReadYourFeed {
  Initialize(){
    rss.FirstChild.AppendChild(GetGenerator());
  }
}

  ReedYourFeed.vb:
Partial Public Class ReadYourFeed
  Public Function GetGenerator()
    Dim sig = <generator>SuperReadYourFeed 2000 1.2.3.4.5</generator>
    Return sig
  End Function
End Class

  * I don’t know VB. Writing that VB took me much googling

• A plugable compiler

  Similar to the above with boo, but almost the inverse. I want an open definition for the AST which the compiler uses to generate IL and I want a great API for building this AST myself.

  Next, I should be able to plug in my own parser/lexer which builds this AST. So the IL generation from the AST is entirely from the (now more than) C# compiler, but the parser is mine.

  This is really an abstraction and opening of the previous step. Instead of just C#/VB, I want it ALL!

• Easier method currying.

  Dustin Campbell might like writing lots of code to do it in C#. I’m sure he does it all the time, but I’d like to be able to do it in FAR fewer lines of code.

• F#’s pipeline operator.

  This is more readable
  {1..10} |> Seq.fold (+) 0;;
  than this
  Enumerable.Aggregate(Enumerable.Range(1, 10), (a, b) => a + b);
  or this
  (from i in Enumerable.Range(1, 10) select i).Sum();
  or even this
  Enumerable.Range(1, 10).Sum();
  Ok, well extension methods sure look a lot like the pipeline operator, so never mind on this request 🙂

It seems like I talked about other crazy stuff too, but I don’t recall what things they were.