Changeset 2032

Timestamp:

09/18/10 21:00:52 (14 years ago)

Author:

dsimcha

Message:

Bug 4888: Heavy reliance on Bug 3534 in Phobos range usage. I used a different approach here than the first one I tried. I only did what was necessary to make Phobos work instead of trying to fix the deeper issue of making std.algorithm to work w/ const/immutable arrays.

Files:

• trunk/docsrc/changelog.dd (modified) (1 diff)
• trunk/phobos/std/algorithm.d (modified) (4 diffs)
• trunk/phobos/std/array.d (modified) (3 diffs)
• trunk/phobos/std/conv.d (modified) (2 diffs)
• trunk/phobos/std/json.d (modified) (2 diffs)
• trunk/phobos/std/numeric.d (modified) (1 diff)
• trunk/phobos/std/range.d (modified) (1 diff)
• trunk/phobos/std/string.d (modified) (1 diff)
• trunk/phobos/std/xml.d (modified) (1 diff)

trunk/docsrc/changelog.dd

@@ -1 +1 @@
-Ddoc
-
-$(D_S D Change Log,
-
-$(VERSION 050, Mmm dd 2010, =================================================,
-
-
-    $(WHATSNEW
-    $(LI std.traits:  Most higher-order ranges now work with const/immutable arrays and other ranges 
-    with a natural tail const, and ranges w/ const/immutable elements.)
+    $(LI Bug 4888:  Heavy reliance on Bug 3534 in Phobos range usage)
-    $(LI std.typecons:  Several improvements to the Tuple struct template:
-        $(UL $(LI  Tuple members are now accessible with the syntax a[0], a[1] etc.)
-             $(LI  Eliminated an internal union. See $(BUGZILLA 4421) and $(BUGZILLA 4846).)
-             $(LI  Worked around $(BUGZILLA 4424). Got opAssign back.)
-             $(LI  Made Tuple.slice!(from, to) to preserve field names if any.)
-             $(LI  Added isTuple!(T) template.)
-        ))
-    )
-    $(BUGSFIXED
-    $(LI Unlisted bug:  std.exception.pointsTo() calls postblit on subobjects.)

trunk/phobos/std/algorithm.d

@@ -104 +104 @@
-        {
-            return Map!(adjoin!(staticMap!(unaryFun, fun)), Range)(r);
-        }
-        else
-        {
-            return Map!(unaryFun!fun, Range)(r);
-        }
-    }
-}
-
-
-
+
+
+
-    alias fun _fun;
-ange
-Unqual!Range
+
+R
-    Unqual!ElementType _cache;
-
-ange
+
-    {
-    // Using a second cache would lead to at least 1 extra function evaluation
-    // and wasted space when 99% of the time this range will only be iterated
-    // over in the forward direction.  Use a bool to determine whether cache
-    // is front or back instead.
-        bool cacheIsBack_;
-
-        private void fillCacheBack()
-        {
-            if (!_input.empty) _cache = _fun(_input.back);
@@ -145 +146 @@
-        {
-            _input.popBack;
-            fillCacheBack();
-        }
-    }
-
-    private void fillCache()
-    {
-        if (!_input.empty) _cache = _fun(_input.front);
-
-ange
+
-        {
-            cacheIsBack_ = false;
-        }
-    }
-
-ange
+
-    {
-        _input = input;
-        fillCache;
-    }
-
-    static if (isInfinite!Range
-
-        
-        
-    
+static if (isInfinite!R
+
+
+
+
-    else
-    {
-                @property bool empty()
-        {
-                        return _input.empty;
-                }
-        }
-
-    void popFront()
-    {
-        _input.popFront;
-        fillCache();
-    }
-
-    @property ElementType front()
-    {
-ange
+
-        {
-            if (cacheIsBack_)
-            {
-                fillCache();
-            }
-        }
-        return _cache;
-    }
-
-ange
+
-    {
-        ElementType opIndex(size_t index)
-        {
-            return _fun(_input[index]);
-        }
-    }
-
-    // hasLength is busted, Bug 2873
-    static if (is(typeof(_input.length) : size_t)
-        || is(typeof(_input.length()) : size_t))
-    {
-        @property size_t length()
-        {
-            return _input.length;
-        }
-    }
-
-ange
+
-    {
-        typeof(this) opSlice(size_t lowerBound, size_t upperBound)
-        {
-            return typeof(this)(_input[lowerBound..upperBound]);
-        }
-    }
-
-    static if (isForwardRange!Range
-    
-    
-    
-    
-    
-    
+static if (isForwardRange!R
+
+
+
+
+
+
-}
-
-unittest
-{
-    debug(std_algorithm) scope(success)
-        writeln("unittest @", __FILE__, ":", __LINE__, " done.");
-    alias map!(to!string) stringize;
-    assert(equal(stringize([ 1, 2, 3, 4 ]), [ "1", "2", "3", "4" ]));
-    uint counter;
-    alias map!((a) { return counter++; }) count;
@@ -843 +844 @@
-version (all)
-{
-/* This is the older version. Too many problems with the newer one.
- */
-Filter!(unaryFun!(pred), Range)
-filter(alias pred, Range)(Range rs)
-{
-    return typeof(return)(rs);
-}
-
-
-
-
-
-
+
+
+
+
+
+
-    {
-        _input = r;
-        while (!_input.empty && !pred(_input.front)) _input.popFront;
-    }
-
-    ref Filter opSlice()
-    {
-        return this;
-    }
-
@@ -872 +874 @@
-        {
-            _input.popFront;
-        } while (!_input.empty && !pred(_input.front));
-    }
-
-    ElementType!(Range) front()
-    {
-        return _input.front;
-    }
-
-ange
+
-    {
-        @property typeof(this) save()
-        {
-            return typeof(this)(_input);
-        }
-    }
-}
-
-unittest
-{

trunk/phobos/std/array.d

@@ -246 +246 @@
-    assert(b is a);
-}
-----
- */
-
-@property T[] save(T)(T[] a)
-{
-    return a;
-}
-
+private template notConst(T) {
+    enum notConst = !is(T == const) && !is(T == immutable);
+}
+
-/**
-Implements the range interface primitive $(D popFront) for built-in
-arrays. Due to the fact that nonmember functions can be called with
-the first argument using the dot notation, $(D array.popFront) is
-equivalent to $(D popFront(array)).
-
-
-Example:
-----
-void main()
-{
-    int[] a = [ 1, 2, 3 ];
-    a.popFront;
-    assert(a == [ 2, 3 ]);
-}
-----
-*/
-
-
-
+
+
+
+
-    assert(a.length, "Attempting to popFront() past the end of an array of "
-            ~ T.stringof);
-    a = a[1 .. $];
-}
-
-unittest
-{
-    //@@@BUG 2608@@@
-    //auto a = [ 1, 2, 3 ];
-    int[] a = [ 1, 2, 3 ];
-    a.popFront;
-    assert(a == [ 2, 3 ]);
-
-
-
-
+
+
+
+
+
+
+
+
-    assert(a.length, "Attempting to popFront() past the end of an array of "
-            ~ T.stringof);
-    a = a[std.utf.stride(a, 0) .. $];
-}
-
-unittest
-{
-    string s1 = "\xC2\xA9hello";
-    s1.popFront();
-    assert(s1 == "hello");
-    wstring s2 = "\xC2\xA9hello";
-    s2.popFront();
-    assert(s2 == "hello");
-    string s3 = "\u20AC100";
-    //write(s3, '\n');
+
+    static assert(!__traits(compiles, popFront!(immutable string)));
-}
-
-/**
-Implements the range interface primitive $(D popBack) for built-in
-arrays. Due to the fact that nonmember functions can be called with
-the first argument using the dot notation, $(D array.popBack) is
-equivalent to $(D popBack(array)).
-
-
-Example:
-----
-void main()
-{
-    int[] a = [ 1, 2, 3 ];
-    a.popBack;
-    assert(a == [ 1, 2 ]);
-}
-----
-*/
-
-
+
+
-{
-    assert(a.length);
-    a = a[0 .. $ - 1];
-}
-
-unittest
-{
-    //@@@BUG 2608@@@
-    //auto a = [ 1, 2, 3 ];
-    int[] a = [ 1, 2, 3 ];
-    a.popBack;
-    assert(a == [ 1, 2 ]);
-
-
-
+
+
+
+
+
+
-{
-    immutable n = a.length;
-    const p = a.ptr + n;
-    if (n >= 1 && (p[-1] & 0b1100_0000) != 0b1000_0000)
-    {
-        a = a[0 .. n - 1];
-    }
-    else if (n >= 2 && (p[-2] & 0b1100_0000) != 0b1000_0000)
-    {
-        a = a[0 .. n - 2];
@@ -369 +385 @@
-{
-    string s = "hello\xE2\x89\xA0";
-    s.popBack();
-    assert(s == "hello", s);
-
-    string s3 = "\xE2\x89\xA0";
-    auto c = s3.back;
-    assert(c == cast(dchar)'\u2260');
-    s3.popBack();
-    assert(s3 == "");
-
-
-
+
+
+
+
+
+
-{
-    assert(a.length);
-    if (a.length == 1)
-    {
-        a = a[0 .. 0];
-        return;
-    }
-    immutable c = a[$ - 2];
-    a = a[0 .. $ - 1 - (c >= 0xD800 && c <= 0xDBFF)];
-}
-
-unittest
-{
-    wstring s = "hello\xE2\x89\xA0";
-    s.popBack();
-    assert(s == "hello");
+
+    static assert(!__traits(compiles, popBack!(immutable wchar[])));
-}
-
-/**
-Implements the range interface primitive $(D front) for built-in
-arrays. Due to the fact that nonmember functions can be called with
-the first argument using the dot notation, $(D array.front) is
-equivalent to $(D front(array)).
-
-
-Example:
@@ -830 +851 @@
-    private static size_t newCapacity(size_t newlength)
-    {
-        long mult = 100 + (1000L) / (bsr(newlength * T.sizeof) + 1);
-        // limit to doubling the length, we don't want to grow too much
-        if(mult > 200)
-            mult = 200;
-        auto newext = cast(size_t)((newlength * mult + 99) / 100);
-        return newext > newlength ? newext : newlength;
-    }
-
+    // Const fixing hack.
+    void put(Range)(Range items)
+    if(isInputRange!(Unqual!Range) && !isInputRange!Range) {
+        alias put!(Unqual!Range) p;
+        p(items);
+    }
+
-/**
-Appends an entire range to the managed array.
- */
-    void put(Range)(Range items) if (isInputRange!Range
-            && is(typeof(Appender.init.put(items.front))))
-    {
-        // note, we disable this branch for appending one type of char to
-        // another because we can't trust the length portion.
-        static if (!(isSomeChar!T && isSomeChar!(ElementType!Range) &&
-                     !is(Range == Unqual!(T)[])) &&

trunk/phobos/std/conv.d

@@ -101 +101 @@
-combination of qualifiers (mutable, $(D const), or $(D immutable)).
-
-Example:
-----
-char[] a = "abc";
-auto b = to!dstring(a);
-assert(b == "abc"w);
-----
- */
-T toImpl(T, S)(S s) if (!implicitlyConverts!(S, T) && isSomeString!T
-S
+(Unqual!S)
-{
-    static if (isSomeString!S)
-    {
-        // string-to-string conversion
-        static if (s[0].sizeof == T[0].sizeof) {
-            // same width, only qualifier conversion
-            enum tIsConst = is(T == const(char)[]) || is(T == const(wchar)[])
-                || is(T == const(dchar)[]);
-            enum tIsInvariant = is(T == immutable(char)[])
-                || is(T == immutable(wchar)[]) || is(T == immutable(dchar)[]);
@@ -175 +175 @@
-    }
-}
-
-/**
-Converts array (other than strings) to string. The left bracket,
-separator, and right bracket are configurable. Each element is
-converted by calling $(D to!T).
- */
-T toImpl(T, S)(S s, in T leftBracket = "[", in T separator = " ",
-    in T rightBracket = "]")
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
-/*
-  Converting static arrays forwards to their dynamic counterparts.
- */
-T toImpl(T, S)(ref S s)
-if (isStaticArray!S)
-{
-    return toImpl!(T, typeof(s[0])[])(s);
-}

trunk/phobos/std/json.d

@@ -50 +50 @@
-                real                            floating;
-                JSONValue[string]       object;
-                JSONValue[]                     array;
-        }
-        JSON_TYPE                               type;
-}
-
-/**
- Parses a serialized string and returns a tree of JSON values.
-*/
-in 
+
-        JSONValue root = void;
-        root.type = JSON_TYPE.NULL;
-
-        if(json.empty()) return root;
-
-        int depth = -1;
-        dchar next = 0;
-        int line = 1, pos = 1;
-
-        void error(string msg) {
@@ -420 +420 @@
-        }
-}
-
-version(unittest) import std.stdio;
-
-unittest {
-        // An overly simple test suite, if it can parse a serializated string and
-        // then use the resulting values tree to generate an identical
-        // serialization, both the decoder and encoder works.
-
-immutable
+auto
-                `null`,
-                `true`,
-                `false`,
-                `0`,
-                `123`,
-                `-4321`,
-                `0.23`,
-                `-0.23`,
-                `""`,
-                `1.223e+24`,

trunk/phobos/std/numeric.d

@@ -2460 +2460 @@
-
-/// ditto
-void inverseFft(Ret, R)(R range, Ret buf) {
-    mixin(MakeLocalFft);
-    return fftObj.inverseFft!(Ret, R)(range, buf);
-}
-
-
-unittest {
-    // Test values from R.
-const
-const
+auto
+auto
-    assert(approxEqual(map!"a.re"(fft1),
-        [36.0, -4, -4, -4, -4, -4, -4, -4]));
-    assert(approxEqual(map!"a.im"(fft1),
-        [0, 9.6568, 4, 1.6568, 0, -1.6568, -4, -9.6568]));
-
-    alias Complex!float C;
-const
+auto
-        C(11,12), C(13,14), C(15,16)];
-const
+auto
-    assert(approxEqual(map!"a.re"(fft2),
-        [64.0, -27.3137, -16, -11.3137, -8, -4.6862, 0, 11.3137]));
-    assert(approxEqual(map!"a.im"(fft2),
-        [72, 11.3137, 0, -4.686, -8, -11.3137, -16, -27.3137]));
-
-const
+auto
-    assert(approxEqual(map!"a.re"(inv1), arr));
-    assert(reduce!max(map!"a.im"(inv1)) < 1e-10);
-
-const
+auto
-    assert(approxEqual(map!"a.re"(inv2), map!"a.re"(arr2)));
-    assert(approxEqual(map!"a.im"(inv2), map!"a.im"(arr2)));
-
-    // FFTs of size 0, 1 and 2 are handled as special cases.  Test them here.
-const 
+
-    assert(fft(empty) == null);
-    assert(inverseFft(fft(empty)) == null);
-
-const 
-const
+
+auto
-    assert(oneFft.length == 1);
-    assert(oneFft[0].re == 4.5L);
-    assert(oneFft[0].im == 0);
-
-const
+auto
-    assert(oneInv.length == 1);
-    assert(approxEqual(oneInv[0].re, 4.5));
-    assert(approxEqual(oneInv[0].im, 0));
-
-immutable 
-const
+
+auto
-    assert(twoFft.length == 2);
-    assert(approxEqual(twoFft[0].re, 12));
-    assert(approxEqual(twoFft[0].im, 0));
-    assert(approxEqual(twoFft[1].re, 4));
-    assert(approxEqual(twoFft[1].im, 0));
-const
+auto
-    assert(approxEqual(twoInv[0].re, 8));
-    assert(approxEqual(twoInv[0].im, 0));
-    assert(approxEqual(twoInv[1].re, 4));
-    assert(approxEqual(twoInv[1].im, 0));
-}
-
-// Swaps the real and imaginary parts of a complex number.  This is useful
-// for inverse FFTs.
-C swapRealImag(C)(C input) {
-    return C(input.im, input.re);

trunk/phobos/std/range.d

@@ -3295 +3295 @@
-    /// Ditto
-    Lockstep!(Ranges) lockstep(Ranges...)(Ranges ranges, StoppingPolicy s)
-    {
-        assert(0);
-    }
-}
-else
-{
-    // Work around DMD bugs 4676, 4652.
-    auto lockstep(Args...)(Args args)
-Args
-Args[0..$ - 1]
+staticMap!(Unqual, Args)
+staticMap!(Unqual, Args[0..$ - 1])
-       is(Args[$ - 1] == StoppingPolicy))
-    )
-    {
-        static if(is(Args[$ - 1] == StoppingPolicy))
-        {
-            alias args[0..$ - 1] ranges;
-            alias Args[0..$ - 1] Ranges;
-            alias args[$ - 1] stoppingPolicy;
-        }
-        else

trunk/phobos/std/string.d

@@ -534 +534 @@
-
-$(D CaseSensitive cs) controls whether the comparisons are case
-sensitive or not.
-
-Returns:
-
-Index in $(D s) where $(D sub) is found, $(D -1) if not found.
- */
-
-sizediff_t
-in Char1[] s, in Char2
+const(Char1)[] s, const(Char2)
-        CaseSensitive cs = CaseSensitive.yes)
-{
-    if (cs == CaseSensitive.yes)
-    {
-        static if (Char1.sizeof == Char2.sizeof)
-        {
-            immutable result = s.length - std.algorithm.find(s, sub).length;
-            return result == s.length ? -1 : result;
-        }
-        else

trunk/phobos/std/xml.d

@@ -118 +118 @@
-Distributed under the Boost Software License, Version 1.0.
-   (See accompanying file LICENSE_1_0.txt or copy at
-         http://www.boost.org/LICENSE_1_0.txt)
-*/
-module std.xml;
-
-import std.array;
-import std.string;
-import std.encoding;
-
-immutable
+enum
-
-/**
- * Returns true if the character is a character according to the XML standard
- *
- * Standards: $(LINK2 http://www.w3.org/TR/1998/REC-xml-19980210, XML 1.0)
- *
- * Params:
- *    c = the character to be tested
- */
-bool isChar(dchar c) // rule 2