***Warning: These are raw notes, and still need to be cleaned up. Read at your own peril!***
## Agenda
Triage
# 7.3
Moved undone 7.3 features to 8.0.
# Allow default in deconstruction
We allowed for `==`, so it seems we should also allow it for assignment and initialization.
Should probably not require `ValueTuple`, but that's more of a compiler thing.
## Conclusion
The feature is a good idea. Even though it's simple, we should not rush it into 7.3. 8.0.
``` c#
case Customer { MiddleName: "" or null }
```
# and, or and not patterns 1350
`not` feels useful. `and` is hard to come up with scenarios for. `or` has more scenarios, but may be better served by a `in { 1, 2, 3 }` style pattern.
``` c#
if (x is not string s) { ... }
else { ... /* s */ }
```
`not` would cause definite assignment to "flip". Should `s` be disallowed in a `not` pattern.
The `{}` pattern for not null is a bit cryptic. `not null` would certainly be more direct.
## Conclusion
Punt to 8.x, when we know more of the rest of the pattern story.
# partial type inference #1349
We've talked about this many times in the past, but couldn't settle on a syntax that was nice enough and worth its while.
A 4th option: allow M<string>(...) to match an M with more type parameters. But that probably goes against intuition and would complicate overload resolution.
For 2: Just commas is known from typeof, so that concept is already in the language, though you can't mix "there" and "not there" today.
## Conclusion
8.X is when we'll look at it again.
# Permit `t is null` for unconstrained type parameter #1284
For null we special case type parameters in all other kinds of places, so this is the only place where you can't.
Also, `t is 3`. We allow *type* patterns, but not constant patterns.
## Conclusion
Absolutely should do this. Mark as 8.0.
# Implicitly scoped using #114 #1174
We have sympathy for this syntactic sugar, and we'd be interested in allowing it. It seems related to similar features, such as "defer" statements (avoids nesting `try/finally`).
Also fits nicely with the work we already did with expression variable scoping.
Also namespace without curlies, where you just say `namespace X.Y;` and it's in force for the remainder of the file.