Changeset 1714

Timestamp:

07/04/10 21:04:48 (14 years ago)

Author:

andrei

Message:

Unlisted bug in Map.save and a few stylistic changes

Files:

• trunk/phobos/std/algorithm.d (modified) (11 diffs)

trunk/phobos/std/algorithm.d

@@ -46 +46 @@
-module std.algorithm;
-
-import std.c.string;
-import std.array, std.container, std.contracts, std.conv, std.date,
-    std.functional, std.math, std.metastrings, std.range, std.string,
-    std.traits, std.typecons, std.typetuple;
-
-version(unittest)
-{
-    import std.random, std.stdio, std.string;
-
-    mixin(dummyRanges);
-}
-
-/**
-Implements the homonym function (also known as $(D transform)) present
-in many languages of functional flavor. The call $(D map!(fun)(range))
-returns a range of which elements are obtained by applying $(D fun(x))
-left to right for all $(D x) in $(D range). The original ranges are
-not changed. Evaluation is done lazily. The range returned by $(D map)
-caches the last value such that evaluating $(D front) multiple times
@@ -111 +110 @@
-        }
-    }
-}
-
-struct Map(alias fun, Range) if (isInputRange!(Range))
-{
-    alias typeof(fun(.ElementType!(Range).init)) ElementType;
-    Range _input;
-    ElementType _cache;
-
-
+ 
-    // 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.
-
+_
-
-        private void fillCacheBack() {
-            if (!_input.empty) _cache = fun(_input.back);
-
+_
-        }
-
-        @property ElementType back() {
-(!cacheIsBack
+ (!cacheIsBack_
-                fillCacheBack();
-            }
-            return _cache;
-        }
-
-        void popBack() {
-            _input.popBack;
-            fillCacheBack();
-        }
-    }
-
-    private void fillCache() {
-        if (!_input.empty) _cache = fun(_input.front);
-
-        static if(isBidirectionalRange!(Range)) {
-
+_
-        }
-    }
-
-    this(Range input) {
-        _input = input;
-        fillCache;
-    }
-
-
+ 
-        // Propagate infinite-ness.
-        enum bool empty = false;
-    } else {
-        @property bool empty() {
-            return _input.empty;
-        }
-    }
-
-    void popFront() {
-        _input.popFront;
-
+()
-    }
-
-    @property ElementType front() {
-
-(cacheIsBack
+ 
+ (cacheIsBack_
-                fillCache();
-            }
-        }
-        return _cache;
-    }
-
-
+ 
-        ElementType opIndex(size_t index) {
-            return fun(_input[index]);
-        }
-    }
-
-    // hasLength is busted, Bug 2873
-
+ 
-        || is(typeof(_input.length()) : size_t)) {
-        @property size_t length() {
-            return _input.length;
-        }
-    }
-
-
+ 
-        typeof(this) opSlice(size_t lowerBound, size_t upperBound) {
-            return typeof(this)(_input[lowerBound..upperBound]);
-        }
-    }
-
-    static if (isForwardRange!Range)
-        @property Map save()
-        {
-
-
-
-
+
-        }
-}
-
-unittest
-{
-    scope(failure) writeln("Unittest failed at line ", __LINE__);
-    int[] arr1 = [ 1, 2, 3, 4 ];
-    int[] arr2 = [ 5, 6 ];
-    auto squares = map!("a * a")(arr1);
-    assert(equal(squares, [ 1, 4, 9, 16 ][]));
-    assert(equal(map!("a * a")(chain(arr1, arr2)), [ 1, 4, 9, 16, 25, 36 ][]));
-
-    // Test the caching stuff.
-
+
+
-    assert(squares2.back == 16);
+
-    assert(squares2.front == 1);
-    squares2.popFront;
-    assert(squares2.front == 4);
-    squares2.popBack;
-    assert(squares2.front == 4);
-    assert(squares2.back == 9);
-
-    assert(equal(map!("a * a")(chain(arr1, arr2)), [ 1, 4, 9, 16, 25, 36 ][]));
-
-    uint i;
@@ -571 +569 @@
-            while (!_input.empty && !pred(_input.back)) _input.popBack;
-        }
-
-    }
-
-    ref Filter opSlice()
-    {
-        return this;
-    }
-
-
+ 
-        enum bool empty = false;  // Propagate infiniteness.
-    } else {
-        bool empty() { return _input.empty; }
-    }
-
-    void popFront()
-    {
-        do
-        {
-            _input.popFront;
@@ -603 +601 @@
-            do
-            {
-                _input.popBack;
-            } while (!_input.empty && !pred(_input.back));
-        }
-
-        ElementType!(Range) back() { return _input.back;}
-    }
-
-
-
+ 
-    {
-        @property typeof(this) save()
-        {
-            return typeof(this)(_input.save);
-        }
-    }
-}
-
-unittest
-{
@@ -638 +636 @@
-    auto nums = [0,1,2,3,4];
-    auto forward = filter!"a % 2 == 0"(nums);
-    assert(equal(retro(forward), [4,2,0][])); // f is a bidirectional range
-
-
-    foreach(DummyType; AllDummyRanges) {
-        DummyType d;
-        auto f = filter!"a & 1"(d);
-        assert(equal(f, [1,3,5,7,9]));
-
-
+ 
-            static assert(isForwardRange!(typeof(f)));
-        }
-
-
+ 
-            static assert(isBidirectionalRange!(typeof(f)));
-            assert(equal(retro(f), [9,7,5,3,1]));
-        }
-    }
-}
-
-// move
-/**
-Moves $(D source) into $(D target) via a destructive
-copy. Specifically: $(UL $(LI If $(D hasAliasing!T) is true (see
@@ -869 +867 @@
-
-public:
-    this(Range input, Separator separator)
-    {
-        _input = input;
-        _separator = separator;
-        // computeFront();
-        // computeBack();
-    }
-
-
+ 
-    {
-        enum bool empty = false;
-    } else
-    {
-        @property bool empty()
-        {
-            return _frontLength == _atEnd;
-        }
-    }
-
@@ -1004 +1002 @@
-        _separator = separator;
-    }
-
-    @property Range front()
-    {
-        assert(!empty);
-        ensureFrontLength;
-        return _input[0 .. _frontLength];
-    }
-
-
+ 
-    {
-        enum bool empty = false;  // Propagate infiniteness
-    }
-    else
-    {
-        @property bool empty()
-        {
-            return _frontLength == size_t.max && _input.empty;
-        }
-    }
@@ -1151 +1149 @@
-        else
-        {
-            // Chase first terminator
-            while (_end < _input.length && !_isTerminator(_input[_end]))
-            {
-                ++_end;
-            }
-        }
-    }
-
-
+ 
-    {
-        enum bool empty = false;  // Propagate infiniteness.
-    }
-    else
-    {
-        @property bool empty()
-        {
-            return _end == _end.max;
-        }
-    }
@@ -1274 +1272 @@
-        auto last = _input.front;
-        do
-        {
-            _input.popFront;
-        }
-        while (!_input.empty && binaryFun!(pred)(last, _input.front));
-    }
-
-    @property ElementType!(R) front() { return _input.front; }
-
-
+ 
-    {
-        void popBack()
-        {
-            auto last = _input.back;
-            do
-            {
-                _input.popBack;
-            }
-            while (!_input.empty && binaryFun!(pred)(last, _input.back));
-        }
-
-        @property ElementType!(R) back() { return _input.back; }
-    }
-
-
+ 
-    {
-        enum bool empty = false;  // Propagate infiniteness.
-    }
-    else
-    {
-        @property bool empty() { return _input.empty; }
-    }
-
-
-
+ 
-        @property typeof(this) save() {
-            return typeof(this)(_input.save);
-        }
-    }
-}
-
-/// Ditto
-Uniq!(pred, Range) uniq(alias pred = "a == b", Range)(Range r)
-{
-    return typeof(return)(r);
@@ -1326 +1324 @@
-    assert(equal(r, [ 1, 2, 3, 4, 5 ][]));
-    assert(equal(retro(r), retro([ 1, 2, 3, 4, 5 ][])));
-
-    foreach(DummyType; AllDummyRanges) {
-        DummyType d;
-        auto u = uniq(d);
-        assert(equal(u, [1,2,3,4,5,6,7,8,9,10]));
-
-        static assert(d.rt == RangeType.Input || isForwardRange!(typeof(u)));
-
-
+ 
-            assert(equal(retro(u), [10,9,8,7,6,5,4,3,2,1]));
-        }
-    }
-}
-
-// group
-/**
-Similarly to $(D uniq), $(D group) iterates unique consecutive
-elements of the given range. The element type is $(D
-Tuple!(ElementType!R, uint)) because it includes the count of
@@ -1380 +1378 @@
-            _current = tuple(_input.front, 1u);
-            _input.popFront;
-            while (!_input.empty && comp(_current.field[0], _input.front))
-            {
-                ++_current.field[1];
-                _input.popFront;
-            }
-        }
-    }
-
-
+ 
-    {
-        enum bool empty = false;  // Propagate infiniteness.
-    }
-    else
-    {
-        @property bool empty()
-        {
-            return _current.field[1] == 0;
-        }
-    }
-
-    @property ref Tuple!(ElementType!R, uint) front()
-    {
-        assert(!empty);
-        return _current;
-    }
-
-
+ 
-        @property typeof(this) save() {
-            typeof(this) ret;
-            ret._input = this._input.save;
-            ret._current = this._current;
-
-            return ret;
-        }
-    }
-}
-