[Discussion] Case Declarations

[mattwar]

Proposal Document: https://github.com/dotnet/csharplang/blob/main/proposals/case-declarations.md
Proposal Issue: #9500

[Richiban]

No real comments, this looks great!

One thing that did occur is whether or not casess can be nested? It doesn't seem super valuable to me off the bat but it'd be nice to know if this is syntactically "reserved" in case it ever comes up in future.

public closed record A
{
    case B;
    case C
    {
        case D;
        case E;
    }
}

[KennethHoff]

The most stereotypical OOP example could logically be written in this way, so it's clearly at least a valid concept.

public closed record Animal
{
    case FarmAnimal
    {
        case Cow;
        case Pig;
    }
    case Pet
    {
        case Cat;
        case Dog
        {
            case Chihuahua;
            case Rottweiler;
        }
    }
}

[Richiban]

It'd probably be quickly considered somewhat bad practice to overly nest cases; in your example the type name of Rottweiler would be Animal.Pet.Dog.Rottweiler

[KennethHoff]

Having such a class hierarchy is considered bad practice already. Having it nested doesn't really change that; it's certainly not making it any better though.

[mattwar]

I'd like to allow this but it is not covered in the proposal. There is room in the design space to allow for a meaning for a nested case declaration.

[AndersKehlet]

case Open(float percent) : { pubic void SomeMethod() {...} }

One of the usual suspects. 😉

As for the proposal, I really like this. The semantics look the same as F# class DU's, but the syntax feels like a natural extension of C#.

[AndersKehlet]

Exhaustiveness is mentioned, so no

[mattwar]

The semantics are 100% vanilla subtyping.

The semantics of a case declaration inside a class or record is 100% subtyping, but not when used as part of a union declaration (nominal type union).

[orthoxerox]

There's nothing about union declarations in this proposal, is there?

[AndersKehlet]

Closed and sealed subtyping with exhaustiveness checking is an implementation of unions, no? GateState can be one of three concrete types, which each can have their own schema. That's a union.

[mattwar]

The proposal refers to being used with class, records and unions.

[HaloFour]

It's an interesting concept, but if closed hierarchies don't require this nesting is it necessary to have a language feature that encourages nesting? My personal experience is that domain hierarchies are very rarely nested like this.

Like F#, would there be a value-type version of nested case classes?

[orthoxerox]

I think the mini-proposals deliberately exclude more complicated forms of DUs. But since this syntax currently has no meaning inside value type declarations I don't see why it can't be repurposed for struct-based DUs when (if) they come later.