“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.”

Themes

• 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.