Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Command-line Reference
  - Feature Overview
  - Articles
- Packages
- Community
  - Blog
  - Orgs using D
  - Twitter
  - Forums
  - IRC
  - Wiki
  - GitHub
  - Issues
  - Foundation
  - Donate
- Resources
  - Books
  - Tutorials
  - Tools
  - Editors
  - IDEs
  - Visual D
  - Acknowledgments
  - D Style
  - Glossary
  - Sitemap

Search
Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.

# Change Log: 2.063

Download D 2.063
released May 28, 2013

#### Language Changes

1. Const and immutable fields with initializers are now warned about.
2. Constructor qualifiers are taken into account when constructing objects.
3. Struct members which require non-bitwise comparison are now properly compared.
4. Array copy operations now always require using the slice syntax.
5. Types no longer act as arguments in typeof expressions.
6. The index variable in a foreach range is no longer implicitly a reference.
7. Associative array entries are no longer default-initialized before assignment.
8. The const attribute is no longer inherited in overriden methods.
9. typeof(null) no longer implicitly converts to T[].
10. The Template This Parameter now changes the member function qualifier.
11. Array slices are now r-values.
12. Accessing a non-static field without a this reference is only allowed in certain contexts.
13. Arrays no longer implicitly convert to a pointer.

#### Language Enhancements

1. Expressions which return unique objects can be implicitly casted to immutable.
2. Static array of void can now be user-initialized.
3. Aggregates can now contain multiple invariants.
4. Methods of templated aggregates can now infer attributes.
5. is expression no longer requires an identifier.
6. Dynamic arrays of known size can be implicitly cast to static arrays in some contexts.
7. Tuples can now be void-initialized.
8. Tuples can now be compared for equality.
9. Template constraints can now be put after the inheritance list.
10. Fields with initializers can now be re-initialized in a const constructor.
11. Added the isNested trait for discovery of aggregates and functions with context pointers.
12. Templates can now be nested inside of functions.
13. UFCS now works with scoped local imports.
14. Added __FUNCTION__, __PRETTY_FUNCTION__ and __MODULE__.
15. DDoc: Deprecated declarations are now wrapped in a DEPRECATED macro.
16. Added documented unittest feature for verifiable code example generation.

#### Compiler Enhancements

1. Added -main switch which adds an empty main function.
2. Added -cov=percentage switch for minimal coverage tests.
3. Added ability to override the mangling of a symbol with a compiler pragma.

#### Phobos Changes

1. std.typecons.scoped implementation changed, potentially breaking some user-code.

#### Phobos Enhancements

1. std.process has been redesigned from the ground up and introduces a new API and functionality.
2. std.getopt can now set booleans to false.
3. Added ownerTid property in std.concurrency.

List of all bug fixes and enhancements in D 2.063.

#### Language Changes

1. Const and immutable fields with initializers are now warned about:

   Eventually, they will be deprecated, and then will trigger an error. Such fields should now be changed to enum or static.

   In a future release, a new behavior for them will be enabled:

   Fields in an aggregate which are not static will always be addressable. This means they will occupy space in the object:

       struct S
       {
           // used to be implicitly static in 2.062, now warns. In a future release it will become non-static.
           immutable int[] arr = [1, 2];

           // ditto
           const int[] arr2 = [1, 2];
       }

   This means that code which accessed such declarations without the this reference will no longer compile. Additionally code which depended on the size of a structure with such fields will have to be fixed:

       struct S
       {
           immutable int[] arr = [1, 2];
       }

       void main()
       {
           auto x = S.arr;  // becomes an error in a future release, 'arr' will require the 'this' reference.

           // S is size 1 in 2.062 and 2.063. In a future release this will change and the following static assert will pass.
           static assert(S.sizeof == size_t.sizeof + size_t.sizeof);  // ptr + length for the array
       }

   To make the field static again, simply use the static keyword. Alternatively make the field an enum to turn it into a manifest constant:

       struct S
       {
           static immutable int[] arr = [1, 2];
           enum arr2 = [1, 2];
       }

   Note however that manifest constants which are arrays are allocated on each usage, so you may prefer using static instead.

   ### Rationale:

   Making a field implicitly static based on whether it is const/immutable and has an initializer leads to confusion. The static keyword can be used to explicitly make any field static.

2. Constructor qualifiers are taken into account when constructing objects:

   A qualified constructor is now invoked when a const/immutable/shared aggregate object is instantiated, respectively:

       import std.stdio;

       class C
       {
           this()           { writeln("1"); }
           this() const     { writeln("2"); }
           this() immutable { writeln("3"); }
           this() shared    { writeln("4"); }
       }

       void main()
       {
           auto a = new C;           // writes "1"
           auto b = new const C;     // writes "2"
           auto c = new immutable C; // writes "3"
           auto d = new shared C;    // writes "4"
       }

   This has the consequence that aggregates which have only immutable or shared constructors can no longer be used to instantiate mutable objects:

       class C
       {
           this() immutable { }
           this() shared { }
       }

       void main()
       {
           auto c1 = new C;           // disallowed
           auto c2 = new immutable C; // ok
           auto c3 = new shared C;    // ok
       }

   On the other hand, aggregates which do not have shared or immutable constructors can no longer be used to construct shared or immutable objects, respectively:

       class C
       {
           this() { }
       }

       void main()
       {
           auto c1 = new C;           // ok
           auto c2 = new immutable C; // disallowed
           auto c3 = new shared C;    // disallowed
       }

   However, if an aggregate has a pure constructor it can be used to construct an object with any type constructor:

       class C
       {
           this() pure { }
       }

       void main()
       {
           auto c1 = new C;  // ok
           auto c2 = new immutable C;  // ok
           auto c3 = new shared C;  // ok
       }

3. Struct members which require non-bitwise comparison are now properly compared.

   In earlier releases some struct members such as arrays would be bitwise-compared in a comparison operation. This has now been changed to be a structural comparison instead:

       struct S
       {
           char[] data;
       }

       void main ()
       {
           auto s1 = S("foo".dup);
           auto s2 = S("foo".dup);

           assert(s1.data !is s2.data);  // both are unique data

           assert(s1 == s2);   // passes in 2.063
           assert(s1.data == s2.data);  // equivalent of above
       }

   If an opEquals function is not present the compiler rewrites the expression s1 == s2 to s1.tupleof == s2.tupleof. Comparing .tupleof expressions is also a feature new to D in the 2.063 release.

4. Array copy operations now always require using the slice syntax:

   The right-hand-side of an array copy operation now requires using the slice syntax:

       void main()
       {
           int[][2] x;
           int[] y;
           int[] z;

           x[] = z;    // copies z (pointer + length) 2 times to x
           y[] = z;    // copies each element of z into y (compiler emits warning)
       }

   If the user intended to write such code they must use the slice syntax for both the source and target arrays:

       void main()
       {
           int[][2] x;
           int[] y;
           int[] z;

           y[] = z[];  // copies each element of z into y (no warnings)
       }

   ### Rationale:

   The compiler will emit a warning to make the user aware that the copy operation is arbitrarily expensive.

5. Types no longer act as arguments in typeof expressions:

   A type can no longer be passed to a function as a value of that type:

       T[] foo(T)(T t)
       {
           return null;
       }

       void main()
       {
           alias int Int;

           // used to work (only with an alias), now a compiler error
           alias typeof(foo(Int)) IntArray;
       }

   If the user wants to pass an argument of a certain type, they can use the .init property:

       T[] foo(T)(T t)
       {
           return null;
       }

       void main()
       {
           alias typeof(foo(int.init)) IntArray;  // ok
       }

   ### Rationale:

   Treating types as expressions in special contexts only leads to confusion. Instead, the .init property can be used for such purposes.

6. The index variable in a foreach range is no longer implicitly a reference:

   The index variable in a foreach range is now by default a value type:

       void main()
       {
           size_t count;
           foreach (n; 0 .. 10)
           {
               ++n;
               ++count;
           }
           assert(count == 10);  // passes
       }

   If the user wants to modify the index variable he must use the ref keyword:

       void main()
       {
           size_t count;
           foreach (ref n; 0 .. 10)
           {
               ++n;
               ++count;
           }
           assert(count == 5);
       }

   ### Rationale:

   Making the index variable implicitly ref can introduce bugs that are hard to track down.

7. Associative array entries are no longer default-initialized before assignment:

   An associative array entry used to be default-initialized before assignment took place:

       void main()
       {
           int[int] aa;
           aa[1] = aa[1] + 1;   // no Error thrown in 2.062
           assert(aa[1] == 1);  // worked in 2.062
       }

   In 2.063, accessing an entry which does not exist will now throw a RangeError:

       void main()
       {
           int[int] aa;
           aa[1] = aa[1] + 1;   // RangeError thrown in 2.063
       }

   ### Rationale:

   Default-initialization during assignment can be a source of bugs.

8. The const attribute is no longer inherited in overriden methods.

   Method overrides no longer inherit constness of the base method:

       class A
       {
           void foo() const { }
       }

       class B : A
       {
           // used to work in 2.062, now an error
           override void foo() { }  // note missing 'const'
       }

   If the user wants to override a const method he has to mark the overriden method as const:

       class A
       {
           void foo() const { }
       }

       class B : A
       {
           override void foo() const { }  // ok
       }

   The feature allows introducing new overloads based on the constness of the method:

       class A
       {
           void foo() const { }
       }

       class B : A
       {
           // introduces new overload (not override!)
           void foo() { }

           // if the above overload is introduced the user must either:
           // a: re-introduce the const overload to prevent function hijacking
           alias super.foo foo;  // without this you will get a compiler error

           // or b: provide a properly typed override:
           override void foo() const { }
       }

9. typeof(null) no longer implicitly converts to T[]:

   The following code used to be allowed:

       void f(int[] function() del)
       {
           assert(!del());  // fails
       }

       typeof(null) g() { return null; }

       void main()
       {
           f(&g);
           f(() => null);
       }

   However the implicit conversion would end up generating wrong code. To work around this, make sure the return type is typed properly, or use (T[]).init in the return expression of a lambda expression:

       void f(int[] function() del)
       {
           assert(!del());  // passes
       }

       int[] g() { return null; }  // fixed return type

       void main()
       {
           f(&g);  // ok
           f(() => (int[]).init);  // ok
       }

10. The Template This Parameter now changes the member function qualifier:

    The Template This Parameter can now be used to infer the qualifier of this to member functions:

        struct S
        {
            void foo(this T)()
            {
            }
        }

        void main()
        {
             immutable S s;
             s.foo();  // makes S.foo immutable
        }

11. Array slices are now r-values:

    Array slices are no longer l-values. This means an address can no longer be taken of a slice, and slices cannot be passed by ref to functions:

        void foo(ref int[] arr) { arr = new int[10]; }

        void main()
        {
            int[] arr;
            foo(arr);  // ok
            assert(arr.length == 10);

            foo(arr[]);  // disallowed in 2.063, the slice is an r-value
            auto ptr = &arr[1..2];  // disallowed in 2.063, cannot take address of r-value
        }

    To work around this you can make your function take an r-value if it doesn't need to reassign and resize the slice, but only needs to read or modify its contents. Otherwise, to accept both l-values and r-values you can make your function take its argument by auto ref:

        void take(int[] arr) { }
        void takeRef(ref int[] arr) { }
        void takeAutoRef(T)(auto ref T[] arr) { }

        void main()
        {
            int[] arr = [1, 2, 3, 4];
            take(arr);          // ok
            takeRef(arr);       // ok
            takeAutoRef(arr);   // ok

            int[] arr2 = arr[1 .. 2];
            take(arr2);         // ok, arr2 is a variable
            takeRef(arr2);      // ditto
            takeAutoRef(arr2);  // ditto

            take(arr[1 .. 2]);         // ok
            takeRef(arr[1 .. 2]);      // error, cannot pass r-value by reference
            takeAutoRef(arr[1 .. 2]);  // ok
        }

    ### Rationale:

    Passing slices by reference had no observable effect when reassigning or resizing such a slice at the call site, therefore such slices should by default be r-values. For example, the following code used to be allowed but is now a compile-time error:

        void reAssign(ref int[] arr) { arr = new int[2]; }
        void reSize(ref int[] arr)   { arr.length = 10; }

        void main()
        {
            int[] arr = [1, 2, 3, 4];

            reAssign(arr[0 .. 4]);  // reassigning has no observable effect at the call site
            assert(arr == [1, 2, 3, 4]);

            reSize(arr[0 .. 4]);    // resizing has no observable effect at the call site
            assert(arr.length == 4);
        }

12. Accessing a non-static field without a this reference is only allowed in certain contexts:

    Accessing non-static fields used to be allowed in many contexts, but is now limited to only a few:

    - offsetof, init, and other built-in properties are allowed:

        struct S { int field; }

        void main()
        {
            auto a = S.field.offsetof;  // ok, statically known
            auto c = S.field.max;       // ditto
            auto d = S.field;           // disallowed, no `this` reference
        }

    - When invoking static methods of a non-static field:

        struct Foo
        {
            static struct Bar
            {
                static int get() { return 0; }
            }

            Bar bar;
        }

        void main()
        {
            static assert(Foo.bar.get() == 0);  // ok, equivalent to `typeof(Foo.bar).get()`
        }

    - When accessing static fields implicitly using an alias this expression:

        struct Foo
        {
            static struct Bar
            {
                static int get() { return 0; }
            }

            Bar bar;
            alias bar this;
        }

        void main()
        {
            static assert(Foo.get() == 0);  // ok, equivalent to 'typeof(Foo.bar).get()'
        }

13. Arrays no longer implicitly convert to a pointer:

    The implicit conversion of an array to a pointer was a deprecated feature:

        void foo(int* p) { }

        void main()
        {
            int[] arr = [1, 2];
            foo(arr);   // ok if -d switch is used during compilation
        }

    This feature has now been completely removed. The workaround is to either use the .ptr property, or explicitly pass the pointer to the first element:

        void foo(int* p) { }

        void main()
        {
            int[] arr = [1, 2];
            foo(arr);      // compile error
            foo(arr.ptr);  // ok
            foo(&arr[0]);  // ok
        }

#### Language Enhancements

1. Expressions which return unique objects can be implicitly casted to immutable:

   Expressions such as new for objects and arrays, and dup for arrays, can now be inferred to be unique. This allows the compiler to implicitly convert such an expression to immutable:

       class C { }

       void main()
       {
           immutable int[] arr1 = new int[](3);   // ok
           immutable int[] arr2 = [1, 2, 3].dup;  // ok in 2.063
           immutable C[] arr3 = [new C, new C].dup;  // ok in 2.063
       }

2. Static array of void can now be user-initialized.

   A static array of void could not be initialized in user-code:

       void main()
       {
           void[2] varr1;  // error in 2.062
           void[2] varr2 = (void[2]).init;  // error in 2.062
           void[2] varr3 = void;  // ok in 2.062
       }

   In 2.063, an explicit initializer can be used:

       void main()
       {
           void[2] varr1;  // still an error in 2.063
           void[2] varr2 = (void[2]).init;  // ok in 2.063
           void[2] varr3 = void;  // ok in 2.063
       }

   The .init property effectively zero-initializes the array.

   ### Rationale:

   The restriction has been lifted to allow generic code to use .init without having to specialize for static void arrays.

3. Aggregates can now contain multiple invariants:

   If an aggregate type has multiple invariants, the invariants' bodies will be merged into a single invariant function and will be run in sequence. Note that the code in one invariant cannot reference code or data in another invariant:

       struct S
       {
           int x;

           void foo() { }

           invariant()
           {
               int local;
               assert(x != 0);
           }

           invariant()
           {
               // local = 1;  // invariant does not have access to the other invariant's body
               assert(x % 2 == 0);
           }
       }

       void main()
       {
           S s = S(2);
           s.foo();  // invoking public function triggers both invariants in sequence
       }

4. Methods of templated aggregates can now infer attributes:

   If a function with some attributes instantiates a templated aggregate, it's member functions will infer those attributes:

       struct S(T)
       {
           T square(T x)
           {
               return x * x;
           }
       }

       void main() pure
       {
           S!int s;  // S!int.square becomes pure and callable from main()
           assert(s.square(2) == 4);  // ok
       }

5. is expression no longer requires an identifier:

   In some cases the is expression required an identifier even when you didn't have a use for it:

       void main()
       {
           alias AA = string[int];

           static if (is(AA _ == V[K], V, K))
           {
               pragma(msg, _);  // prints string[int]
               pragma(msg, K);  // prints int
               pragma(msg, V);  // prints string
           }
       }

   The identifier is no longer required, so the above can be rewritten to:

       void main()
       {
           alias AA = string[int];

           static if (is(AA == V[K], V, K))
           {
               pragma(msg, AA); // prints string[int]
               pragma(msg, K);  // prints int
               pragma(msg, V);  // prints string
           }
       }

6. Dynamic arrays of known size can be implicitly cast to static arrays in some contexts:

   In some contexts the compiler knows the size of a dynamic array or of a slice of an array. In such a case the compiler will allow an implicit conversion to a static array of the same size:

       void foo(int[4] x) { }

       void main()
       {
           int[] arr = [1, 2, 3, 4, 5, 6, 7, 8];
           foo(arr[0 .. 4]);  // ok
       }

   Another example, where a string is converted to a reference to a static array:

       string str = "aaaabbbbccccdddd";

       void foo(ref const(char)[16] buf)
       {
           assert(buf.ptr is str.ptr);
       }

       void main()
       {
           foo(str[0..16]);  // ok
       }

   ### Limitations:

   - This feature does not yet work with complex expressions where it might be reasonable to assume the size of a slice:

       void foo(int[4] x) { }

       void main()
       {
           int[] arr = [1, 2, 3, 4, 5, 6, 7, 8];
           foreach (i; 0 .. 4)
           {
               foo(arr[i .. i + 4]);  // not yet supported
           }
       }

7. Tuples can now be void-initialized:

   You can now void-initialize a tuple variable:

       template Tuple(T...)
       {
           alias T Tuple;
       }

       void main()
       {
           Tuple!(int, int) tup1 = void;  // ok
       }

   Upon such initialization the values in the tuple are undetermined.

8. Template constraints can now be put after the inheritance list:

   Template constraints used to be allowed only before the inheritance list, leading to code where the inheritance list could be hard to spot:

       class Foo(T1, T2)
           if (is(T1 == int) && is(T2 == string)) : Base
       {
       }

   This restriction has been lifted, so you can now write:

       class Foo(T1, T2) : Base
           if (is(T1 == int) && is(T2 == string))
       {
       }

9. Tuples can now be compared for equality:

   Example:

       struct Tuple(T...) { T field; alias field this; }

       void main()
       {
           auto tup1 = Tuple!(int, int)(1, 2);
           auto tup2 = Tuple!(int, int)(1, 2);
           auto tup3 = Tuple!(int, int)(1, 3);

           assert(tup1 == tup2);  // works since 2.063
           assert(tup1 != tup3);  // works since 2.063
       }

   This also means you can now compare ParameterStorageClassTuple instances from std.traits:

       import std.traits;

       void func1(ref int x, ref int y) { }
       void func2(ref float x, ref float y) { }

       void main()
       {
           alias Storages = ParameterStorageClassTuple;
           assert(Storages!func1 == Storages!func2);
       }

   In addition to that, builtin .tupleof expressions can be used to easily compare fields of an aggregate:

       struct S
       {
           char[] a, b;

           // Implements equality test against another instance of this type.
           bool opEquals(S rhs) { return this.tupleof == rhs.tupleof; }
       }

       void main()
       {
           S s1 = S("a".dup, "b".dup);
           S s2 = S("a".dup, "b".dup);
           assert(s1 == s2);
       }

   This also allows you to implement a structural equality test against an instance of a different type:

       struct S1
       {
           char[] a, b;

           // Implements a structural equality test against any other type T
           bool opEquals(T)(T rhs) { return this.tupleof == rhs.tupleof; }
       }

       struct S2
       {
           string x, y;
       }

       void main()
       {
           auto s1 = S1("123".dup, "456".dup);
           auto s2 = S2("123", "456");
           assert(s1 == s2);
       }

   Since tuples can be sliced you can use this feature to compare a subset of tuples:

       struct S
       {
           int a, b, c, d, e;

           bool opEquals(S rhs)
           {
               // compares a, b, d, and e
               return this.tupleof[0..2] == rhs.tupleof[0..2] &&
                      this.tupleof[3..5] == rhs.tupleof[3..5];
           }
       }

       void main()
       {
           S s1 = S(1, 2, 0, 3, 4);
           S s2 = S(1, 2, 1, 3, 4);
           assert(s1 == s2);
       }

10. Fields with initializers can now be re-initialized in a const constructor:

    You can now initialize a field in a const constructor even if such a field already has an initializer:

        struct S
        {
            bool field = true;

            this(int v) const
            {
                field = false;  // ok
            }
        }

11. Added the isNested trait for discovery of aggregates and functions with context pointers:

    The new isNested trait allows you to discover whether an aggregate or function contains a context pointer:

        void main()
        {
            int x;

            struct S1 { void f() { x++; } }
            static struct S2 { }

            void f1() { x++; }
            static void f2() { }

            static assert(__traits(isNested, S1));
            static assert(__traits(isNested, f1));
            static assert(!__traits(isNested, S2));
            static assert(!__traits(isNested, f2));
        }

12. Templates can now be nested inside of functions:

    void test()
    {
        template ArrayOf(T) { alias ArrayOf = T[]; }
        static assert(is(ArrayOf!int == int[]));
    }

Allowing template's inside of functions will enable better encapsulation and avoid the pollution of module-scoped symbol names.

13. UFCS now works with scoped local imports:

    Functions that are made available through a local import are now picked up when using Uniform Function Call Syntax:

        module foo;
        string concat(string arg1, string arg2) { return arg1 ~ arg2; }

        module test;
        void main()
        {
            import foo;
            assert("foo".concat("bar") == "foobar");  // UFCS now works
        }

    This feature also works for imports within aggregates. Note that local imports have a higher precedence than module-scoped imports.

14. Added __FUNCTION__, __PRETTY_FUNCTION__ and __MODULE__:

    A new set of special keywords were added. Together with __FILE__ and __LINE__ they form a complete feature set that is useful in debugging code:

        module test;
        import std.stdio;

        void test(string file = __FILE__, size_t line = __LINE__, string mod = __MODULE__,
                  string func = __FUNCTION__, string pretty = __PRETTY_FUNCTION__)
        {
            writefln("file: '%s', line: '%s', module: '%s',\nfunction: '%s', pretty function: '%s'",
                     file, line, mod, func, pretty);
        }

        int main(string[] args)
        {
            test();
            return 0;
        }

    The above will output:

        file: 'test.d', line: '13', module: 'test',
        function: 'test.main', pretty function: 'int test.main(string[] args)'

15. DDoc: Deprecated declarations are now wrapped in a DEPRECATED macro:

        module test;

        /// sum function
        deprecated int sum(int x, int y) { return x + y; }

    By default the macro expands to its argument. It can be overriden by the user, for example:

    macros.ddoc:

        DEPRECATED=<del>$0</del>

    The above ddoc file can then be used when the documentation is being generated:

        $ dmd -D -o- test.d macros.ddoc

16. Added documented unittest feature for verifiable code example generation:

    Documented unittests which follow any symbol declarations are now used to generate example sections for the symbol when generating DDOC documentation. Example:

        /// sum function
        int sum(int x, int y) { return x + y; }

        ///
        unittest
        {
            assert(sum(2, 2) == 4);
        }

    The body of the unittest will be part of the documentation of the sum function. This allows the implementor of the function to keep their examples always up-to-date.

    For more information, see the documentation page of documented unittests.

#### Compiler Enhancements

1. Added -main switch which adds an empty main function:

   The -main switch is primarily useful when unittesting libraries:

       module test;

       int sum(int a, int b) { return a + b; }
       unittest
       {
           assert(sum(2, 2) == 4);
       }

   The above library would need a main() function for the unittests to run, and -main can be used for this purpose:

       $ dmd -unittest -main -run test.d

2. Added -cov=percentage switch for minimal coverage tests.

   The -cov switch now has an optional percentage setting which makes the executable emit an error when the coverage doesn't meet the specified requirement:

       module test;

       void test1() { int x = 5; }
       void test2() { int x = 5; }
       void test3() { int x = 5; }

       void main()
       {
           test1();
           test2();
       }

   Example of coverage testing:

       $ dmd -cov=90 test.d
       $ test
       Error: test.d is 80% covered, less than required 90%

3. Added ability to override the mangling of a symbol with a compiler pragma:

   The new pragma(mangle, ...) directive allows you to set a custom mangling for any symbol:

       pragma(mangle, "module") extern(C) void module_();

   The above allows linking to a C function named "module", which ordinarily we wouldn't be able to link to directly since "module" is a reserved D keyword.

#### Phobos Changes

1. std.typecons.scoped implementation changed, potentially breaking some user-code:

   User-code which used the std.traits.ReturnType trait to retrieve the type of a scoped call will have to be changed to use the typeof operator instead:

       class A
       {
           this() {}
           this(int) {}
       }

       class B
       {
           // ReturnType!(scoped!A) a;  // disallowed in 2.063
           typeof(scoped!A()) a;        // rewritten, compiles in 2.063

           this()
           {
               a = scoped!A(1);  // would not compile in 2.062, but works with syntax used for 2.063
           }
       }

   The reason for this change is that the ReturnType trait would retrieve the wrong type when a class had multiple constructors, and this would cause initializing the field to fail.

   Another benefit of the new implementation is that scoped can now be aliased for usability purposes:

       class A
       {
           this(int) { }
       }

       void main()
       {
           alias scoped!A scopeA;
           auto a = scopeA(1);
       }

#### Phobos Enhancements

1. std.process has been redesigned from the ground up and introduces a new API and functionality:

   The new std.process module introduces functionality for invoking processes with custom pipe redirection, the ability to wait for processes to finish, and the ability to kill processes. The full list of features can be found in the std.process documentation.

2. std.getopt can now set booleans to false:

   Example code:

       void main(string[] args)
       {
           bool flag = true;
           getopt(args, &flag);
       }

   When invoked via --flag=false, it will set flag to false.

3. Added ownerTid property in std.concurrency:

   It is now easier to send a message from a child thread to its owner thread. Simply use the ownerTid property to get the owner thread's Tid identifier:

       void fun()
       {
           string res = receiveOnly!string();
           assert(res == "Main calling");

           ownerTid.send("Child responding");  // new
       }

       void main()
       {
           auto child = spawn(&fun);
           child.send("Main calling");

           string res = receiveOnly!string();
           assert(res == "Child responding");
       }

   If the owner thread has exited, accessing ownerTid from any of its child threads will throw a TidMissingException.

List of all bug fixes and enhancements in D 2.063:

#### DMD Compiler regressions

1. Bugzilla 9130: Wrong codegen for compile time constructed struct
2. Bugzilla 9258: opAssign with base class triggers "identity assignment operator overload" error
3. Bugzilla 9526: ICE when compiling project with unittests
4. Bugzilla 9536: IFTI fails when calling a static member from const member
5. Bugzilla 9538: Regression (2.062): Can't use typeid on .ptr of static array
6. Bugzilla 9539: Wrong implicit conversion of array to pointer
7. Bugzilla 9545: [REG 2.063a] ICE with member template instantiation
8. Bugzilla 9552: DMD crashed when taking member delegate from __traits(getOverloads)
9. Bugzilla 9566: Regression (2.062): Cannot use struct .init when it contains a static array initialized from a single element.
10. Bugzilla 9568: [64bit] wrong code for scope(exit)
11. Bugzilla 9633: compiles trait wrongly returns true even when object method call actually does not compile
12. Bugzilla 9650: __traits(compiles) + mixin
13. Bugzilla 9663: [REG2.063a] ICE caused by issue 7444 change.
14. Bugzilla 9672: mixin within cyclic import causes undefined properties
15. Bugzilla 9689: std.typecons.Proxy breaks with @disable this(this)
16. Bugzilla 9694: A member struct that has mutable opEquals reports weird error message
17. Bugzilla 9739: Regression (1.077 git-head): DMD not considering ctor with default args as default ctor
18. Bugzilla 9759: compiler segfault in StructLiteral::implicitConvTo(Type*) on invalid code
19. Bugzilla 9764: Ddoc: Ddoc file name is incorrectly emphasized
20. Bugzilla 9775: Can no longer create a const Date in CTFE if the variable is explicitly typed
21. Bugzilla 9806: assertion failure in struct.c:668
22. Bugzilla 9834: incorrect detection of lambda locality.
23. Bugzilla 9846: regression of forward references
24. Bugzilla 9858: const alias this fails when opAssign is present
25. Bugzilla 9865: Crash on bogus import / circular reference
26. Bugzilla 9890: Alias This + Alias Fields
27. Bugzilla 9903: Broken ddoc in std.typecons and etc.c.sqlite3
28. Bugzilla 9919: Regression (2.062): Symbol lookup fails with public import and mixin
29. Bugzilla 9952: regression(HEAD): Attribute inference for virtual functions breaks subclasses
30. Bugzilla 9957: [2.061 -> 2.062] Taking pointer of enum float array gives some garbage
31. Bugzilla 9974: immutable class constructor is broken
32. Bugzilla 9984: inout qualifier is skipped for constructor arguments (template constructor only)
33. Bugzilla 9987: Declaring struct ModuleInfo should be allowed
34. Bugzilla 10002: 2.062 -> 2.063 calling "remove" is impure
35. Bugzilla 10003: void* UFCS regression
36. Bugzilla 10016: Incorrect error gagging using RefCounted
37. Bugzilla 10040: struct-related ICE
38. Bugzilla 10041: ufcs writeln of associative array
39. Bugzilla 10043: ICE with __traits(compiles)
40. Bugzilla 10044: Wrong di generation for IsExp with TemplateParameterList
41. Bugzilla 10047: opDispatch instantiation failure should be gagged for UFCS
42. Bugzilla 10049: Spurious "Label already defined" error inside a foreach over a range aggregate
43. Bugzilla 10050: Regression (git-head): RDMD no longer emits error messages from DMD
44. Bugzilla 10053: struct member with pure dtor forces declared dtor to be pure, too
45. Bugzilla 10055: Incorrect attribute merging in dtor/postblit building
46. Bugzilla 10056: Strange Error with templates and string.format
47. Bugzilla 10067: [REG] Recursive template instantiation
48. Bugzilla 10073: Default opEquals depends on class declaration order with DMD HEAD
49. Bugzilla 10076: expression.c:4310: virtual Expression* TypeExp::semantic(Scope*): Assertion 0 failed.
50. Bugzilla 10089: Strange function call error message with specified module
51. Bugzilla 10091: [HEAD] Cannot cast struct member string enum to static ubyte array of same size
52. Bugzilla 10096: Regression (git-head): __traits(allMembers) triggers out of bounds error
53. Bugzilla 10101: static if conditional cannot be at global scope using mixin template
54. Bugzilla 10106: [ICE] Ice in glue.c:1215 + 2 error messages without lines
55. Bugzilla 10134: Mutual referencing templates error
56. Bugzilla 10142: [REG2.063a] enum value semantic problem that declared in class member
57. Bugzilla 10144: Using enum inside final class occurs weird errors
58. Bugzilla 10148: regression 062=>063: unjustified 'safe function cannot call system function'
59. Bugzilla 10151: final: before enum is now an error.
60. Bugzilla 10160: No line number "cannot modify struct ... with immutable members"
61. Bugzilla 10166: XXX is not a template
62. Bugzilla 10178: Compiler segfault with zero-length tuple comparison

#### DMD Compiler bugs

1. Bugzilla 1520: TypeInfo_Const.opEquals is incorrect
2. Bugzilla 1804: Severe GC leaks with repetitive array allocations
3. Bugzilla 2356: array literal as non static initializer generates horribly inefficient code.
4. Bugzilla 3789: [TDPL] Structs members that require non-bitwise comparison not correctly compared
5. Bugzilla 4094: ICE(expression.c): recursive struct templates with type inference
6. Bugzilla 4247: Cannot create default-constructed struct on heap when constructor is defined
7. Bugzilla 4414: ICE(cgcs.c) Taking item of static array returned by function
8. Bugzilla 4436: Double bug regarding Tuple.init
9. Bugzilla 4479: Module Foo is in multiple files Foo
10. Bugzilla 4617: Alias this'ed symbols cannot be passed to templates
11. Bugzilla 4814: rdmd: Doesn't rebuild when using -of and turning an -L linker option on or off
12. Bugzilla 5450: no match for implicit super() call in constructor
13. Bugzilla 5625: std.format unittest disabled
14. Bugzilla 6070: CTFE UFCS forward reference error
15. Bugzilla 6089: __gshared with not static 2D array
16. Bugzilla 6153: Inserting to An Array!T inside an Array!(Array!T) causes a segfault.
17. Bugzilla 6312: template instance cannot use argument from enclosing template
18. Bugzilla 6431: [RDMD] Modifying a library doesn't trigger a rebuild
19. Bugzilla 6535: RDMD outputs broken library files
20. Bugzilla 6539: Incomprehensible error message with failed template instantiation
21. Bugzilla 6545: [CTFE] Hard-coded array operations not yet supported
22. Bugzilla 6578: Ignored const with struct with constructor
23. Bugzilla 6795: ICE(cgcs.c): Incrementing an enum array item
24. Bugzilla 6852: Cannot compare instances of ParameterStorageClassTuple
25. Bugzilla 7068: copying array of pointers calls memset instead of memcpy with -d
26. Bugzilla 7437: DMD enters infinite loop during overload resolution
27. Bugzilla 7569: cannot void initialize tuple declarations
28. Bugzilla 7572: f.fn!(void) is not an lvalue
29. Bugzilla 7719: enum forward reference error when enum is in braces
30. Bugzilla 7980: Stack overflow / recursive expansion with alias this
31. Bugzilla 8041: __gshared/static problem
32. Bugzilla 8081: pure nothrow unittest problem in generated 'header' file
33. Bugzilla 8130: Memory corruption because without *.def file DMD compiles DLL with assumption _tls_index = 0
34. Bugzilla 8213: Incorrect error message with pointer to ubyte[] and front
35. Bugzilla 8238: templates can create ghost fields
36. Bugzilla 8245: UFCS doesn't work for pointers
37. Bugzilla 8294: complex breaks calling in 64 bit DMD
38. Bugzilla 8347: Parser bug with const placed after ~this() in decl
39. Bugzilla 8366: Overriding const member function in conjunction with mutable overload causes a strange error
40. Bugzilla 8589: Incorrect conversion of function returning typeof(null) to function returning an array
41. Bugzilla 8609: A forward reference error with static arrays
42. Bugzilla 8668: public selective import makes functions conflict when otherwise they don't
43. Bugzilla 8670: IFTI fails from aliases
44. Bugzilla 8697: Invalid error message: Forward reference of interface
45. Bugzilla 8698: Forward reference error with interfaces
46. Bugzilla 8827: Cannot move contents of R12
47. Bugzilla 8828: Long compilation time of a destroy() on a large fixed-sized matrix
48. Bugzilla 8833: Odd error with expression tuples
49. Bugzilla 8902: Unexpected "duplicate union initialization for X" error
50. Bugzilla 8945: Can't call static struct initializer or constructor without qualifier for templated inner struct
51. Bugzilla 8953: Parser rejects qualifier after destructor i.e. ~this() <qualifier> { }
52. Bugzilla 8989: cfloat argument passing broken
53. Bugzilla 8998: 'inout pure' returns immutable, which in reality is mutable
54. Bugzilla 9091: Using __traits(getMember) on template argument fails inside member function
55. Bugzilla 9144: synchronized CRITSECSIZE should be a target constant
56. Bugzilla 9199: Module level qualified functions should be rejected
57. Bugzilla 9209: ice(symbol.c) with const struct heap allocation
58. Bugzilla 9231: overriding inout funcion with attribute inference reports weird error
59. Bugzilla 9232: Parsing error on some templated methods calls
60. Bugzilla 9241: 2.061: Property call error message disappeared
61. Bugzilla 9280: Runtime range violation with named capture groups in regex
62. Bugzilla 9311: shared library file extension incorrectly modified
63. Bugzilla 9345: CTFE fails when using std.string.format with imported string enum
64. Bugzilla 9346: nested struct calls disabled postblit
65. Bugzilla 9386: struct destructor called erroneously
66. Bugzilla 9393: Partial template specialization and template lambda does not work
67. Bugzilla 9401: destructor and nothrow syntax
68. Bugzilla 9413: Incorrect modification inside contracts is not detected correctly
69. Bugzilla 9414: Incorrect modification inside contracts is not detected on virtual function
70. Bugzilla 9415: delegate inference should make function literal impure
71. Bugzilla 9417: "no size yet for forward reference" error with nested structure
72. Bugzilla 9428: Wrong array concatenation
73. Bugzilla 9441: struct constructor missed on auto/type-inferred variable definition
74. Bugzilla 9445: interpret.c:151: Assertion v->ctfeAdrOnStack >= 0 && v->ctfeAdrOnStack < stackPointer() failed.
75. Bugzilla 9451: Listing abstract functions in diagnostic should show full signature
76. Bugzilla 9473: Unittest docs should each be in their own section
77. Bugzilla 9474: Ddoc'd unittests should work correctly with interspersed version(none)
78. Bugzilla 9475: Should retain source formatting in ddoc's unittests
79. Bugzilla 9480: The template name in the JSON output contains template and function arguments
80. Bugzilla 9494: compiler stack overflow on invalid associative array
81. Bugzilla 9495: Win64 vararg issue when first argument is > 8 byte
82. Bugzilla 9508: RDMD doesn't generate new dependency list when a file is changed.
83. Bugzilla 9540: Compiler crash on delegate context frame assignment
84. Bugzilla 9561: Many error messages from std.format
85. Bugzilla 9590: UFCS does not work with void lazy expressions
86. Bugzilla 9613: Parser bug when using .init with type constructor
87. Bugzilla 9617: ulong.max is wrongly accepted by smaller signed parameter
88. Bugzilla 9619: Failed struct field typeof in inner function
89. Bugzilla 9622: Range violation in rdmd
90. Bugzilla 9649: DMD doesn't parse valid PostfixExpression . NewExpression syntax.
91. Bugzilla 9652: __traits(getAttributes) doesn't work with manifest constants
92. Bugzilla 9654: Template function cannot take string by ref T[len]
93. Bugzilla 9656: Built-in dup result should behave as like unique array, if it is possible.
94. Bugzilla 9658: Setting pre-initialized field should be allowed in qualified constructor.
95. Bugzilla 9677: Crash on setting length property of array VC 2012 64 bit
96. Bugzilla 9679: Refused const/immutable assignment in conditional
97. Bugzilla 9692: __traits(allMembers) fails on module without a package
98. Bugzilla 9700: std.typecons.Proxy with invaliant and in-place operation causes Access Violation
99. Bugzilla 9712: IFTI does not support deducing static array types from array literal arguments
100. Bugzilla 9713: Ddoc: Empty description suppress automatic example generation
101. Bugzilla 9714: Ddoc: Combination of -D and -unittest reveals hidden unittest function
102. Bugzilla 9720: OSX wrong code with -O Illegal instruction
103. Bugzilla 9722: optimizer kills GOT to EBX load
104. Bugzilla 9729: interface thunk doesn't set EBX to GOT
105. Bugzilla 9735: Casting delegates to void* should be illegal
106. Bugzilla 9736: VS2010 project file does full rebuild every time
107. Bugzilla 9743: IFTI and polymorphic string literal should support implicit conversion to static array type
108. Bugzilla 9744: Poor error message taking address of thread-local variable at compile time
109. Bugzilla 9747: IFTI argument deduction fails for committed string literals which are implicitly converted to a static array
110. Bugzilla 9755: JSON output is missing the protection attribute for templates
111. Bugzilla 9757: Ddoc: documented unittest after ditto should work
112. Bugzilla 9758: Ddoc: empty ddoc comment and unittest block generates no Examples section
113. Bugzilla 9768: No line number for wrong foreach type
114. Bugzilla 9773: ref parameter with default value should not compile
115. Bugzilla 9774: Error message with __error using == on tuple members
116. Bugzilla 9777: Calling final interface method leads to wrong code
117. Bugzilla 9781: -inline will cause backend ICE
118. Bugzilla 9788: -profile doesn't work if exceptions are thrown in the running program
119. Bugzilla 9790: Internal error when compiling a invalid variable in template (in expression.c and backend\evalu8.c)
120. Bugzilla 9791: [ICE] (struct.c line 668) map with a missing tuple import
121. Bugzilla 9818: Constant folding for static array does not work with initializing by element
122. Bugzilla 9829: rdmd passes '--' to dmd
123. Bugzilla 9837: IFTI should consider enum base type
124. Bugzilla 9844: DMD (-m64) int long initialisation bug
125. Bugzilla 9845: enum value should be able to contain forward references in global scope
126. Bugzilla 9863: Incorrect generation of SAHF instruction on 64 bits
127. Bugzilla 9873: Built-in tuple should support equality comparison
128. Bugzilla 9874: Function call syntax disuniformity in template constraints
129. Bugzilla 9880: Redundant template instance displaying in error message
130. Bugzilla 9883: Error on using property as new dynamic array size
131. Bugzilla 9885: IFTI should consider known tuple types.
132. Bugzilla 9892: [ICE] forward reference in enum declaration members causes compiler segfault
133. Bugzilla 9899: struct with pure/nothrow destructor cannot be used as a struct member in pure/nothrow functions
134. Bugzilla 9901: string return from inner template function error
135. Bugzilla 9907: Struct literal with destructor should match to non-ref overload
136. Bugzilla 9910: Scalar op vector is broken.
137. Bugzilla 9928: ice with void* and function literal
138. Bugzilla 9936: Wrong opBinary/opBinaryRight rewrite.
139. Bugzilla 9939: allMembers trait doesn't returns members of nested anonymous enum
140. Bugzilla 9940: ICE applying getProtection to a functions obtained using getOverloads.
141. Bugzilla 9946: A UFCS disallowed in dynamic array allocation
142. Bugzilla 9961: Using UFCS properties suppress actual errors
143. Bugzilla 9965: Wrong Assembly For DIL, SIL Registers
144. Bugzilla 9971: eponymous function is not an lvalue
145. Bugzilla 9985: Postblit isn't called on local struct return
146. Bugzilla 9990: templates with function alias cause forward reference error
147. Bugzilla 9993: const ctor should be preferred than mutable for const obj creation
148. Bugzilla 9994: Built-in generated opAssign should call dtor on assignment
149. Bugzilla 10004: tuple comparison with side-effect should work
150. Bugzilla 10005: struct variable declaration and const-correctness
151. Bugzilla 10011: Wrong JSON "init" property output for class reference initializers
152. Bugzilla 10029: Update list of reserved version identifiers.
153. Bugzilla 10058: Inconsistent mangling between C++ and extern(C++).
154. Bugzilla 10059: export doesn't work for variable declarations
155. Bugzilla 10063: inout+pure results in ability to produce immutable reference to mutable data
156. Bugzilla 10066: Template opEquals sometimes obstructs struct compilation
157. Bugzilla 10102: @disable incompletely implemented
158. Bugzilla 10103: template mixin with property overloads
159. Bugzilla 10105: ICE when converting string literal to static char array in enum initializer
160. Bugzilla 10115: More @disabled holes
161. Bugzilla 10171: Unexpected error "cannot infer type from overloaded function symbol"
162. Bugzilla 10180: offsetof doesn't work through function call alias this

#### DMD Compiler enhancements

1. Bugzilla 3449: const and invariant struct members do not behave according to spec
2. Bugzilla 3502: Fix for dropped Mac OS X 10.5
3. Bugzilla 3673: inheritance + if clause = no go
4. Bugzilla 4528: Better error message for private abstract method
5. Bugzilla 5140: Add __FUNCTION__, __PRETTY_FUNCTION__, and __MODULE__
6. Bugzilla 6185: Include non-global functions when resolving UFCS
7. Bugzilla 6453: Allow multiple invariant per struct/class
8. Bugzilla 6809: IFTI should imply const where inout is present on args, but not on return type
9. Bugzilla 7444: Require [] for array copies too
10. Bugzilla 7511: attribute inference should work for template functions
11. Bugzilla 8220: invalid function call not detected during semantic analysis
12. Bugzilla 8669: TemplateThisParameter should change member function's qualifier
13. Bugzilla 8819: void static array should have init built-in propert
14. Bugzilla 8959: IsExpression should support syntax which has no Identifier in all cases
15. Bugzilla 9033: Remove __thread from the language
16. Bugzilla 9136: Add isNested trait
17. Bugzilla 9155: Ddoc: code section should strip leading spaces
18. Bugzilla 9170: CTFE: Allow reinterpret casts float <-> int
19. Bugzilla 9185: Add note about where -op is useful
20. Bugzilla 9574: Diagnostic for old use of 'alias this = that' should be informative
21. Bugzilla 9627: Not good enough error messages in some cases when using UFCS
22. Bugzilla 9635: Improved error message for failed access of array field properties from static method
23. Bugzilla 9676: Ddoc: Wrap deprecated declarations in a (DEPRECATED) macro
24. Bugzilla 9680: Include entry point location in "dmd -v -o-" output
25. Bugzilla 9723: Implement -main switch to inject a default main() function
26. Bugzilla 9726: Add minimum % coverage required for -cov testing
27. Bugzilla 9727: Documented unittest comment should appear before Example section
28. Bugzilla 9745: Allow non-thread local static variables to have their address taken in CTFE
29. Bugzilla 9778: RDMD: Support passing resource files to DMD
30. Bugzilla 9789: Ddoc for aliases should use new "alias x=y" syntax
31. Bugzilla 9866: movsxd not supported
32. Bugzilla 9920: [Optimizer] Use mul/imul for integer division by constant
33. Bugzilla 9941: [CTFE] Allow to store "newed" classes and structs in the data segment
34. Bugzilla 9943: Allow to return typeid from CTFE
35. Bugzilla 9963: Absurdly Inefficient Codegen For Adding Boolean Predicates
36. Bugzilla 9977: Function local templates should be allowed
37. Bugzilla 10030: Support '-l:' switch when passing default library to ld
38. Bugzilla 10077: add pragma(mangle, "...") to override symbol mangle.
39. Bugzilla 10109: add -transition compiler switch to aid in dealing with breaking changes
40. Bugzilla 10150: Prefix method 'this' qualifiers should be just ignored anytime
41. Bugzilla 10179: Tuple assignment should not cause "has no effect" error even if the length is zero

#### Phobos regressions

1. Bugzilla 9122: std.concurrency send() fails with multiple arrays
2. Bugzilla 9742: std.math.floor returns 0 for any value x > -1 and x < 0
3. Bugzilla 10122: Appender doesn't work with disabled default construction

#### Phobos bugs

1. Bugzilla 3795: Problem with phobos std.variant
2. Bugzilla 4729: std.algorithm: strange iota behaviour
3. Bugzilla 4798: std.algorithm.map unusable for ranges with const elements
4. Bugzilla 4955: struct dirent.d_type is not a mask
5. Bugzilla 5032: std.file.rename acts differently on Windows and Linux when the target file already exists.
6. Bugzilla 5201: std.string.indexOf and std.algorithm.indexOf return different things for narrow strings
7. Bugzilla 5310: Variant == const(Variant) doesn't compile
8. Bugzilla 5359: std.traits.isDelegate should work for types and expressions
9. Bugzilla 5360: calling rdmd from different folder
10. Bugzilla 5514: Erroneous documentation and lacking randomization for topN
11. Bugzilla 5658: Undocumented fields in std.typecons.Tuple
12. Bugzilla 5924: schwartzSort of Tuple!(char)[]
13. Bugzilla 8321: std.range.put doesn't work with RefCounted output range
14. Bugzilla 8613: std.typecons.Proxy cannot work with operator 'in'
15. Bugzilla 8655: bitfields and Typedef don't mix
16. Bugzilla 9164: Can't easily assign one Nullable to another
17. Bugzilla 9431: Tuple creation problem with array of array
18. Bugzilla 9456: decodeFront is inconsistent in whether it pops elements off of the range or not
19. Bugzilla 9512: std.regex: Incorrect parsing of hex sequences composed from capital letters.
20. Bugzilla 9553: SOCKET should be 64 bit wide on Win64
21. Bugzilla 9583: std.getopt.getopt does not consume options terminator "--" from args list, as docs claim
22. Bugzilla 9612: std.range.Cycle.opSlice tests on the bounds are missing
23. Bugzilla 9624: fullyQualifiedName fails for functions
24. Bugzilla 9648: Missing std.random import for std.algorithm.topN
25. Bugzilla 9753: std.string.translate precondition asserts
26. Bugzilla 9794: std.json cannot handle delete character
27. Bugzilla 9804: std.math.FloatingPointControl corrupts floating point state
28. Bugzilla 9812: std.conv.parse string fails on certain escape characters.
29. Bugzilla 9836: std.array.popFront does not work with alias this.
30. Bugzilla 9950: std.json should return empty string/array instead of null on empty input
31. Bugzilla 9956: hasElaborateAssign trait does not work with static arrays
32. Bugzilla 9979: Regex bug with \b and look-behind
33. Bugzilla 10116: stdio.File.byLine repeats last line forever, readln(ref C[],R) returns bad data
34. Bugzilla 10167: Wrong Document Comment on std.format.d(181)
35. Bugzilla 10182: std.bitmanip unit test has pointless/unused foreach loop

#### Phobos enhancements

1. Bugzilla 4787: std.algorithm.bisectRight()
2. Bugzilla 4921: Synopsis code in std.variant documentation throws an assertion error
3. Bugzilla 5013: std.typecons.Tuple should have constructor for static arrays
4. Bugzilla 5106: makeIndex should return SortedRange
5. Bugzilla 5226: indexOf() which takes a pred but no needle
6. Bugzilla 5401: std.socket updates and boost license
7. Bugzilla 5507: countUntil should take Ranges... instead of R2
8. Bugzilla 6224: Add an ownerTid property in std.concurrency
9. Bugzilla 6486: std.math.abs(BigInt)
10. Bugzilla 7405: std.algorithm.schwartzSort.release
11. Bugzilla 9260: getopt should allow setting booleans to false
12. Bugzilla 9265: Nullable fixed-sized array wrapper
13. Bugzilla 9625: assertNotThrown should print exception msg if no msg is provided
14. Bugzilla 9802: Add std.traits.{isNested,hasNested}.
15. Bugzilla 9814: Add std.traits.isNestedFunction
16. Bugzilla 9839: std.traits.Select should be able to select symbols
17. Bugzilla 9888: Allow passing a generator to std.random.uniform for enums

#### Druntime bugs

1. Bugzilla 4307: spawn()'ed thread doesn't terminate
2. Bugzilla 6024: Document that Windows 2000 SP4 is no longer supported
3. Bugzilla 10057: [2.063 beta] Module info overwritten in shared phobos.
4. Bugzilla 10081: Incorrect char array comparison

#### Optlink bugs

1. Bugzilla 6144: Unexpected OPTLINK Termination at EIP=00428DA3

#### Installer bugs

1. Bugzilla 9343: Problem installing dmd-2.061-0.fedora.x86_64.rpm on Fedora 18

#### Website bugs

1. Bugzilla 4847: std.algorithm.topN documentation
2. Bugzilla 9544: D logo image is broken on non-root-level pages
3. Bugzilla 9609: Ddoc tags for std.string.icmp seem wrong
4. Bugzilla 10036: missing core.atomic docs on dlang.org

Copyright © 1999-2017 by the D Language Foundation | Page generated by Ddoc on Thu Feb 16 13:39:49 2017