Data commit

Task/Enumerations/D/enumerations.d

@@ -0,0 +1,50 @@
+void main() {
+    // Named enumeration (commonly used enum in D).
+    // The underlying type is a 32 bit int.
+    enum Fruits1 { apple, banana, cherry }
+
+    // You can assign an enum to the general type, but not the opposite:
+    int f1 = Fruits1.banana; // No error.
+    // Fruits1 f2 = 1; // Error: cannot implicitly convert.
+
+    // Anonymous enumeration, as in C, of type 32 bit int.
+    enum { APPLE, BANANA, CHERRY }
+    static assert(CHERRY == 2);
+
+    // Named enumeration with specified values (int).
+    enum Fruits2 { apple = 0, banana = 10, cherry = 20 }
+
+    // Named enumeration, typed and with specified values.
+    enum Fruits3 : ubyte { apple = 0, banana = 100, cherry = 200 }
+
+    // Named enumeration, typed and with partially specified values.
+    enum Test : ubyte { A = 2, B, C = 3 }
+    static assert(Test.B == 3); // Uses the next ubyte, duplicated value.
+
+    // This raises a compile-time error for overflow.
+    // enum Fruits5 : ubyte { apple = 254, banana = 255, cherry }
+
+    enum Component {
+        none,
+        red   = 2 ^^ 0,
+        green = 2 ^^ 1,
+        blue  = 2 ^^ 2
+    }
+
+    // Phobos BitFlags support all the most common operations on flags.
+    // Some of the operations are shown below.
+    import std.typecons: BitFlags;
+
+    alias ComponentFlags = BitFlags!Component;
+    immutable ComponentFlags flagsEmpty;
+
+    // Value can be set with the | operator.
+    immutable flagsRed = flagsEmpty | Component.red;
+
+    immutable flagsGreen = ComponentFlags(Component.green);
+    immutable flagsRedGreen = ComponentFlags(Component.red, Component.green);
+    immutable flagsBlueGreen = ComponentFlags(Component.blue, Component.green);
+
+    // Use the & operator between BitFlags for intersection.
+    assert (flagsGreen == (flagsRedGreen & flagsBlueGreen));
+}