1. 7

“Let’s continue being inspired by functional languages, and in particular other languages – F#, Scala, Swift – that aim to mix functional and object-oriented concepts as smoothly as possible.”


Working with data
  • pattern matching
  • tuples
  • “denotable” anonymous types
  • “records” - compact ways of describing shapes
  • working with common data structures (List/Dictionary)
  • extension members
  • slicing
  • immutability
  • structural typing/shapes?

Performance and reliability (and interop)

  • generating reference assemblies
  • static linking instead of IL merge
  • determinism
  • NuGet support
  • versioning and adaptive light-up
  • Async sequences: We introduced single-value asynchrony in C# 5, but do not yet have a satisfactory approach to asynchronous sequences or streams
  • Serialization: we may no longer be into directly providing built-in serialization, but we need to make sure we make it reasonable to custom-serialize data - even when it’s immutable, and without requiring costly reflection.
  • Virtual extension methods/default interface implementations
  • Improvements to generic constraints, e.g.:
    • generic constructor constraints
    • delegate and enum constraints
    • operators or object shapes as constraints (or interfaces), e.g. similar to C++ concepts
  • mixins or traits
  • delegation

Null – proper safe nullable reference types, where you simply cannot access the members until you’ve checked for null

  • Type providers: This is a whole different kind of language feature, currently known only from F#. We wouldn’t be able to just grab F#’s model though; there’d be a whole lot of design work to get this one right!
  • Better better betterness: In C# we made some simplifications and generalizations to overload resolution, affectionately known as “better betterness”. We could think of more ways to improve overload resolution; e.g. tie breaking on staticness or whether constraints match, instead of giving compiler errors when other candidates would work.
  • Scripting: The scripting dialect of C# includes features not currently allowed in C# “proper”: statements and member declarations at the top level. We could consider adopting some of them.
  • params IEnumerable.
  • Binary literals and digit separators.

  2. 2

    I don’t think this link warrants scala tag and swift tag. Quoting submission guidelines, “Do not overreach with tags if they are not the primary focus of the story”.

    1. 2

      Ok, I would change it, but it seems like I can’t do that… (by the way, why are there no csharp, fsharp tags?)