I'm new to D2, so please.. :)

The spec on Array Operations, http://www.digitalmars.com/d/2./arrays.html says: """A vector operation is indicated by the slice operator appearing as the lvalue of an =, +=, -=, *=, /=, %=, ^=, &= or |= operator."""

The following tests works fine as I expected:


        {
                double[3] a = [1,1,1];
                double[3] b;
                b[] = a[] + 3;
                assert(a == [1,1,1]);
                assert(b == [4,4,4]);
        }
        
        {
                double[3] a = [1,1,1];
                auto b = a;
                b[] = a[] + 3;
                assert(a == [1,1,1]);
                assert(b == [4,4,4]);
        }

But from here on I'm having problems...

        {
                double[] a = [1,1,1];
                double[] b;
                b[] = a[] + 3;
                assert(a == [1,1,1]);
assert(b == [4,4,4]); // fails as b.length == 0.. Should the compiler say something?
        }
        
        {
                double[] a = [1,1,1];
                double[] b;
                b.length = a.length;
                b[] = a[] + 3;
                assert(a == [1,1,1]);
                assert(b == [4,4,4]); // Now it's fine
        }
        
        {
                double[3] a = [1,1,1];
double[3] b = a[] + 3; // works although lvalue isn't a slice. Static arrays? Because it's an initial value?
                assert(a == [1,1,1]);
                assert(b == [4,4,4]);
        }
        
        {
                double[3] a = [1,1,1];
                auto b = a;
                b = a[] + 3; // And so does this.. Something to do with static 
arrays?
                assert(a == [1,1,1]);
                assert(b == [4,4,4]);
        }
        
        { // Like the previous example, but with dynamic arrays..
                double[] a = [1,1,1];
                auto b = a;
                assert(a is b);
                b = a[] + 3;
                assert(a == [1,1,1]);
                //writeln(b); // access violation. Because of dynamic arrays?
        }       

        { // Like above, but using slicing like the spec says.. Works fine
                double[] a = [1,1,1];
                auto b = a;
                assert(a is b);
                writeln(typeof(b).stringof); // double[]
                b[] = a[] + 3;
                assert(a == [4,4,4]); // a also changed. I expected this
                assert(b == [4,4,4]);
        }
        
        {
                double[3] a = [1,1,1];
                auto b = a[] + 3; // What happens here?
                writeln(typeof(b).stringof); // double[]
                assert(b.length == 3);
                assert(b.capacity == 0);
                //writeln(b); // access violation
        }
        
        { // Same as above?
                double[3] a = [1,1,1];
                //writeln(a[] + 3); // access violation
        }
        

Reply via email to