I would like many features of Scala could be incorporated into C#. As that does not going to happen, I have my reduced wish list (with forgotten items, since I'm now somwhow dissapointed with C# road map - that's me).

 

1 - Parameter-Level Interface Implementation; For example:

class Person
{
    public string Name { get; set; }
    public int Age { get; }
}
interface IPersonata
{
    string Name { get; }
    int Age { get; }
}
class SomeTasks
{
    // ...
    void Function(static IPersonata p) { /* ... */ }
    // ...
    void AnotherFunction(Person p)
    {
        // ...
        Function(p);
        // ...
    }
}

Should work; since Person satisfies IPersonata "statically". This is something like Google Go languages does. If we use dynamic instead of static; then it should generate necessary parts at runtime.

 

2 - Mixins (like Scala's Mixins); which in turn could lead to some statically typed meta-programming (well; It "could"; yet I am not sure how viable are these things in C#'s type system *).

 

3 - Templating generics themselves; at least as type parameters, in interfaces:

interface ITemplateBuilder<T><a>
{
     T<a> CreateInstance(a arg);
}

 

4 - Stronger type inferance (*).

 

5 - XAML everywhere! Yes! XAML could be a perfect replacement for macros in C#; and it's legal even for macro-hater C# folks (and some designers which I have not their eagle-eye view for sure; yet I like statically syntatic extension tools)! XAML provides a proper blending of aspects, services and data manipulation facilities.

 

I have successfully implemented a kd tree (in fact a 2d tree!) for solving a GIS nearest neighbor finding algorithm and enjoyed it a lot; and it is really performant.

 

But; the point that language designers should have in calculation more and more (as our problems get more complex and need quicker reactions):

 

A programming language for sure consums time to bend the programmer's mind to it's concept. At one point this "bending time" will be costy enough for being abandoned by industry.

 

One good job that Microsoft did; is releasing F#. Because if they intend to keep C# the way it is; they should leverage abstraction levels as new languages. F# is a wonderful language; yet a Scala blend (Maybe G# since G has one more angle than C!) could help more; since this "syntax" thing - and { } - really matters.