enum behaivor. another rehash of the topic

Joseph Rice ricejm01 at gmail.com
Sat Dec 14 17:16:39 PST 2013


While I must first Admit I'm new to D.   However; I have been a 
C/C++ programmer for 15 years. I am excited about D.  One of the 
features I love is being able to access my legacy code.    But 
there are some cases were a complete re-write/re-factor to D 
makes sense. I've come to it very frustrating code that has been 
stable for years now needs to be changed because of a language 
quirk.  The main selling point about D is C/C++ is almost the 
same syntax,  I see potential in D to replace C/C++.

I've noticed that enum behavior is dramatically different.  This 
is my opinion,  but I see this as a flaw in D.  Again let me 
repeat, My opinion.   While I understand D's approach to enum's.  
It is a hard pill to swallow for an experienced programmer.

The D compiler should know the type of the enum from the symbol.  
You should not have to type the NAME.element when doing a 
comparison or assignment.   Declaring an enum FOO { one, two, 
three} should be the same as declaring a new type.   So that when 
you declare `FOO bar;` in code, assignment and comparison of 
`bar`  should know what bar is comprised of because it is of type 
enum FOO.   Therefore anything of type enum FOO can only comprise 
of the values 'one', 'two', or 'three'.

I've prepared 3 examples, a C, C++, and Finally D.  All 
essentially the same code.  You will notice that the D version, 
has some vast differences. For example you can not define an enum 
and declare the variable all at once.   This gets me to the 
annoying part.  assigning and Comparing.

jrice at Wayland:~/prj/enum_example$ gcc -o enum_c enum.c
jrice at Wayland:~/prj/enum_example$ g++ -o enum_cpp enum.cpp
jrice at Wayland:~/prj/enum_example$ dmd enum.d
jrice at Wayland:~/prj/enum_example$ ./enum_c
It's test1
jrice at Wayland:~/prj/enum_example$ ./enum_cpp
It's test1
jrice at Wayland:~/prj/enum_example$ ./enum
It's test1
jrice at Wayland:~/prj/enum_example$ cat enum.c
#include <stdio.h>

void main() {
	enum TEST {
		test1=0,
		test2
	} test;

	test = test1;
	
	switch (test) {
		case test1:
			printf("It's test1\n");
			break;
		case test2:
			printf("It's test2\n");
			break;
		default:
		break;
	}
}
jrice at Wayland:~/prj/enum_example$ cat enum.cpp
#include <iostream>
using namespace std;

int main() {
	enum TEST {
		test1=0,
		test2
	} test;

	test = test1;
	
	switch (test) {
		case test1:
			cout << "It's test1" << endl;
			break;
		case test2:
			cout << "It's test2" << endl;
			break;
		default:
		break;
	}
	return 0;
}
jrice at Wayland:~/prj/enum_example$ cat enum.d
import std.stdio;

void main() {
	enum TEST {
		test1=0,
		test2
	};

	TEST test = TEST.test1;
	
	switch (test) {
		case TEST.test1:
			writeln("It's test1");
			break;
		case TEST.test2:
			writeln("It's test2");
			break;
		default:
		break;
	}
}

So as you can see, D is just awkward, and it becomes tedious 
especially if you have many many many values in the enum.


So D language Designers and maintainers:

1st

I understand your reasons, it makes it un-ambiguous, becaause you 
know exactly which enum `test1` belongs too.

2nd

What the heck, why do I have to type extra.  It makes porting a 
little mre frustrating, and makes me question using D in the 
first place.

3rd

I'm Pleading to you to consider making both syntax's valid. The 
Old C/C++ way,  and the D way.  If you have too, make compiler 
flag.


More information about the Digitalmars-d mailing list