Implementation of "smart enums"

[moon3legro]

I have always seen and thought about quote-unquote "java enums are better than c# enums". After doing a bit of research I partially agree, but I quite like the simplicity of c# enums. So instead, I thought of some ideas on how to implement "smart enums" and be able to use the old simplicity of enums without breaking old projects while being able to use more complex enums if users wish. Here is my proposed syntax: (Note: the proposed semantics and syntax have been changed, please scroll down further)

public enum Example1 : byte
{
	One, //same as One()
	Two = 2, //same as Two(2)
	Three(4); //same as Three = 4, semicolon is required only if there are more statements after (e.g. user-defined constructors)

	Example1() { } //error, cannot override implicit constructor
	Example1(byte value) { } // error, cannot override implicit constructor
}

public enum Example2 : IExample, byte //the encapsulated integer must be last
{
	One(1, 0),
	Five(5, 1); //not the same as Five = 1, 5 or Five = (1, 5) because invalid syntax

	int number; //public by default; is sort of a 'more strict readonly', as can be seen below
	float someValue = 0f; //is this valid? or only in constructors
	List<int> referenceType;

	//constructors are private by default, can explicitly define as private
	Example2(int _number) //error, user-defined constructors must call one of the implicit constructors
	{
		number = _number;
	}
	
	private Example2(int _number, byte value) : new(value) //OK
	{
		number = _number;
	}

	public Example2(string foo) : new() { } //error, constructors cannot be public

	void IExample.ExampleMethod() { }

	public void ExampleMethod()
	{
		_ = number; //OK
		number = 9; //error, cannot modify value
		referenceType.Add(); //error, cannot modify value (maybe difficult to detect)
		referenceType.NonExistentProperty = 202; //error, cannot modify value (property has setter)
		_ = (Example2)1; //returns Example2.Five
		Example2 someValue = (Example2)404; //no such value, ToString() returns "404"
		_ = someValue.number; //should it throw an InvalidOperationException?
	}
}

public enum Example3
{
	One,
	Two,
	Three
}

Note: I have read #5937, but mine proposes a different syntax that doesn't break some old projects. As another example of the syntax:

public enum Subscription {
    Free("Free Tier", 0),
    Prime("Premium Tier", 25),
    Vip("VIP Tier", 50);

    string Name;
    int Discount;

    public Subscription(string name, int discount) : new()
    {
        Name = name;
        Discount = discount;
    }

    public string GetName()
    {
        return Name;
    }

    public string GetDiscount()
    {
        return Discount;
    }
}

UPDATE: I have changed my proposed semantics and my proposed syntax.

//there is now only one user-defined constructor
//the arguments are the members, which are always public, are fields, and are a 'more strict readonly' as I previously described
//is now more like a record struct if you ask me
//the contextual keyword 'value' is valid in this context as an argument, to specify that it is only an argument, not a field; only to be passed to the implicit constructor
//e.g. enum Example4(... , short value) : short, new(value) and enum Example5(... , int value) : new(value)
public enum Subscription(string Name, int Discount)
//user-defined constructor implicitly calls the implicit parameterless constructor new()
//the second to last type in the ": , , , ..." "inheritance order" may now be the encapsulated integer, and the last may be the implicit constructor to call (e.g. enum Example4 : IExample, short, new())
{
    Free("Free Tier", 0),
    Prime("Premium Tier", 25),
    Vip("VIP Tier", 50);

   //properties cannot have setters, cannot be auto-implemented, and are also a 'more strict readonly'
   //events of created instances (e.g. Subcription sub = Subcription.Free) will never change if the instance is re-assigned

    string GetName() //methods (more broadly members) are now by default public and must be public; can be explicitly declared public
    {
        return Name;
    }

    public string GetDiscount()
    {
        return Discount;
    }
}

public enum Old
{
    One, //cannot be One() nor One(0) but can be One = 0
    Two
}

public enum New1()
{
    One(), //cannot be One, One = 0 nor One(0)
    Two()
}

public enum New2(int value) : new(value)
{
    One(0), //cannot be One, One = 0 nor One()
    Two(1)
}

If you don't understand feel free to ask some questions!

[huoyaoyuan]

Syntax is the least significant point for designing such type system, and often decided in very late stage. Instead, we are focusing on what semantics we want to achieve.

[moon3legro]

Well, I guess you are correct, but what semantics haven't been mentioned/discussed at my post? What even is semantics? (I know less when it comes to the more technical side of programming languages)

[huoyaoyuan]

First of all, what "enum" do we want? Replicating a feature/name from other language isn't a good answer. As long discussed in #5937, the majority (if not all) of proposed feature overlaps with discriminated unions/enhanced extensions.

The behaviors should be discussed in detail. How will the type be in nature, as value type or reference type? Their semantics are way different.
Then go deeper, if the new "enum" can't be trivially casted from/to numbers because of extra field, why does it ever use an underlying number? Enums are having strong requirements for its semantics for example casting, attaching extra things like fields will immediately break some semantics. Why should it be called "enum" at all?

This is just a non-exhaustive list appears quickly in mind.

[moon3legro]

How will the type be in nature, as value type or reference type?

Enums in c# have always been value types, why ask this question? It is still a value type.

if the new "enum" can't be trivially casted from/to numbers because of extra field, why does it ever use an underlying number?

Enums in c# are basically wrappers for the primitive integral types, that is why I think there is an underlying number. To quote Comparison of C# and Java:

C# has implemented enumerations in a manner similar to C, that is as wrappers around the bit-flags implemented in primitive integral types (int, byte, short, etc.). This has performance benefits and improves interaction with C/C++ compiled code, but provides fewer features and can lead to bugs if low-level value types are directly cast to an enumeration type, as is allowed in the C# language.

[huoyaoyuan]

The "smart enum" isn't comparable with enum just because Java calls them "enum". The extra state will break a lot of characteristics.

Enums in c# have always been value types, why ask this question? It is still a value type.

Having extra state in value type would cause more troubles, including wasted or uninitialized fields and value tearing.

Enums in c# are basically wrappers for the primitive integral types, that is why I think there is an underlying number.

This doesn't support why the "smart enum" should inherit this.

[moon3legro]

The "smart enum" isn't comparable with enum just because Java calls them "enum".

"Smart enum" is a term I use to describe enums in java, not an actual new object type to be proposed.

The extra state will break a lot of characteristics.

What exactly?

Having extra state in value type would cause more troubles, including wasted or uninitialized fields and value tearing.

If variables are never used, why even include them? If fields are uninitialized, why not discuss what happens to the field if that scenario happens? Why not initialize it with the default value of the type? Why not be a better programmer and don't leave it uninitialized in the first place?

This doesn't support why the "smart enum" should inherit this.

Because this proposal is more like an overhaul without removing old functionality. Not like I am proposing an entirely new object type. It is still an enum.

[HaloFour]

At this point I think the effort should be focused on discriminated unions since they cover a superset of use cases. A singleton case in a DU is basically the same as a "smart enum" case, and should both be a data carrier as well as support implementation and members.

[moon3legro]

Could you please provide an example?

[HaloFour]

You can kind of imagine it as a closed hierarchy of record types, where each can have associated data elements. Sometimes those data elements are provided by the declaration (like in the Subscription example you provided), whereas others can be parameters to the case itself, or a combination. A really basic example might be something like this:

public enum Color(int r, int g, int b) {
    Red(255, 0, 0),
    Green(0, 255, 0),
    Blue(0, 0, 255),
    Black(0, 0, 0),
    White(255, 255, 255),
    Other(int r, int g, int b);

    // can also have members
    public int Red => r;
    public int Green => g;
    public int Blue => b;
}

// can be used like:
Color red = Color.Red;
Color cyan = Color.Other(0, 255, 255);

// deconstruct
var (r, g, b) = cyan;

// match
var name = cyan switch {
    Red => "red!",
    Other(0, 255, 255) => "cyan!",
    _ => "who knows"
};