Proposal: new first-class ValueType entity — Order/Hierarchy

[forgotten-aquilon]

My idea is similar to #587, but with several exceptions.

I want to propose a new data type which represents single node from tree-like structure. It can be helpful to use as a self-explaining marker in complex systems where at some level of abstraction different objects are represented by the same class. It can be solved by using enum, but it is a "linear" type (in a sense all its possible values are of the same order), so additionally can be added attributes, but their managing can become too complex.

public order GameItemType
{
    Weapon
    {
        SingleHanded
        {
            Sword,
            Wand,
            Knife,
            [...]
        },
        TwoHanded
        {
            Sword,
            Bow,
            Hammer,
            [...]
        }
    },
    Consumable
    {
        Food,
        Tonic
        {
            Healing,
            Empowering,
            [...]
        }
    },
    Clothing
    {
        Head,
        Top,
        Bottom,
        Ring,
        [...]
    },
}

GameItemType itemType1 = GameItemType.Weapon.SingleHanded.Sword; // Ok
GameItemType itemType2 = GameItemType.Weapon.TwoHanded.Sword; // Ok

var eq = itemType1 != itemType2; // True

GameItemType itemType3 = GameItemType.Consumable.Food; //Ok
GameItemType itemType4 = GameItemType.Clothing; //Error!

As you can see order can represents different levels of nestedness. Also objects of the same type are compared by their full values, not the terminal one.

You can create order object only if its last element is a Terminal. All nodes without children are Terminal. But you can explicitly mark a node with children as a Terminal with '?' symbol.

public order Position
{
    President,
    VP,
    Minister
    {
        VC,
        MinisterOfDefence?
        {
            Deputy
        },
        MinisterOfFinance?
        {
            Deputy
        },
    }
}

Position p1 = Position.Minister.MinisterOfDefence; // Ok
Position p2 = Position.Minister.MinisterOfDefence.Deputy; // Ok
Position p3 = Position.Minister; //Error!

Even the very type as an entry node can be marked as a Terminal:

public order Entity?
{
    SubEntity,
}

Entity e1 = Entity; // Ok
Entity e2 = Entity.SubEntity; // Ok

Possible implementation:

OrderNode is a core struct, which contains information about single separate node of the type, including its name, children and is it Terminal node or not.

public readonly struct OrderNode
{
    public string Name { get; }

    public bool IsTerminal { get; }

    public IReadOnlyDictionary<string, OrderNode> Nodes { get; }

    public OrderNode(string name)
    {
        if (String.IsNullOrWhiteSpace(name))
        {
            throw new ArgumentException("Order item can not be empty");
        }

        Name = name;
        IsTerminal = true;
        Nodes = new Dictionary<string, OrderNode>().AsReadOnly();
    }

    public OrderNode(string name, IReadOnlyDictionary<string, OrderNode> nodes)
    {
        if (string.IsNullOrWhiteSpace(name))
        {
            throw new ArgumentException("Order item can not be empty");
        }

        Name = name;
        IsTerminal = false;
        Nodes = nodes;
    }
}

Should be generated new struct with the user-defined name, where static constructor generates code, which creates all nested nodes based on parsed user-defined structure of a type.

public readonly struct OrderObject__TYPENAME : IEquatable<OrderObject>
{
    public static OrderNode Order { get; }
    public IReadOnlyList<string> Items { get; }

    public char Separator { get; }

    public readonly string Root => Items[0];

    public readonly string Value => Items[^1];

    static OrderObject__TYPENAME()
    {
        // Order = ...
        // Here we generate code for setting nested OrderNode objects representing the data structure
    }

    public OrderObject__TYPENAME(IReadOnlyList<string> items, char separator = '.')
    {
        Items = items;
        Separator = separator;
        ValidateObject();
    }

    public override string ToString() => string.Join(Separator, Items);

    public bool Equals(OrderObject__TYPENAME other)
    {
        return this.ToString() == other.ToString();
    }

    public override bool Equals(object? obj) => obj is OrderObject__TYPENAME other && this.Equals(other);

    public override int GetHashCode() => this.ToString().GetHashCode();

    private void ValidateObject()
    {
        OrderNode iterationNode = Order;

        for (int i = 0; i < Items.Count; i++)
        {
            string nodeName = Items[i];

            if (nodeName != iterationNode.Name)
            {
                throw new Exception("Node name is not equal to item name");
            }

            if (!iterationNode.IsTerminal && i == Items.Count-1)
            {
                throw new Exception("Node is not marked as terminal but is the last in the list of items");
            }

            if (!iterationNode.IsTerminal && !iterationNode.Nodes.TryGetValue(nodeName, out iterationNode))
            {
                throw new Exception("Node is not marked as terminal but is doesn't contain child nodes");
            }
        }
    }
}

So newly created type provides ability to check in runtime all inner structure of a type. You can set separator symbol which will affect comparison of objects. In compile time the parser should read initialization of order variable as a string, e.g.

var o = OrderType.Level1.Level2; // "OrderType.Level1.Level2".Split(OrderType.Separator);

split it by separator and pass into the constructor.

Well, it's not enum because of nested nature, it converts to a string by default and there is no casting to numeric values.

[colejohnson66]

I'm confused. You're proposing not just nested enums, but an OrderNode that allows reflection? Why not just use reflection on nested enums (when/if they're added)?

And to beat a dead horse: your use case feels extremely niche and would be easily served with a JSON input to a source generator.

[forgotten-aquilon]

OrderNode that allows reflection

It's just a support structure, which is used to create a Tree.

Why not just use reflection on nested enums

I linked #587 issue and it seems nested enums will never be added, because of reasons. So I proposed the alternative to nested enums.

your use case feels extremely niche

I mostly agree, but still...

would be easily served with a JSON input to a source generator.

Well, the idea to have it as a part of standard with syntax, linter and hinting support,

[TahirAhmadov]

If the objective is just the behavior of an enum, just with nested definition syntax, I don't think it deserves a feature. Instead, an SG can be used to write this:

public class OrderRoot : Attribute { }
public class OrderNesting<T> : Attribute where T : struct, Enum { }

public enum _SingleHanded
{
		Sword,
		Wand,
		Knife,
		[...]
}
public enum _Weapon
{
	[OrderNesting<_SingleHanded>]
	SingleHanded,
	[OrderNesting<_TwoHanded>]
	TwoHanded
}
[OrderRoot]
public enum _GameItemType
{
	[Nesting<_Weapon>]
	Weapon,
}

// SG generates:
public enum GameItemType
{
	Weapon_SingleHanded_Sword,
	Weapon_SingleHanded_Wand,
	Weapon_SingleHanded_Knife,
	// ... etc. ....
}

[miyu]

This seems like a natural extension to type unions where one would allow pattern-matching to a union-of-unions recursively.

enum SingleHanded {}
enum TwoHanded {}
enum Food {}
enum Tonic {}
enum Clothing {}
union Weapon(SingleHanded, TwoHanded)
union Consumable(Food, Tonic)
union GameItemType(Weapon, Consumable, Clothing)

GameItemType x;
switch(x) {
  case SingleHanded: /* matches GameItemType.Weapon.SingleHanded */
  case Weapon:  /* matches GameItemType.Weapon.* */
  case Clothing: /* matches GameItemType.Clothing */
}

[miyu]

See Also: #399