reinterpret array

[Dominikus Dittes Scherkl via Digitalmars-d-learn]

On Tuesday, 13 January 2015 at 23:36:51 UTC, Artur Skawina via 
Digitalmars-d-learn wrote:
> It's neat, but the real problems with it are:
> 1) obfuscation - it hides those trivial bit ops behind layers of
> functions and operator overloads, which everyone reading the
> code must then figure out;

Ok, but this is the case with any function - and this modulo stuff
is easy but not so trivial that a function is not justified.

> 2) safety - `a.bit` could potentially outlive `a`; D does not
> handle object lifetimes, so there's no 100% safe way to prevent
> such bugs.
This can be addressed with the newer proposed mechanisms and a 
little
more information-hiding (generator function):

>
> Hence you probably don't actually want to use this.
> [...]
I had something pretty close to that in mind:

@property inout bit(T)(inout ref T a)
    pure @safe @nogc nothrow
    if(isUnsigned!T || (isArray!T && isUnsigned!T[0]))
{
    struct BitArray(T)
    {
    private:
       enum s = std.bitop.bsr(T.sizeof)+2;
       enum m = (1<<s)-1;
       inout T* r;
       size_t len;
    public:
       this(inout T* p, size_t d) { r = p; len = d<<s; }

       bool opIndex(size_t idx) const // get bit
       {
          return (idx < len) ? (r[idx>>s]>>(idx & m))&1u : false;
       }

       static if(isMutable!T)
       {
          void opIndexAssign(bool b, size_t idx) // set or clear 
bit
          {
             if(idx < len)
             {
                if(b) r[idx>>s] |= 1u<<(idx & m);
                else r[idx>>s] &= ~(cast(T)1<<(idx & m));
             }
          }
       }
    }
    static if(isUnsigned!T)
       return BitArray(&a, 1);
    else
       return BitArray(&a[0], a.length);
}