Merge remote-tracking branch 'upstream/master' into stable

Author: MartinNowak

.htaccess

@@ -224,3 +224,11 @@ Redirect 301 /dips/1031 https://github.com/dlang/DIPs/tree/master/DIPs/other/DIP
 Redirect 301 /dips/1032 https://github.com/dlang/DIPs/tree/master/DIPs/other/DIP1032.md
 Redirect 301 /dips/1033 https://github.com/dlang/DIPs/tree/master/DIPs/other/DIP1033.md
 Redirect 301 /dips/1034 https://github.com/dlang/DIPs/tree/master/DIPs/accepted/DIP1034.md
+Redirect 301 /dips/1035 https://github.com/dlang/DIPs/blob/master/DIPs/DIP1035.md
+Redirect 301 /dips/1036 https://github.com/dlang/DIPs/blob/master/DIPs/other/DIP1036.md
+Redirect 301 /dips/1037 https://github.com/dlang/DIPs/blob/master/DIPs/DIP1037.md
+Redirect 301 /dips/1038 https://github.com/dlang/DIPs/blob/master/DIPs/accepted/DIP1038.md
+Redirect 301 /dips/1039 https://github.com/dlang/DIPs/blob/master/DIPs/other/DIP1039.md
+Redirect 301 /dips/1040 https://github.com/dlang/DIPs/blob/master/DIPs/DIP1040.md
+Redirect 301 /dips/1041 https://github.com/dlang/DIPs/blob/master/DIPs/other/DIP1041.md
+Redirect 301 /dips/1042 https://github.com/dlang/DIPs/blob/master/DIPs/DIP1042.md

CODEOWNERS

@@ -10,7 +10,7 @@
 # when someone opens a pull request that modifies code that they own.
 # Later matches take precedence.
 
-spec/* @andralex @WalterBright
+spec/* @andralex @WalterBright @maxhaton @mdparker
 foundation.dd @andralex @acehreli @WalterBright
 
 posix.mak @andralex @CyberShadow @MartinNowak @wilzbach

articles/ctarguments.dd

@@ -36,22 +36,24 @@ $(HEADERNAV_TOC)
     ---
     template Variadic(T...)
     {
-        static assert (T.length > 1);
+        static assert(T.length > 1);
         pragma(msg, T[0]);
         pragma(msg, T[1]);
     }
 
     alias dummy = Variadic!(int, 42);
-    // prints during compilation:
-    // int
-    // 42
     ---
+    $(P Output during compilation:)
+$(CONSOLE
+int
+42
+)
 
     $(H2 $(LNAME2 AliasSeq, AliasSeq))
 
     $(P The language itself does not provide any means to define such sequences outside of
         a template parameter declaration. Instead, there is a
-        $(MREF_ALTTEXT simple utility, std, meta) provided by the standard
+        $(REF_ALTTEXT simple template, AliasSeq, std,meta) provided by the standard
         library:
     )
 
@@ -79,7 +81,7 @@ $(H2 $(LNAME2 available-operations, Available operations))
 
         ---
         import std.meta;
-        static assert (AliasSeq!(1, 2, 3, 4).length == 4);
+        static assert(AliasSeq!(1, 2, 3, 4).length == 4);
         ---
 
     $(H3 $(LNAME2 indexing-slicing, Indexing and slicing))
@@ -88,13 +90,17 @@ $(H2 $(LNAME2 available-operations, Available operations))
 
         ---
         import std.meta;
-        alias Numbers = AliasSeq!(1, 2, 3, 4);
-        static assert (Numbers[1] == 2);
-        alias SubNumbers = Numbers[1 .. $];
-        static assert (SubNumbers[0] == 2);
+
+        alias nums = AliasSeq!(1, 2, 3, 4);
+        static assert(nums[1] == 2);
+
+        // slice last 3 elements
+        alias tail = nums[1 .. $];
+        static assert(tail[0] == 2);
+        static assert(tail.length == 3);
         ---
 
-    $(H3 $(LNAME2 assignment, Assignment))
+    $(H4 $(LNAME2 assignment, Element assignment))
 
         $(P Works only if the sequence element is a symbol that refers to a mutable variable)
 
@@ -106,12 +112,12 @@ $(H2 $(LNAME2 available-operations, Available operations))
             int x;
             alias seq = AliasSeq!(10, x);
             seq[1] = 42;
-            assert (x == 42);
+            assert(x == 42);
             // seq[0] = 42; // won't compile, can't assign to a constant
         }
         ---
 
-    $(H3 $(LNAME2 loops, Loops))
+    $(H3 $(LNAME2 loops, `foreach`))
 
         $(P D's $(DDSUBLINK spec/statement, ForeachStatement, foreach statement) has special
             semantics when iterating over compile-time sequences. It repeats the body of the loop
@@ -132,13 +138,13 @@ $(H2 $(LNAME2 available-operations, Available operations))
                     pragma (msg, typeof(sym));
             }
         }
-
-        /* Prints:
-        int
-        string
-        void()
-        */
         ---
+        $(P Output during compilation:)
+$(CONSOLE
+int
+string
+void()
+)
 
         $(P $(B Note:) $(DDSUBLINK version, staticforeach, Static foreach)
         should be preferred in new code.)
@@ -182,9 +188,11 @@ $(H3 $(LNAME2 type-seq, Type sequences))
     import std.meta;
     alias Params = AliasSeq!(int, double, string);
     void foo(Params); // void foo(int, double, string);
+
+    foo(7, 6.5, "hi");
     ---
 
-$(H4 $(LNAME2 type-seq-instantiation, Type sequence instantiation))
+$(H3 $(LNAME2 type-seq-instantiation, Type sequence instantiation))
 
     $(P D supports a special variable declaration syntax where a type sequence acts as a type:)
 
@@ -211,7 +219,7 @@ $(H4 $(LNAME2 type-seq-instantiation, Type sequence instantiation))
     variables, known as an $(I lvalue sequence).)
 
     $(P $(DDSUBLINK spec/template, variadic-templates, Variadic template functions)
-    use a type sequence instance for a function parameter:)
+    use a type sequence instance to declare function parameters:)
 
     ---
     void foo(T...)(T args)
@@ -223,9 +231,6 @@ $(H4 $(LNAME2 type-seq-instantiation, Type sequence instantiation))
     }
     ---
 
-    $(P $(B Note:) $(REF Tuple, std, typecons) wraps a type sequence instance,
-    preventing auto-expansion, and allowing it to be returned from functions.)
-
 $(H3 $(LNAME2 value-seq, Value sequences))
 
     $(P It is possible to use a sequence of values of the same type to declare an array literal:)
@@ -248,20 +253,41 @@ $(H3 $(LNAME2 value-seq, Value sequences))
     swap(pair);
     assert(x == 7 && y == 3);
     ---
-    $(P As above, such sequences may use $(ALOCAL assignment, assignment).)
-
-$(H4 $(LNAME2 tupleof, Aggregate field sequences))
+    $(P As above, such sequences may use
+    $(ALOCAL assignment, element assignment).)
 
     $(P $(DDSUBLINK spec/class, class_properties, `.tupleof`) is a
     class/struct instance property that provides an lvalue sequence
     of each field.)
 
+    $(P A function cannot return a value sequence. Instead,
+    $(REF Tuple, std, typecons) can be used. It wraps an lvalue
+    sequence in a struct, preventing auto-expansion.)
+
 $(H3 $(LNAME2 symbol-seq, Symbol sequences))
 
 $(P A symbol sequence aliases any named symbol - types, variables, functions and templates -
 but not literals.
 Like an alias sequence, the kind of elements can be mixed.)
 
+---
+import std.meta : AliasSeq;
+
+void f(T)(T v)
+{
+    pragma(msg, T);
+}
+alias syms = AliasSeq!(f, f!byte);
+syms[0](42); // call f!int with IFTI
+syms[1](42); // call f!byte
+---
+$(P Output during compilation:)
+$(CONSOLE
+byte
+int
+)
+$(P Note that function `f!byte` is instantiated when the sequence is
+created, not at the call-site.)
 )
 
 Macros:

articles/ctod.dd

@@ -85,11 +85,11 @@ signed char        =>        byte
 unsigned char      =>        ubyte
 short              =>        short
 unsigned short     =>        ushort
-wchar_t            =>        wchar
+wchar_t            =>        core.stdc.stddef.wchar_t
 int                =>        int
 unsigned           =>        uint
-long               =>        int
-unsigned long      =>        uint
+long               =>        core.stdc.config.c_long
+unsigned long      =>        core.stdc.config.c_ulong
 long long          =>        long
 unsigned long long =>        ulong
 float              =>        float

articles/d-floating-point.dd

@@ -81,7 +81,7 @@ $(D nextDown(x)) gives the next representable number which is less than x.
 
 $(P Numerical analysts often describe errors in terms of "units in the last place"(ulp), a surprisingly subtle term which is often used rather carelessly. [footnote:
 The most formal definition is found in [J.-M. Muller, "On the definition of ulp(x)",INRIA Technical Report 5504 (2005).]: If $(D x) is a real number that lies between two finite consecutive floating-point numbers a and b of type F, without being equal to one of them, then ulp(x)=abs(b-a); otherwise ulp(x) = $(D x*F.epsilon). Moreover, ulp(NaN) is NaN, and ulp($(PLUSMN)F.infinity) = $(PLUSMN)$(D F.max*F.epsilon).]
-I prefer a far simpler definition: The difference in ulps between two numbers x and y is is the number of times which you need to call nextUp() or nextDown() to move from x to y. [Footnote: This will not be an integer if either x or y is a real number, rather than a floating point number.]
+I prefer a far simpler definition: The difference in ulps between two numbers x and y is the number of times which you need to call nextUp() or nextDown() to move from x to y. [Footnote: This will not be an integer if either x or y is a real number, rather than a floating point number.]
 The D library function $(D feqrel(x, y)) gives the number of bits which are equal between x and y; it is an easy way to check for loss-of-precision problems.
 )
 
@@ -176,7 +176,7 @@ $(TR $(TD max_10_exp) $(TD +38) $(TD +308) $(TD +4932) $(TD +4932) $(TD 385) $(T
 )
 
 $(P When writing code which should adapt to different CPUs at compile time, use $(D static if) with the $(D mant_dig) property. For example, $(D static if (real.mant_dig==64)) is true if 80-bit reals are available.
-For binary types, the $(D dig) property gives only the $(I minimum) number of valid decimal digits. To ensure that that every representable number has a unique decimal representation, two additional digits are required. Similarly, for decimal numbers, $(D mant_dig) is a lower bound on the number of valid binary digits.
+For binary types, the $(D dig) property gives only the $(I minimum) number of valid decimal digits. To ensure that every representable number has a unique decimal representation, two additional digits are required. Similarly, for decimal numbers, $(D mant_dig) is a lower bound on the number of valid binary digits.
 )
 
 $(H2 Useful relations for a floating point type $(D F), where $(D x) and $(D y) are of type $(D F))

articles/hijack.dd

@@ -130,7 +130,7 @@ to add the rules:
 $(OL
 $(LI by default functions can only overload against other functions in the same
 module)
-$(LI if a name is found in more than one scope, in order to use it it must
+$(LI if a name is found in more than one scope, in order to use it, it must
 be fully qualified)
 $(LI in order to overload functions from multiple modules together, an alias
 statement is used to merge the overloads)

articles/index.dd

@@ -104,7 +104,7 @@ $(D_S Articles,
                     in D.)
             )
             $(DIVC item,
-                $(H4 $(LINK2 $(ROOT_DIR)articles/mixin.html, Mixins))
+                $(H4 $(LINK2 $(ROOT_DIR)articles/mixin.html, String Mixins))
                 $(P A short article about D's $(D mixin) statement which allows
                     to insert arbitrary code from a string, and how it compares
                     to the C preprocessor.)

articles/lazy-evaluation.dd

@@ -249,12 +249,7 @@ if (!p)
 p.bar();    // now use p
 ---
 
-$(P Because throw is a statement, not an expression, expressions that
-need to do this need to be broken up into multiple statements,
-and extra variables are introduced.
-(For a thorough treatment of this issue, see Andrei Alexandrescu and
-Petru Marginean's paper
-$(LINK2 https://erdani.org/publications/cuj-06-2003.php.html, Enforcements)).
+$(P
 With lazy evaluation, this can all be encapsulated into a single
 function:
 )
@@ -312,4 +307,3 @@ Macros:
     SUBNAV=$(SUBNAV_ARTICLES)
 
     NG_digitalmars_D = <a href="http://www.digitalmars.com/pnews/read.php?server=news.digitalmars.com$(AMP)group=digitalmars.D$(AMP)artnum=$0">D/$0</a>
-

articles/mixin.dd

@@ -1,8 +1,8 @@
 Ddoc
 
-$(D_S Mixins,
+$(D_S String Mixins,
 
-        $(P Mixins (not to be confused with
+        $(P String Mixins (not to be confused with
         $(DDLINK spec/template-mixin, Template Mixins, template mixins))
         enable string constants to be compiled as regular D code
         and inserted into the program.
@@ -91,5 +91,5 @@ END
 )
 
 Macros:
-        TITLE=Mixins
+        TITLE=String Mixins
         SUBNAV=$(SUBNAV_ARTICLES)