202 lines
5 KiB
Markdown
202 lines
5 KiB
Markdown
# C# Language Design Notes for Apr 30, 2018
|
|
|
|
***Warning: These are raw notes, and still need to be cleaned up. Read at your own peril!***
|
|
|
|
|
|
# Switch expressions
|
|
|
|
Current syntax:
|
|
|
|
``` c#
|
|
e switch
|
|
{
|
|
1 => "one",
|
|
2 => "two",
|
|
var x when x > 2 => "too many",
|
|
_ => "too few"
|
|
}
|
|
```
|
|
|
|
No `default` - instead use `_`.
|
|
|
|
If the compiler thinks there are cases you don't handle, it'll warn. If you actually don't handle a case we throw an exception (NRE for prototype, something else in the long run).
|
|
|
|
Also discussed:
|
|
|
|
- use `match` instead of `switch`
|
|
- keyword first, followed by parens, like `switch` statement
|
|
- or without parens
|
|
- optional implicit default at the end?
|
|
|
|
The current thing is nice for error recovery.
|
|
|
|
The lack of statements inside may be a frustration, but that's orthogonal. Let's leave it for now.
|
|
|
|
## Exploration
|
|
|
|
Is there a way to instead generalize the syntax from the conditional (ternary) operator? After all, semantically speaking this could be viewed as a general form: Conditional operators and switch expressions on bool are semantically equivalent.
|
|
|
|
``` c#
|
|
e
|
|
? true => e1
|
|
: false => e2
|
|
```
|
|
|
|
The fact that you know the number of colons today means you can have fewer parentheses than you would get away with here.
|
|
|
|
``` c#
|
|
e ?
|
|
true => e1 ? x : y :
|
|
false => e2
|
|
```
|
|
|
|
It's not in fact obvious whether there should be many `?`s and one `:`, or one `?` and many `:`s:
|
|
|
|
``` c#
|
|
// Interpret ? as following the tested expression, and : as a separator of test/result pairs
|
|
e
|
|
? 1 => "one"
|
|
: 2 => "two"
|
|
: var x when x > 2 => "too many"
|
|
: _ => "too few"
|
|
|
|
// Interpret ? as introducing test/result pairs, and : as introducing the fallback result
|
|
e
|
|
? 1 => "one"
|
|
? 2 => "two"
|
|
? var x when x > 2 => "too many"
|
|
: "too few"
|
|
```
|
|
|
|
The `=>` glyph is probably not right in a `?:` style syntax. It would have to be something else that more clearly signals pattern/result pairs.
|
|
|
|
``` c#
|
|
e
|
|
? 1 -> "one"
|
|
? 2 -> "two"
|
|
? var x when x > 2 -> "too many"
|
|
: "too few"
|
|
```
|
|
|
|
## Considering our options
|
|
|
|
``` c#
|
|
// Compromise - terser
|
|
e ? { 1: "one", 2: "two", var x when x > 2: "two many", "too few" }
|
|
|
|
// Formatted
|
|
e ?
|
|
{
|
|
1: "one",
|
|
2: "two",
|
|
var x when x > 2: "two many",
|
|
"too few"
|
|
}
|
|
|
|
e switch
|
|
{
|
|
1: "one",
|
|
2: "two",
|
|
var x when x > 2: "two many",
|
|
"too few"
|
|
}
|
|
|
|
// Some of these in context of a var
|
|
var x = e
|
|
? 1 -> "one"
|
|
: 2 -> "two"
|
|
: var x when x > 2 -> "too many"
|
|
: _ -> "too few";
|
|
|
|
var x = e ?
|
|
{
|
|
1: "one",
|
|
2: "two",
|
|
var x when x > 2: "two many",
|
|
"too few"
|
|
};
|
|
|
|
var x = e switch
|
|
{
|
|
1: "one",
|
|
2: "two",
|
|
var x when x > 2: "two many",
|
|
"too few"
|
|
};
|
|
|
|
// Some of these as one-liners in a method call
|
|
|
|
M(x switch { null => 0, _ => x.Length }); // 1
|
|
M(x switch { null: 0, x.Length }); // 2
|
|
|
|
M(x ? null -> 0 : _ -> x.Length); // 3
|
|
M(x ? { null: 0, x.Length }); // 4
|
|
|
|
M(x ? null -> 0 : x.Length); // 5
|
|
M(x ? { null -> 0, x.Length }); // 6
|
|
```
|
|
|
|
Argument against 1:
|
|
|
|
``` c#
|
|
strings.Select(x => x switch { null => 0, _ => x.Length }); // Lots of => with different meaning
|
|
```
|
|
|
|
Argument against `->`: Has meaning in unsafe code
|
|
|
|
Argument against `:` as used in 4: Clashes with other uses of `:`.
|
|
|
|
Where input is an expression rather than a variable:
|
|
|
|
``` c#
|
|
M(e switch { null => 0, var x => x.Length }); // 1 - 0
|
|
M(e switch { null: 0, var x: x.Length }); // 2 - 13 - 6
|
|
|
|
M(e ? null -> 0 : var x -> x.Length); // 3 - 1
|
|
M(e ? { null: 0, var x: x.Length }); // 4 - 6 - 3
|
|
|
|
M(e ? { null -> 0, var x -> x.Length }); // 6 - 0
|
|
```
|
|
|
|
We might want to allow the last thing to be a default value without pattern, but not in the prototype.
|
|
|
|
## Conclusion
|
|
|
|
The prototype will have version 2. We're saving for later whether the last clause should be able to leave off a pattern.
|
|
|
|
|
|
# Property pattern
|
|
|
|
``` c#
|
|
if (e is { Name: "Mads", Employer: { ID: string id } }) { WriteLine(id); } // 1 - Current
|
|
if (e is { Name = "Mads", Employer = { ID = string id } }) { WriteLine(id); } // 2
|
|
if (e is { Name == "Mads", Employer == { ID == string id } }) { WriteLine(id); } // 3
|
|
if (e is { Name is "Mads", Employer is { ID is string id } }) { WriteLine(id); } // 4
|
|
```
|
|
|
|
1 is what we have implemented, but it clashes a little with what we just decided for switch expressions.
|
|
2 mirrors object initializers the most
|
|
3 implies equality, but clashes in meaning with `==` elsewhere
|
|
4 emphasizes `is` as a means for applying patterns
|
|
|
|
``` c#
|
|
var result = person switch
|
|
{
|
|
{ Name: "Mads", Employer: { ID: string id } }: id,
|
|
(_, id: var pid){ Name: "Matt" }: pid,
|
|
_: null
|
|
};
|
|
```
|
|
|
|
There's a clash but maybe it doesn't feel too bad. The second pattern with three different meanings of `:` is certainly not common.
|
|
|
|
``` c#
|
|
var result = person switch
|
|
{
|
|
{ Name is "Mads", Employer is { ID is string id } }: id,
|
|
(_, var pid){ Name is "Matt" }: pid,
|
|
_: null
|
|
};
|
|
```
|
|
## Conclusion
|
|
Decision: stay with `:` for prototype, remains open question though! |