Changeset 1749

Timestamp:

07/12/10 00:50:32 (14 years ago)

Author:

andrei

Message:

Changed definition of isOutputRange and introduced universal function put(R, E) that puts an element in an output range.

Files:

• trunk/phobos/std/range.d (modified) (2 diffs)

trunk/phobos/std/range.d

@@ -1 +1 @@
-// Written in the D programming language.
-
-/**
-ideas
-
-
+some
+
+fantascienza.net/leonardo/so/, 
-
-Macros:
-
-WIKI = Phobos/StdRange
-
-Copyright: Copyright Andrei Alexandrescu 2008-.
-License:   $(WEB boost.org/LICENSE_1_0.txt, Boost License 1.0).
-Authors:   $(WEB erdani.org, Andrei Alexandrescu)
-*/
-module std.range;
@@ -219 +219 @@
-        bool empty();
-        int front();
-    }
-    static assert(isInputRange!(B));
-    static assert(isInputRange!(int[]));
-    static assert(isInputRange!(char[]));
-}
-
-/**
-Returns $(D true) if $(D R) is an output range. An output range can be
-
-
-
-
-
+
+
+
+
+
+
+
-
-----
-R r;
-E e;
-r.put(e);        // can write an element to the range
-----
-
-The semantics of $(D r.put(e)) an output range (not checkable during
-compilation) are assumed to output $(D e) to $(D r) and advance to the
-next position in $(D r), such that successive calls to $(D r.put) add
-extra elements to $(D r).)
-
-$(LI An input range with assignable elements is also an output
-range. In that case, inserting elements into the range is effected
-with two primitive calls: $(D r.front = e, r.popFront()). Such a range
-
+
+
+
+
+
+
+
+
+
+
-
-To write elements to either kind of output range, call the free
-function $(D put(r, e)) defined below. That function takes the
-appropriate cource of action depending on the range's kind.
- */
-template isOutputRange(R, E)
-{
-    enum bool isOutputRange = is(typeof(
-    {
-            // can define a range object
+
-        E e;
-
-
-
-
+
+
+
+
+
+
-        E e;
-        r.front = e;       // can assign to the front of range
+    }()))
+        ||
+        is(typeof(
+    {
+        R r;
+        E[] es;
+        r(es);
-    }()));
-}
-
-/**
-Outputs $(D e) to $(D r), which must be an output range. Depending on
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
- */
-void put(R, E)(ref R r, E e) if (isOutputRange!(R, E))
-{
-is(typeof(&r.put
+!isArray!R && is(typeof(r.put(e)
-    {
-        r.put(e);
-    }
-
+ static if (isInputRange!R && is(typeof(r.front = e)))
-    {
-        r.front = e;
-        r.popFront();
+    }
+    else static if (isArray!E && is(typeof(r(e))))
+    {
+        r(e);
+    }
+    else static if (is(typeof(r(new E[]))))
+    {
+        r((&e)[0 .. 1]);
+    }
+    else
+    {
+        static assert(false);
-    }
-}
-
-unittest
-{
-    struct A {}
-    static assert(!isInputRange!(A));
-    struct B
-    {
-        void put(int);
-    }
-    static assert(isOutputRange!(B, int));
-    static assert(isOutputRange!(int[], int));
+}
+
+unittest
+{
+    void myprint(in char[] s) { writeln('[', s, ']'); }
+    static assert(isOutputRange!(typeof(&myprint), char));
-}
-
-/**
-Returns $(D true) if $(D R) is a forward range. A forward range is an
-input range that can save "checkpoints" by simply copying it to
-another value of the same type. Notable examples of input ranges that
-are $(I not) forward ranges are file/socket ranges; copying such a
-range will not save the position in the stream, and they most likely
-reuse an internal buffer as the entire stream does not sit in
-memory. Subsequently, advancing either the original or the copy will