Task

Create an enumeration of constants with and without explicit values.




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));
}