Classes as enums in D?

[Meta via Digitalmars-d-learn]

On Monday, 30 November 2015 at 07:48:37 UTC, Andrew LaChance 
wrote:
> Hello,
> D has intrigued me for a while, and I thought I would finally 
> read up on it!  I've been reading "Programming in D" by Ali 
> Çehreli and I've been thinking about how I can use the language 
> in a side project I'm working on, porting it from java to D.  
> One of the uncommonly-used features of java that I like is how 
> enums can be full classes (though I don't like that there's no 
> option to use enums as e.g. regular ints).  This allows several 
> benefits, such as the ability to use them in switch statements 
> like regular enums, the full set of objects is known at compile 
> time, all objects are immutable, it's impossible to 
> accidentally or purposefully create new objects of that type, 
> etc...
>
> For example (in java), if I wanted to have an enum that 
> describes all the white keys on a piano keyboard and have 
> members that describe the number of half-steps to the next 
> white key and to the previous white key, I can define an enum 
> (the "id" or enum value is implicitly defined so it doesn't 
> have to be explicitly written in the definition):
>
> enum WhiteKey
> {
>     A(2,2),
>     B(2,1),
>     C(1,2),
>     D(2,2),
>     E(2,1),
>     F(1,2),
>     G(2,2);
>
>     private final int halfStepsToNext;
>     private final int halfStepsToPrevious;
>
>     WhiteKey(int halfStepsPrevious, int halfStepsNext)
>     {
>         this.halfStepsToPrevious = halfStepsPrevious;
>         this.halfStepsToNext = halfStepsNext;
>     }
> }
>
> From what I've read and seen, in D all enums have forced to 
> integral types.  Is it possible to do the above in D and I have 
> just missed it?  I can think of a few ways around it (such as 
> statically create and define a bunch of WhiteKey structs, ...), 
> but none are as clean as the above.  If this isn't something 
> supported, is it on a roadmap of wanted features?
>
> Thanks!  I'm looking forward to really getting to know the 
> language.

Yes and no. You can use arbitrary types for enums in D but a lot 
of the time you shouldn't when it involves types that are not 
Plain Old Data. A naive translation would be like this:

class WhiteKey
{
	private immutable int halfStepsToNext;
	private immutable int halfStepsToPrevious;

	enum
	{
		A = new WhiteKey(2, 2),
		B = new WhiteKey(2, 1),
		C = new WhiteKey(1, 2),
		D = new WhiteKey(2, 2),
		E = new WhiteKey(2, 1),
		F = new WhiteKey(1, 2),
		G = new WhiteKey(2, 2),
	}
	
	private this(int halfStepsToPrevious, int halfStepsToNext)
	{
		this.halfStepsToPrevious = halfStepsToPrevious;
		this.halfStepsToNext = halfStepsToNext;
	}
}

However, you do NOT want to do this, as everywhere you use 
WhiteKey's members, a new object will be created. For example:

auto f = WhiteKey.A;
auto n = WhiteKey.A;
	
import std.stdio;
writeln(&f, " ", &n);

This will two different addresses, because a new object is being 
created each time. It's basically taking the expression `new 
Key(2, 2)` and copy-pasting it wherever you use WhiteKey.A. 
Java's enums are basically syntax sugar for this:

class WhiteKey
{
	private immutable int halfStepsToNext;
	private immutable int halfStepsToPrevious;

	public static WhiteKey A = new WhiteKey(2, 2);
	public static WhiteKey B = new WhiteKey(2, 1);
	public static WhiteKey C = new WhiteKey(1, 2);
	public static WhiteKey D = new WhiteKey(2, 2);
	public static WhiteKey E = new WhiteKey(2, 1);
	public static WhiteKey F = new WhiteKey(1, 2);
	public static WhiteKey G = new WhiteKey(2, 2);
	
	private this(int halfStepsToPrevious, int halfStepsToNext)
	{
		this.halfStepsToPrevious = halfStepsToPrevious;
		this.halfStepsToNext = halfStepsToNext;
	}
}

This doesn't quite work in D; you'd have to make each WhiteKey 
const (which is probably not a bad idea anyway if you're using it 
like an enum). However, it's better to just do this with plain 
old value-type structs. It's exactly the same as my previous code 
defining a WhiteKey class with an embedded enum, but using a 
struct instead of a class.