Maintainer trait for domain enumeration values

[HernanFAR]

Currently I'm working with a project using domain driven design and I create some traits and prelude functions for DomainType, and I think that maybe worth to showcase them

As you will see, the Maintainer interface is a trait that must be associated with any "domain enumeration", like states of an entity or any limited set of values that represents something. These are the following definitions

// Maintainer.Trait.cs
public interface Maintainer<Self>
    where Self : Maintainer<Self>
{
    abstract static Seq<Self> All { get; }
}

public interface Maintainer<Self, out Key> 
    : Maintainer<Self>
    where Self : Maintainer<Self>
    where Key : Identifier<Key>
{
    Key Id { get; }
}

// Maintainer.Prelude.cs

public static partial class Prelude
{
    public static Seq<A> get<A>() 
      where A : Maintainer<A> =>
      A.All;

    public static Option<A> find<A>(Func<A, bool> fa)
      where A : Maintainer<A> =>
      get<A>().Find(fa);

    public static A findUnsafe<A>(Func<A, bool> fa)
        where A : Maintainer<A> =>
        find(fa) switch
        {
            A a => a,
            _ => throw new InvalidOperationException("Option was None")
        };
}

// Maintainer.Extensions.cs

public static class MaintainerExtensions
{
    extension<A>(A)
        where A : Maintainer<A>
    {
        public static Option<A> Find(Func<A, bool> fa) =>
            find(fa);

        public static A FindUnsafe(Func<A, bool> fa) =>
            findUnsafe(fa);
    }

    extension<A>(A a)
        where A : Maintainer<A>
    {
        public bool Is(A b) => a.Equals(b);
        public bool IsNot(A b) => not(a.Equals(b));
    }

}

Here is and example

public sealed class ComplexityLevel 
    : Maintainer<ComplexityLevel, ComplexityId>
{
    public const string VeryLowId = "0f2c5ae4-518b-4b1f-9449-4da1493bfb9b";
    public const string LowId = "f3c13263-0626-4654-b563-a99f1226b5a4";
    public const string MediumId = "bf818adf-dc0f-4807-a3f9-52af7c222b01";
    public const string HighId = "043db43d-3b58-4f96-ad35-952063c92e10";
    public const string VeryHighId = "7b9a7803-4031-40db-8a67-99a19b4d585f";

    public ComplexityId Id { get; }

    public string Name { get; }
    
    public int Value { get; }

    private ComplexityLevel(ComplexityId id, string name, int value)
    {
        Id = id;
        Name = name;
        Value = value;
    }

    public static ComplexityLevel VeryLow { get; } =
        New(VeryLowId, "Muy baja", 1);

    public static ComplexityLevel Low { get; } =
        New(LowId, "Baja", 2);

    public static ComplexityLevel Medium { get; } =
        New(MediumId, "Medio", 3);

    public static ComplexityLevel High { get; } =
        New(HighId, "Alta", 4);

    public static ComplexityLevel VeryHigh { get; } =
        New(VeryHighId, "Muy alta", 5);

    public static Seq<ComplexityLevel> All { get; } =
    [
        VeryLow,
        Low,
        Medium,
        High,
        VeryHigh
    ];

    private static ComplexityLevel New(string id, string name, int value) =>
        new(new ComplexityId(id), name, value);

}

And it can be used like this

public void Sample()
{
  string levelIdValue = ComplexityLevel.LowId;

  Option<ComplexityLevel> a = ComplexityLevel.Find(c => c.To() == levelIdValue);
  Option<ComplexityLevel> b = find<ComplexityLevel>(c => c.To() == levelIdValue);
  ComplexityLevel                 c = findUnsafe<ComplexityLevel>(c => c.To() == levelIdValue)
}

What do you think? :)

---

Going forward

We can improve this trait by a source generator, it maybe posible to take the default values and create an "Match" instance method, following the example

public static class X
{
    extension(Option<ComplexityLevel> ma)
    {
          public A Match<A>(Func<A> VeryLow,
                      Func<A> Low,
                      Func<A> Medium,
                      Func<A> High,
                      Func<A> VeryHigh,
                      Func<A> None) =>
          ma.Case switch
          {
              ComplexityLevel cl => cl.Match(VeryLow, Low, Medium, High, VeryHigh),
              null => None()
          };
    }
    
    extension(ComplexityLevel a)
    {
        public A Match<A>(Func<A> VeryLow,
                          Func<A> Low, 
                          Func<A> Medium, 
                          Func<A> High, 
                          Func<A> VeryHigh) =>
            a switch
            {
                not null when a == ComplexityLevel.VeryLow => VeryLow(),
                not null when a == ComplexityLevel.Low => Low(),
                not null when a == ComplexityLevel.Medium => Medium(),
                not null when a == ComplexityLevel.High => High(),
                not null when a == ComplexityLevel.VeryHigh => VeryHigh(),
                _ => throw new InvalidOperationException($"Value {a} not found in {ComplexityLevel.All}")
            };
    }
}

So it can be used like this

public void Sample2() 
{
        ComplexityId levelId = new ComplexityId(ComplexityLevel.LowId);

        var result1 = findUnsafe((ComplexityLevel cl) => cl.Id == levelId)
            .Match(VeryLow: () => "Muy bajo",
                        Low: () => "Bajo",
                        Medium: () => "Medio",
                        High: () => "Alto",
                        VeryHigh: () => "Muy alto");

        var result2 = find((ComplexityLevel cl) => cl.Id == levelId)
            .Match(VeryLow: () => "Muy bajo",
                       Low: () => "Bajo",
                       Medium: () => "Medio",
                       High: () => "Alto",
                       VeryHigh: () => "Muy alto",
                       None: () => "Sin ingresar");
}

---

Hi, @louthy! How' it going? I hope you're ok! I would like to create a PR with this trait, if you like the idea

[louthy]

By the way, I'm not ignoring this, I have seen it, just not had time to take it in yet. Once I get the foldable changes complete (in the ref-folds branch), I'll take a closer look.

[HernanFAR]

Hi Louthy! How it's going? :) Don't worry about that, you have your own time and priorities. It's understandable

Also, thanks for answering, I didn't notice that were a ref-folds branch, I'll take a look