Changeset 1897

Timestamp:

08/19/10 00:48:56 (14 years ago)

Author:

dsimcha

Message:

Added isIterable, ForeachType? to std.traits in preparation for improvements to std.array.array.

Files:

• trunk/docsrc/changelog.dd (modified) (1 diff)
• trunk/phobos/std/traits.d (modified) (2 diffs)

trunk/docsrc/changelog.dd

@@ -4 +4 @@
-
-$(VERSION 049, Aug 11, 2010, =================================================,
-
-
-    $(WHATSNEW
-    $(LI Added FFT to std.numeric.)
-    $(LI Added convenience functions for Rebindable.)
-    $(LI std.process: Added environment, an AA-like interface for environment variables.)
-    $(LI std.range:  Iota, Stride, Transversal, FrontTransveral now support slicing where possible.)
-    $(LI std.range:  Added Lockstep, hasLvalueElements.)
+    $(L1 std.traits:  Added isIterable, ForeachType.)
-    $(LI std.typetuple:  Added anySatisfy.) 
-    )
-    $(BUGSFIXED
-    $(LI Unlisted Bug:  std.math.pow doesn't work on immutable numbers.)
-    $(LI Unlisted Bug:  std.math.pow floating point overload expects both arguments to be exact same type.)
-    $(LI Unlisted Bug:  std.path.join("", "foo") returns "/foo" instead of "foo" on Posix.)
-    $(LI Unlisted Bug:  std.range.iota() random access primitives inconsistent after popFront on floating point version)
-    $(LI Several unlisted bugs in std.range.chain)
-    $(LI $(BUGZILLA 2903): Splitter should be bi-dir if the input range is bi-dir.)
-    $(LI $(BUGZILLA 2951): std.random.dice() should be templated on proportions.)

trunk/phobos/std/traits.d

@@ -2310 +2310 @@
-unittest
-{
-    static assert(isPointer!(int*));
-    static assert(!isPointer!(uint));
-    static assert(!isPointer!(uint[uint]));
-    static assert(!isPointer!(char[]));
-    static assert(isPointer!(void*));
-}
-
-/**
+ * Returns $(D true) if T can be iterated over using a $(D foreach) loop with
+ * a single loop variable of automatically inferred type, regardless of how
+ * the $(D foreach) loop is implemented.  This includes ranges, structs/classes
+ * that define $(D opApply) with a single loop variable, and builtin dynamic,
+ * static and associative arrays.
+ */
+template isIterable(T)
+{
+    static if (is(typeof({foreach(elem; T.init) {}}))) {
+        enum bool isIterable = true;
+    } else {
+        enum bool isIterable = false;
+    }
+}
+
+unittest {
+    struct OpApply
+    {
+        int opApply(int delegate(ref uint) dg) { assert(0); }
+    }
+
+    struct Range
+    {
+        uint front() { assert(0); }
+        void popFront() { assert(0); }
+        enum bool empty = false;
+    }
+
+    static assert(isIterable!(uint[]));
+    static assert(!isIterable!(uint));
+    static assert(isIterable!(OpApply));
+    static assert(isIterable!(uint[string]));
+    static assert(isIterable!(Range));
+}
+
+/**
- * Tells whether the tuple T is an expression tuple.
- */
-template isExpressionTuple(T ...)
-{
-    static if (T.length > 0)
-        enum bool isExpressionTuple =
-            !is(T[0]) && __traits(compiles, { auto ex = T[0]; }) &&
-            isExpressionTuple!(T[1 .. $]);
-    else
-        enum bool isExpressionTuple = true; // default
@@ -2585 +2621 @@
-}
-
-unittest
-{
-    static assert(is(ModifyTypePreservingSTC!(Intify, const real) == const int));
-    static assert(is(ModifyTypePreservingSTC!(Intify, immutable real) == immutable int));
-    static assert(is(ModifyTypePreservingSTC!(Intify, shared real) == shared int));
-    static assert(is(ModifyTypePreservingSTC!(Intify, shared(const real)) == shared(const int)));
-}
-version (unittest) private template Intify(T) { alias int Intify; }
+
+/**
+Returns the inferred type of the loop variable when a variable of type T
+is iterated over using a $(D foreach) loop with a single loop variable and
+automatically inferred return type.  Note that this may not be the same as
+$(D std.range.ElementType!(Range)) in the case of narrow strings, or if T
+has both opApply and a range interface.
+*/
+template ForeachType(T)
+{
+    alias ReturnType!(typeof(
+    {
+        foreach(elem; T.init) {
+            return elem;
+        }
+        assert(0);
+    })) ForeachType;
+}
+
+unittest
+{
+    static assert(is(ForeachType!(uint[]) == uint));
+    static assert(is(ForeachType!(string) == immutable(char)));
+    static assert(is(ForeachType!(string[string]) == string));
+}
-
-
-/**
-Strips off all $(D typedef)s (including $(D enum) ones) from type $(D T).
-
-Example:
---------------------
-enum E : int { a }
-typedef E F;
-typedef const F G;