Following on from VB.Net’s new basic pattern matching support, the C# team has recently put forward a proposal for record types and pattern matching in C# which was posted in the Roslyn discussion area on CodePlex, quote:
Pattern matching extensions for C# enable many of the benefits of algebraic data types and pattern matching from functional languages, but in a way that smoothly integrates with the feel of the underlying language. The basic features are: records, which are types whose semantic meaning is described by the shape of the data; and pattern matching, which is a new expression form that enables extremely concise multilevel decomposition of these data types. Elements of this approach are inspired by related features in the programming languages F# and Scala.
There has been a very active discussion on the forum ever since, particularly around syntax.
UPDATE: the discussion appears to have dried up in mid-September 2014 and the pattern matching in C# proposal doesn’t appear to have progressed,
Background
Algebraic types and pattern matching have been a core language feature in functional-first languages like ML (early 70s), Miranda (mid 80s), Haskell (early 90s) and F# (mid 00s).
I like to think of records as part of a succession of data types in a language:
Name | Example (F#) | Description |
Scalar | let width = 1.0
let height = 2.0 |
Single values |
Tuple |
// Tuple of float * float
let rect = (1.0, 2.0) |
Multiple values |
Record |
type Rect = {Width:float; Height:float}
let rect = {Width=1.0; Height=2.0} |
Multiple named fields |
Sum type(single case) |
type Rect = Rect of float * float
let rect = Rect(1.0,2.0) |
Tagged tuple |
Sum type(named fields) |
type Rect = Rect of width:float*height:float
let rect = Rect(width=1.0,height=2.0) |
Tagged tuple with named fields |
Sum type(multi case) |
type Shape=
| Circle of radius:float
| Rect of width:float * height:float |
Union of tagged tuples |
Note: in F# sum types are also often referred to as discriminated unions or union types, and in functional programming circles algebraic data types tend to refer to tuples, records and sum types.
Thus in the ML family of languages records are like tuples with named fields. That is, where you use a tuple you could equally use a record instead to add clarity, but at the cost of defining a type. C#’s anonymous types fit a similar lightweight data type space, but as there is no type definition their scope is limited (pun intended).
For the most part I find myself pattern matching over tuples and sum types in F# (or in Erlang simply using tuples where the first element is the tag to give a similar effect).
Sum Types
The combination of sum types and pattern matching is for me one of the most compelling features of functional programming languages.
Sum types allow complex data structures to be succinctly modelled in just a few lines of code, for example here’s a concise definition for a generic tree:
type 'a Tree =
| Tip
| Node of 'a * 'a Tree * 'a Tree
Using pattern matching the values in a tree can be easily summed:
let rec sumTree tree =
match tree with
| Tip -> 0
| Node(value, left, right) ->
value + sumTree(left) + sumTree(right)
The technique scales up easily to domain models, for example here’s a concise definition for a retail store:
/// For every product, we store code, name and price
type Product = Product of Code * Name * Price
/// Different options of payment
type TenderType = Cash | Card | Voucher
/// Represents scanned entries at checkout
type LineItem =
| Sale of Product * Quantity
| Cancel of int
| Tender of Amount * TenderType
Class Hierarchies versus Pattern Matching
In class-based programming languages like C# and Java, classes are the primary data type where (frequently mutable) data and related methods are intertwined. Hierarchies of related types are typically described via inheritance. Inheritance makes it relatively easy to add new types, but adding new methods or behaviour usually requires visiting the entire hierarchy. That said the compiler can help here by emitting an error if a required method is not implemented.
Sum types also describe related types, but data is typically separated from functions, where functions employ pattern matching to handle separate cases. This pattern matching based approach makes it easier to add new functions, but adding a new case may require visiting all existing functions. Again the compiler helps here by emitting a warning if a case is not covered.
Another subtle advantage of using sum types is being able to see the behaviour for all cases in a single place, which can be helpful for readability. This may also help when attempting to separate concerns, for example if we want to add a method to print to a device to a hierarchy of classes in C# we could end up adding printer related dependencies to all related classes. With a sum type the printer functionality and related dependencies are more naturally encapsulated in a single module
In F# you have the choice of class-based inheritance or sum types and can choose in-situ. In practice most people appear to use sum types most of the time.
C# Case Classes
The C# proposal starts with a simple “record” type definition:
public record class Cartesian(double x: X, double y: Y);
Which is not too dissimilar to an F# record definition, i.e.:
type Cartesian = { X: double, Y: double }
However from there it then starts to differ quite radically. The C# proposal allows a “record” to inherit from another class, in effect allowing sum types to be defined, i.e:
abstract class Expr;
record class X() : Expr;
record class Const(double Value) : Expr;
record class Add(Expr Left, Expr Right) : Expr;
record class Mult(Expr Left, Expr Right) : Expr;
record class Neg(Expr Value) : Expr;
which allows pattern matching to be performed using an extended switch case statement:
switch (e)
{
case X(): return Const(1);
case Const(*): return Const(0);
case Add(var Left, var Right):
return Add(Deriv(Left), Deriv(Right));
case Mult(var Left, var Right):
return Add(Mult(Deriv(Left), Right), Mult(Left, Deriv(Right)));
case Neg(var Value):
return Neg(Deriv(Value));
}
This is very similar to Scala case classes, in fact change “record” to case, drop semicolons and voilà:
abstract class Term
case class Var(name: String) extends Term
case class Fun(arg: String, body: Term) extends Term
case class App(f: Term, v: Term) extends Term
To sum up, the proposed C# “record” classes appear to be case classes which support both single and multi case sum types.
Language Design
As someone who has to spend some of their time working in C# and who feels more productive having concise types and pattern matching in their toolbox, overall I welcome our new overlords this proposal.
From my years of experience using F#, I feel it would be nice to see a simple safety feature included, to what is in effect a sum type representation, so that sum types can be exhaustive. This would allow compile time checks to ensure that all cases have been covered in a switch/case statement, and a warning given otherwise.
Then again, I feel this is quite a radical departure from the style of implementation I’ve seen in C# codebases in the wild, to the point where it’s starting to look like an entirely different language… and so this may be a feature that if it does see the light of day is likely to get more exposure in C# shops working on greenfield projects.