On Saturday, 30 March 2024 at 14:57:00 UTC, IchorDev wrote:

enum A{
	x,y,z,
    static if(cond){
		w,
	}
}

I don't think static if fits here. There are already special cases for enums which allow things that don't make sense elsewhere when using a declaration list. In particular, requiring the trailing comma is troublesome.

I think what might be in order is to elevate enums to a more structured type (like Swift does).

Something like:

enum ??? foo {
   case x;
   case y;
   case z;
   // constructors?
   this(int n) { this._value = cast(foo)n; }
   // operators?
   opBinary(...)
   // static if works at a declaration scope!
   static if(cond) {
     case a;
   }
}

The ??? is because I'm assuming it would be too ambiguous with existing syntax. Maybe enum struct?

But enums were basically copied from C (with duct-taped on features), and other modern languages (such as swift) have really considered how enums should be designed.

-Steve

On Saturday, 30 March 2024 at 14:57:00 UTC, IchorDev wrote:

enum A{
	x,y,z,
    static if(cond){
		w,
	}
}

It would be strange if this was enabled just for enums but not for other listings. Other possibilities that come to mind:

auto fun(int a, float b, static if(cond){char c, bool d,}) => //...

import std.algorithm, std.range, static if(cond){std.conv,};

pragma(msg, "hello", static if(cond){"world!",});

Also I'm not quite sure of the syntax. When you list something with commas, it resembles an expression, since function argument lists and array literals are also listed with commas and expressions. But in D, you can't use if or static if as an expression - for that you have the conditional operator cond ? whenTrue : otherwise. Could this idea would work better with the conditional operator syntax?

enum A{x, y, z, cond? w: ()}

On second thought, maybe not. You can't do this inside an array literal either unless you also have a value for the "else" case, and you also can't list multiple values for one condition except by defining another array literal outside the original one and concatenating them. Maybe it's time to let us use ifs and conditional compilation directives as parts of expressions, so it'd be consistent with your proposal?

There's another possibility for enums specifically. This could also be solved if you could define them with ; separators like you define classes, structs and unions. If you could define an enum by defining an union with no non-zero members it'd solve this one and also give the existing sum type proposals a run for their money.

On Wednesday, 3 April 2024 at 17:57:31 UTC, Steven Schveighoffer wrote:

enum ??? foo {
   case x;
   case y;
   case z;
   // constructors?
   this(int n) { this._value = cast(foo)n; }
   // operators?
   opBinary(...)
   // static if works at a declaration scope!
   static if(cond) {
     case a;
   }
}

How about inheritance?

enum A
{
  x,y,z,
}

static if(cond)
  enum B : A { w }
else
  alias B = A;

On Thursday, 4 April 2024 at 07:39:36 UTC, Daniel N wrote:

enum A
{
  x,y,z,
}

static if(cond)
  enum B : A { w }
else
  alias B = A;

Doesn't work the way you'd want it to in this case:

enum A
{
  x,y,z,
}

enum B : A { w }

pragma(msg, typeof(B.x)); // A

On Wednesday, 3 April 2024 at 17:57:31 UTC, Steven Schveighoffer wrote:

enum ??? foo {
   case x;
   case y;
   case z;
   // constructors?
   this(int n) { this._value = cast(foo)n; }
   // operators?
   opBinary(...)
   // static if works at a declaration scope!
   static if(cond) {
     case a;
   }
}

Swift's enum is a tagged union. I'd love if we got tagged unions, and the enum struct syntax isn't bad either. If D tagged unions could functionally replace enums (i.e. if they could have an arbitrary number of empty cases) then this would be a fine replacement in my opinion. Sadly, no such feature exists yet.

Another use case I ran into was stuff like:

enum MouseButton: ubyte {
    static foreach(i; 1..9)
        mixin("mouse_"~i.stringof~",");
    mouse_left = mouse_1,
    mouse_right = mouse_2,
    mouse_middle = mouse_3;
}

Though it might make more sense specifically for conditional compilation like version(..).

On Saturday, 30 March 2024 at 14:57:00 UTC, IchorDev wrote:

static if(cond){
	enum A{
		x,y,z,w,
	}
}else{
	enum A{
		x,y,z,
	}
}

enum A{
	x,y,z,
    static if(cond){
		w,
	}
}

I use a mixin generator for my types and I can switch between 2 columns (different languages)/names with a static if. For example:

struct ConsArray(Enum, size_t col)
{
  mixin(makeEnum!col);
  E[] list;
  size_t index;

  enum makeEnum(size_t mod) = () {
    size_t num;
    string str = "enum E {";
    static foreach(i, e; EnumMembers!Enum) {
      static if ((i & 1) ^ mod)
        str ~= e.format!"%s = %s,"(num++);
    }
    return str ~ "}";
  }();
//...
}

void main()
{
  enum Names
  { // mod 1, 0
        Andy, Ali,
       Cindy, Cengiz,
       Kenny, Kaan,
       Micky, Mehmet,
       Sunny, Salih
  }
  auto names = ConsArray!(Names, 1)();
  enum nameEn {Andy,Cindy,Kenny,Micky,Sunny}
}

If we wish, I could just give the enum directly with E without declaring a condition on my type. However this gives me error-free matching.

SDB@79

Indeed why not use manifest constants? Especially mouse buttons and address families are inherently extensible, because they are provided by OS. Variable enum may also force client code to be needlessly versioned to cope with members with conditional existence.