Enum-indexed arrays

[bearophile]

A little ObjectPascal program (works with FreePascal, similar code works in Ada 
too):

Type  
  Direction = (North, East, South, West); 
  Tarray = array [Direction] of integer;
var
  a: Tarray;
  d: Direction;
begin
  d := North;
  a[d] := 1;
  writeln(a[d]);
end.


'Direction' is an assigned enumerated type, similar to a D enum, and T is a 
strong type (like D1 typedef, currently there is no replacement in D2) of a 
fixed-sized (here stack-allocated) array of four integers that has Direction as 
indexes.

Such kind of enum-indexed arrays are common enough, and in ObjectPascal they 
are efficient and safe (the compiler refuses an index of type different from 
Direction. There is no need of runtime array bound tests).

A similar D2 program is:


import std.stdio: writeln;
enum Direction { North, East, South, West }
alias int[Direction] Tarray; // weak type definition
void main() {
    Direction d = Direction.North;
    Tarray a = [d: 1];
    writeln(a[d]);
    // a[5] = 1; // good, cannot implicitly convert expression
}


Beside not being Tarray a strong type definition, another important difference 
is that Tarray is an associative array.
An advantage of associative arrays over fixed-sized arrays is that it works 
even if you assign arbitrary numbers to the enum items ({ North = 756, ... }), 
and it's managed by reference (so there are less troubles in passing it 
around), but compared to a naive fixed-sized array they are quite less 
efficient in performance, memory and GC activity.

So when enums are default ones (with no numbers specified for indexes) I miss 
Enum-indexed fixed-sized arrays a bit in D2 :-)

A first try at D2 implementation:


import std.stdio: writeln;
import std.traits: EnumMembers;

struct EnumIndexedArray(E, T) if (is(E == enum)) {
    static bool areConsequential(E)() {
        foreach (i, field; EnumMembers!E)
            if (i != field)
                return false;
        return true;
    }

    static assert(areConsequential!E(),
                  "Enum fields aren't consequential starting from 0");

    alias EnumMembers!E Efields;
    enum int NFIELDS = Efields.length;
    T[NFIELDS] data;
    alias data this;

    T opIndexAssign(T value, E e) { data[e] = value; return value; }
    T opIndex(E e) { return data[e]; }
}

// demo ---------------

enum Direction { North, East, South, West }
alias EnumIndexedArray!(Direction, int) Tarray;

void main() {
    Direction d = Direction.North;
    Tarray a;
    a[d] = 1;
    writeln(a[d]);
    //a[2] = 1; // good, error
}

Bye,
bearophile