Changeset 1540

Timestamp:

05/23/10 00:35:48 (15 years ago)

Author:

rsinfu

Message:

Added BlackHole? and WhiteHole?.

Files:

• trunk/phobos/std/traits.d (modified) (5 diffs)
• trunk/phobos/std/typecons.d (modified) (5 diffs)

trunk/phobos/std/traits.d

@@ -11 +11 @@
- * License:   <a href="http://www.boost.org/LICENSE_1_0.txt">Boost License 1.0</a>.
- * Authors:   $(WEB digitalmars.com, Walter Bright),
- *            Tomasz Stachowiak ($(D isExpressionTuple)),
- *            $(WEB erdani.org, Andrei Alexandrescu),
- *            Shin Fujishiro
- *
- *          Copyright Digital Mars 2005 - 2009.
- * 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)
- *
- * Macros:
- *   EM = <em>$0</em>
- */
-module std.traits;
-import std.typetuple;
-
-
-//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
-// Functions
-//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
-
-// Petit demangler
@@ -493 +490 @@
-$(D FunctionTypeOf) is able to obtain function types of properties.
---------------------
-class C {
-    int value() @property;
-}
-static assert(is( typeof(C.value) == int ));
-static assert(is( FunctionTypeOf!(C.value) == function ));
---------------------
-
-Note:
-$(EM pointer) types; function types
-are 
+pointer types; function types are
+
- */
-template FunctionTypeOf(func...)
-    if (func.length == 1 && isCallable!(func))
-{
-    static if (is(typeof(& func[0]) Fsym : Fsym*) && is(Fsym == function))
-    {
-        alias Fsym FunctionTypeOf; // HIT: function symbol
-    }
-    else static if (is(typeof(& func[0].opCall) Fobj == delegate))
-    {
@@ -2053 +2050 @@
-    static assert(isSomeFunction!(real function(ref int)));
-    static assert(isSomeFunction!(real delegate(ref int)));
-
-    static assert(! isSomeFunction!(int));
-    static assert(! isSomeFunction!(val));
-    static assert(! isSomeFunction!(isSomeFunction));
-}
-
-
-/**
-$(EM called)
+called
-function call operator $(D $(LPAREN)...$(RPAREN)).
- */
-template isCallable(T...)
-    if (T.length == 1)
-{
-    static if (is(typeof(& T[0].opCall) == delegate))
-        // T is a object which has a member function opCall().
-        enum bool isCallable = true;
-    else static if (is(typeof(& T[0].opCall) V : V*) && is(V == function))
-        // T is a type which has a static member function opCall().
@@ -2294 +2291 @@
-
-
-//:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
-// Misc.
-//:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
-
-/**
-Returns the mangled name of symbol or type $(D sth).
-
-$(D mangledName) is the same as builtin $(D .mangleof) property, except that
-$(EM correct)
+correct
---------------------
-module test;
-import std.traits : mangledName;
-
-class C {
-    int value() @property;
-}
-pragma(msg, C.value.mangleof);      // prints "i"
-pragma(msg, mangledName!(C.value)); // prints "_D4test1C5valueMFNdZi"
---------------------
@@ -2364 +2361 @@
-            m_upb *= 10;
-        }
-    }
-
-    return s;
-}
-
-unittest
-{
-    typedef int MyInt;
+    MyInt test() { return 0; }
-    class C { int value() @property { return 0; } }
-    static assert(mangledName!(int) == int.mangleof);
-    static assert(mangledName!(C) == C.mangleof);
-    static assert(mangledName!(MyInt)[$ - 7 .. $] == "T5MyInt");
+    //static assert(mangledName!(test)[$ - 7 .. $] == "T5MyInt");
+        // seems bug in dmd: the preceding T is omitted
-    static assert(mangledName!(C.value)[$ - 12 .. $] == "5valueMFNdZi");
-    static assert(mangledName!(mangledName) == "3std6traits11mangledName");
-    static assert(mangledName!(removeDummyEnvelope) ==
-            "_D3std6traits19removeDummyEnvelopeFAyaZAya");
-}
-
-
-/*
-workaround for [BUG 2234] "allMembers does not return interface members"
- */

trunk/phobos/std/typecons.d

@@ -1 +1 @@
-// Written in the D programming language.
-
-/**
-This module implements a variety of type constructors, i.e., templates
-that allow construction of new, useful general-purpose types.
-
-Macros:
-
-WIKI = Phobos/StdVariant
-EM   = <em>$0</em>
- 
-Synopsis:
-
-----
-// value tuples
-alias Tuple!(float, "x", float, "y", float, "z") Coord;
-Coord c;
-c.field[1] = 1;   // access by index
-c.z = 1;          // access by given name
-alias Tuple!(string, string) DicEntry; // names can be omitted
@@ -1379 +1378 @@
-    assert(a == 5);
-    a = 42;
-    assert(!a.isNull);
-    assert(a == 42);
-}
-
-+/
-
-
-/**
-
-
-
+
+
+
+
+
+
---------------------
-Base
+C
-{
-    int m_value;
-    this(int v) { m_value = v; }
-    int value() @property { return m_value; }
-
-    abstract real realValue() @property;
-    abstract void doSomething();
-}
-
-void main()
-{
-obj = new AutoImplement!Base
-obj
+c = new BlackHole!C
+c
-
-    // Abstract functions are implemented as do-nothing:
-obj
-obj
+c
+c
-}
---------------------
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-Params:
-
-
+
-
-         Two arguments are passed to $(D how): the first one is the $(D Base),
-         and the second one is an alias to a function to be implemented.  Then
-         $(D how) must return a implemented function body as a string.
-
-         The generated function body can use these keywords:
-         $(UL
-            $(LI $(D a0), $(D a1), &hellip;: arguments passed to the function;)
-            $(LI $(D args): a tuple of the arguments;)
-            $(LI $(D self): an alias to the function itself;)
@@ -1448 +1538 @@
-            stmt ~= q{
-                auto r = parent(args);
-                Importer.writeln("--> ", r);
-                return r;
-            };
-    }
-    return stmt;
-}
---------------------
-
-A 
+
-         implemented/overridden.
-
-         An argument is passed to $(D what): an alias to a non-final member
-         function in $(D Base).  Then $(D what) must return a boolean value.
-         Return $(D true) to indicate that the passed function should be
-         implemented/overridden.
-
---------------------
-// Sees if fun returns something.
-template hasValue(alias fun)
@@ -1483 +1573 @@
-
-BUGS:
-
-$(UL
- $(LI Variadic arguments to constructors are not forwarded to super.)
- $(LI Deep interface inheritance causes compile error with messages like
-      "Error: function std.typecons._AutoImplement!(Foo)._AutoImplement.bar
-      does not override any function".  [$(BUGZILLA 2525), $(BUGZILLA 3525)] )
- $(LI The $(D parent) keyword is actually a delegate to the super class'
-      corresponding member function.  [$(BUGZILLA 2540)] )
-$(D alias) template parameter in $(D how) and/or $(D what) may
- cause strange compile error.  Use template tuple parameter instead to
- workaround 
+alias template parameter in $(D how) and/or $(D what) may cause
+strange compile error.  Use template tuple parameter instead to workaround
+
-)
- */
-
-
-
+
-{
-    private alias AutoImplement_Helper!(
-            "autoImplement_helper_", "Base", Base, how, what )
-             autoImplement_helper_;
-    override mixin(autoImplement_helper_.code);
-}
-
-/*
- * Code-generating stuffs are encupsulated in this helper template so that
- * namespace pollusion, which can cause name confliction with Base's public
@@ -1718 +1806 @@
-        pragma(msg, "--------------------");
-    }
-}
-
-//debug = SHOW_GENERATED_CODE;
-unittest
-{
-    // no function to implement
-    {
-        interface I_1 {}
-
-
-
-
-
-
-
+
-    }
-    // parameters
-    {
-        interface I_3 { void test(int, in int, out int, ref int, lazy int); }
-AutoImplement
+BlackHole
-    }
-    // use of user-defined type
-    {
-typedef int MyInt;
-MyInt
-AutoImplement
+struct S {}
+S
+BlackHole
-    }
-    // overloads
-    {
-        interface I_5
-        {
-            void test(string);
-            real test(real);
-            int  test();
-            int  test() @property; // ?
-        }
-AutoImplement
+BlackHole
-    }
-    // constructor forwarding
-    {
-        static class C_6
-        {
-            this(int n) { assert(n == 42); }
-            this(string s) { assert(s == "Deeee"); }
-            this(...) {}
-        }
-AutoImplement
-AutoImplement
-AutoImplement
+BlackHole
+BlackHole
+BlackHole
-    }
-    /+ // deep inheritance
-    {
-    // XXX [BUG 2525,3525]
-    // NOTE: [r494] func.c(504-571) FuncDeclaration::semantic()
-        interface I { void foo(); }
-        interface J : I {}
-        interface K : J {}
-        static abstract class C_8 : K {}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
- */
-template generateEmptyFunction(C, func.../+[BUG 4217]+/)
-{
-    static if (is(ReturnType!(func) == void))
-        enum string generateEmptyFunction = q{
-        };
-    else static if (functionAttributes!(func) & FunctionAttribute.REF)
-        enum string generateEmptyFunction = q{
-            static typeof(return) dummy;
-            return dummy;
-        };
-    else
-        enum string generateEmptyFunction = q{
-            return typeof(return).init;
-        };
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-template generateAssertTrap(C, func.../+[BUG 4217]+/)
-{
-    enum string generateAssertTrap =
-        `assert(0, "` ~ (C.stringof ~ "." ~ __traits(identifier, func))
-                ~ ` is not implemented");`;
-}
-
-unittest // doc example
-{
-    static class C
-    {
-        abstract void notYetImplemented();
-    }
-
-    auto o = new AutoImplement!(C, generateAssertTrap);
-    try
-    {
-        o.notYetImplemented();
-        assert(0);
-    }
-    catch (Error e) {}
-}
-
-
-/*
-Used by MemberFunctionGenerator.
- */
-private template OverloadSet(string nam, T...)
-{
-    enum string name = nam;
-    alias T contents;
-}
-
-/*
-Used by MemberFunctionGenerator.
- */
-private template FuncInfo(alias func, /+[BUG 4217 ?]+/ T = typeof(&func))
-{
-    alias         ReturnType!(T) RT;
-    alias ParameterTypeTuple!(T) PT;
-}
-
-/*
-General-purpose member function generator.
- */
-private template MemberFunctionGenerator(alias Policy)
-{
-private static:
-    //mixin Policy; // can't
-
-    //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
-    // Internal stuffs
-    //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
-
-    enum CONSTRUCTOR_NAME = "__ctor";
-    enum WITH_BASE_CLASS  = __traits(compiles, Policy.BASE_CLASS_ID);
-
-    // Returns a tuple consisting of 0,1,2,...,n-1.  For static foreach.
-    template CountUp(size_t n)
-    {
-        static if (n > 0)
-            alias TypeTuple!(CountUp!(n - 1), n - 1) CountUp;
-        else
-            alias TypeTuple!() CountUp;
-    }
-
-
-    //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
-    // Code generator
-    //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
-
-    /*
-     * Runs through all the target overload sets and generates D code which
-     * implements all the functions in the overload sets.
-     */
-    public string generateCode(overloads...)() @property
-    {
-        string code = "";
-
-        // run through all the overload sets
-        foreach (i_; CountUp!(0 + overloads.length)) // workaround
-        {
-            enum i = 0 + i_; // workaround
-            alias overloads[i] oset;
-
-            code ~= generateCodeForOverloadSet!(oset);
-
-            static if (WITH_BASE_CLASS && oset.name != CONSTRUCTOR_NAME)
-            {
-                // The generated function declarations may hide existing ones
-                // in the base class (cf. HiddenFuncError), so we put an alias
-                // declaration here to reveal possible hidden functions.
-                code ~= Format!("alias %s.%s %s;\n",
-                            Policy.BASE_CLASS_ID, // [BUG 2540] super.
-                            oset.name, oset.name );
-            }
-        }
-        return code;
-    }
-
-    // handle each overload set
-    private string generateCodeForOverloadSet(alias oset)() @property
-    {
-        string code = "";
-
-        foreach (i_; CountUp!(0 + oset.contents.length)) // workaround
-        {
-            enum i = 0 + i_; // workaround
-            code ~= generateFunction!(
-                    oset.contents[i], Policy.FUNCINFO_ID!(oset.name, i)) ~ "\n";
-        }
-        return code;
-    }
-
-    /*
-     * Returns D code which implements the function func.  This function
-     * actually generates only the declarator part; the function body part is
-     * generated by the functionGenerator() policy.
-     */
-    //private string generateFunction(alias func, string myFuncInfo)() @property
-    private string generateFunction(args_.../+[BUG 4217]+/)() @property
-    {
-        alias args_[0..1] func; enum myFuncInfo = args_[1];
-
-        enum name   = __traits(identifier, func);
-        enum isCtor = (name == CONSTRUCTOR_NAME);
-
-        string code; // the result
-
-        /*** Function Declarator ***/
-        {
-            alias FunctionAttribute FA;
-            enum atts     = functionAttributes!(func);
-            enum realName = isCtor ? "this" : name;
-
-            /* Just for the sake of Format!(...). */
-            static string make_postAtts()
-            {
-                string poatts = "";
-                if (atts & FA.PURE    ) poatts ~= " pure";
-                if (atts & FA.NOTHROW ) poatts ~= " nothrow";
-                if (atts & FA.PROPERTY) poatts ~= " @property";
-                if (atts & FA.SAFE    ) poatts ~= " @safe";
-                if (atts & FA.TRUSTED ) poatts ~= " @trusted";
-                return poatts;
-            }
-            enum postAtts = make_postAtts();
-
-            static string make_returnType()
-            {
-                string rtype = "";
-
-                if (!isCtor)
-                {
-                    if (atts & FA.REF) rtype ~= "ret ";
-                    rtype ~= myFuncInfo ~ ".RT";
-                }
-                return rtype;
-            }
-            enum returnType = make_returnType();
-
-            //
-            code ~= Format!("extern(%s) %s %s(%s) %s\n",
-                    functionLinkage!(func),
-                    returnType,
-                    realName,
-                    ""~generateParameters!(func, myFuncInfo),
-                    postAtts );
-        }
-
-        /*** Function Body ***/
-        code ~= "{\n";
-        {
-            enum nparams = ParameterTypeTuple!(func).length;
-
-            /* Declare keywords: args, self and parent. */
-            string preamble;
-
-            preamble ~= "alias TypeTuple!(" ~ enumerateParameters!(nparams) ~ ") args;\n";
-            if (!isCtor)
-            {
-                preamble ~= "alias " ~ name ~ " self;\n";
-                if (WITH_BASE_CLASS && !__traits(isAbstractFunction, func))
-                    //preamble ~= "alias super." ~ name ~ " parent;\n"; // [BUG 2540]
-                    preamble ~= "auto parent = &super." ~ name ~ ";\n";
-            }
-
-            //
-            code ~= preamble;
-            code ~= Policy.generateFunctionBody!(func);
-        }
-        code ~= "}";
-
-        return code;
-    }
-
-    /*
-     * Returns D code which declares function parameters.
-     * "ref int a0, real a1, ..."
-     */
-    //private string generateParameters(alias func, string myFuncInfo)() @property
-    private string generateParameters(args_.../+[BUG 4217]+/)() @property
-    {
-        alias args_[0..1] func; enum myFuncInfo = args_[1];
-
-        alias ParameterStorageClass STC;
-        alias ParameterStorageClassTuple!(func) stcs;
-        enum nparams = stcs.length;
-
-        string params = ""; // the result
-
-        foreach (i, stc; stcs)
-        {
-            if (i > 0) params ~= ", ";
-
-            // Parameter storage classes.
-            if (stc & STC.SCOPE) params ~= "scope ";
-            if (stc & STC.OUT  ) params ~= "out ";
-            if (stc & STC.REF  ) params ~= "ref ";
-            if (stc & STC.LAZY ) params ~= "lazy ";
-
-            // Take parameter type from the FuncInfo.
-            params ~= myFuncInfo ~ ".PT[" ~ toStringNow!(i) ~ "]";
-
-            // Declare a parameter variable.
-            params ~= " " ~ Policy.PARAMETER_VARIABLE_ID!(i);
-        }
-
-        // Add some ellipsis part if needed.
-        final switch (variadicFunctionStyle!(func))
-        {
-            case Variadic.NO:
-                break;
-
-            case Variadic.C, Variadic.D:
-                // (...) or (a, b, ...)
-                params ~= (nparams == 0) ? "..." : ", ...";
-                break;
-
-            case Variadic.TYPESAFE:
-                params ~= " ...";
-                break;
-        }
-
-        return params;
-    }
-
-    // Returns D code which enumerates n parameter variables using comma as the
-    // separator.  "a0, a1, a2, a3"
-    private string enumerateParameters(size_t n)() @property
-    {
-        string params = "";
-
-        foreach (i_; CountUp!(n))
-        {
-            enum i = 0 + i_; // workaround
-            if (i > 0) params ~= ", ";
-            params ~= Policy.PARAMETER_VARIABLE_ID!(i);
-        }
-        return params;
-    }
-}