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

Author: dkorpel

articles/cpptod.dd

@@ -495,6 +495,7 @@ $(H4 The D Way)
         Properties can be get and set using the normal field syntax,
         yet the get and set will invoke methods instead.
 
+$(RUNNABLE_EXAMPLE
 ------
 class Abc
 {
@@ -507,15 +508,13 @@ class Abc
   private:
     int myprop;
 }
-------
-
-        which is used as:
 
-------
 Abc a = new Abc;
 a.property = 3;
 int x = a.property;
+assert(x == 3);
 ------
+)
 
         Thus, in D a property is treated like it was a simple field name.
         A property can start out actually being a simple field name,
@@ -563,6 +562,8 @@ $(H4 The D Way)
         $(HTTPS dlang.org/spec/template.html#implicit_template_properties,
         Eponymous Templates) - promotion of single template members to the
         enclosing name space:
+
+$(RUNNABLE_EXAMPLE_COMPILE
 ------
 template factorial(int n)
 {
@@ -574,19 +575,26 @@ template factorial(int n : 1)
     enum factorial = 1;
 }
 
-void test()
+unittest
 {
+    import std.stdio;
     writeln(factorial!(4));  // prints 24
 }
 ------
+)
         The template blocks can be made shorter using
         $(HTTPS dlang.org/spec/template.html#variable-template,
         Enum Template) syntax:
+
+$(RUNNABLE_EXAMPLE_COMPILE
 ------
 enum factorial(int n) = n * .factorial!(n-1);
 
 enum factorial(int n : 1) = 1;
+
+static assert(factorial!(4) == 24);
 ------
+)
 
 <hr>$(COMMENT  -------------------------------------------- )
 
@@ -712,6 +720,7 @@ $(H4 The D Way)
         It compiles quickly, and gives a sensible compile time message
         if it fails.
 
+$(RUNNABLE_EXAMPLE
 ------
 import std.stdio;
 
@@ -739,6 +748,7 @@ int main()
     return 0;
 }
 ------
+)
 
 <hr>$(COMMENT  -------------------------------------------- )
 
@@ -784,6 +794,7 @@ $(H4 The D Way)
         can be done in D without resorting to template argument
         pattern matching:
 
+$(RUNNABLE_EXAMPLE_COMPILE
 ------
 template IsFunctionT(T)
 {
@@ -793,27 +804,30 @@ template IsFunctionT(T)
         const int IsFunctionT = 1;
 }
 
-void test()
+unittest
 {
     alias int fp(int);
 
-    assert(IsFunctionT!(fp) == 1);
+    static assert(IsFunctionT!(fp) == 1);
 }
 ------
+)
 
         The task of discovering if a type is a function doesn't need a
         template at all, nor does it need the subterfuge of attempting to
         create the invalid array of functions type.
         The $(ISEXPRESSION) expression can test it directly:
 
+$(RUNNABLE_EXAMPLE_COMPILE
 ------
-void test()
+unittest
 {
     alias int fp(int);
 
-    assert( is(fp == function) );
+    static assert( is(fp == function) );
 }
 ------
+)
 
 $(HR)
 
@@ -928,7 +942,7 @@ void main()
 
     auto d2 = gallery[0];
     d2.id = 1;
-    assert(d2.id == gallery[0].id, "neither ref nor pointer");
+    assert(d2.id != gallery[0].id); // d2 is neither ref nor pointer
 }
 ------
 )
@@ -937,6 +951,8 @@ void main()
 
 ------
     auto d2 = &gallery[0];
+    d2.id = 1;
+    assert(d2.id == gallery[0].id);
 ------
 
 )

articles/ctod.dd

@@ -325,6 +325,15 @@ array.length = array.length + 1;
 array[array.length - 1] = x;
 ----------------------------
 
+or simply:
+
+----------------------------
+int[] array;
+int x;
+array ~= x;
+----------------------------
+
+
 <hr>$(COMMENT  ============================================ )
 $(H2 $(LNAME2 strcat, String Concatenation))
 
@@ -628,6 +637,27 @@ void dostring(string s)
        to generate a fast lookup scheme for it, eliminating the bugs
        and time required in hand-coding one.
 
+       Another possibility of associating a string to a number is to
+       use an associative array.
+
+$(RUNNABLE_EXAMPLE_COMPILE
+----------------------------
+ulong[string] map = ["hello"    : 1616515,
+                     "goodbye"  : 42,
+                     "maybe"    : ulong.max
+                    ];
+unittest
+{
+    import std.stdio;
+    writeln("number is ", map["goodbye"]);
+    writeln(i"map contains $(map.length) elements");
+    writeln("map is ", map);
+}
+----------------------------
+)
+
+       Any type can be used as key or as value.
+
 <hr>$(COMMENT  ============================================ )
 $(H2 $(LNAME2 align, Setting struct member alignment))
 

book/d.en/is_expr.d

@@ -344,7 +344,7 @@ The following function template uses different specifiers with this syntax of th
 ---
 void myFunction(T)(T parameter) {
     static if (is (T LocalAlias == struct)) {
-        writefln("\n--- struct ---");
+        writefln("\n-- struct --");
         // LocalAlias is the same as T. 'parameter' is the
         // struct object that has been passed to this
         // function.
@@ -355,7 +355,7 @@ void myFunction(T)(T parameter) {
     }
 
     static if (is (T baseTypes == super)) {
-        writeln("\n--- super ---");
+        writeln("\n-- super --");
         // The 'baseTypes' tuple contains all of the base
         // types of T. 'parameter' is the class variable that
         // has been passed to this function.
@@ -368,7 +368,7 @@ void myFunction(T)(T parameter) {
     }
 
     static if (is (T ImplT == enum)) {
-        writeln("\n--- enum ---");
+        writeln("\n-- enum --");
         // 'ImplT' is the actual implementation type of this
         //  enum type. 'parameter' is the enum value that has
         //  been passed to this function.
@@ -378,7 +378,7 @@ void myFunction(T)(T parameter) {
     }
 
     static if (is (T ReturnT == return)) {
-        writeln("\n--- return ---");
+        writeln("\n-- return --");
         // 'ReturnT' is the return type of the function
         // pointer that has been passed to this function.
 
@@ -418,18 +418,18 @@ The output:
 )
 
 $(SHELL_SMALL
---- struct ---
+-- struct --
 Constructing a new Point object by copying it.
 
---- super ---
+-- super --
 class AlarmClock has 2 base types.
 All of the bases: (Object, Clock)
 The topmost base: Object
 
---- enum ---
+-- enum --
 The implementation type of enum WeekDays is int
 
---- return ---
+-- return --
 This is a function with a return type of char:
     char function(double d, int i, Clock c)
 calling it... and the result is 'a'
@@ -497,7 +497,7 @@ The following program tests that $(C is) expression with four different types:
 import std.stdio;
 
 void myFunction(T)(T parameter) {
-    writefln("\n--- Called with %s ---", T.stringof);
+    writefln("\n-- Called with %s --", T.stringof);
 
     static if (is (T == Value[Key],
                    Value,
@@ -533,20 +533,20 @@ The condition is satisfied only if the key type is $(C string):
 )
 
 $(SHELL_SMALL
---- Called with int ---
+-- Called with int --
 No, the condition has not been satisfied.
 
---- Called with int[string] ---
+-- Called with int[string] --
 Yes, the condition has been satisfied.
 The value type: int
 The key type  : string
 
---- Called with double[string] ---
+-- Called with double[string] --
 Yes, the condition has been satisfied.
 The value type: double
 The key type  : string
 
---- Called with dchar[long] ---
+-- Called with dchar[long] --
 No, the condition has not been satisfied.
 )
 

book/d.en/literals.d

@@ -78,7 +78,7 @@ To see this logic in action, let's try the following program that takes advantag
 import std.stdio;
 
 void main() {
-    writeln("\n--- these are written in decimal ---");
+    writeln("\n-- these are written in decimal --");
 
     // fits an int, so the type is int
     writeln(       2_147_483_647, "\t\t",
@@ -88,7 +88,7 @@ void main() {
     writeln(       2_147_483_648, "\t\t",
             typeof(2_147_483_648).stringof);
 
-    writeln("\n--- these are NOT written in decimal ---");
+    writeln("\n-- these are NOT written in decimal --");
 
     // fits an int, so the type is int
     writeln(       0x7FFF_FFFF, "\t\t",
@@ -113,11 +113,11 @@ The output:
 )
 
 $(SHELL
---- these are written in decimal ---
+-- these are written in decimal --
 2147483647		int
 2147483648		long
 
---- these are NOT written in decimal ---
+-- these are NOT written in decimal --
 2147483647		int
 2147483648		uint
 4294967296		long

book/d.en/switch_case.d

@@ -123,7 +123,7 @@ import std.stdio;
 
 void main() {
     foreach (value; [ 1, 2, 3, 10, 20 ]) {
-        writefln("--- value: %s ---", value);
+        writefln("-- value: %s --", value);
 
         switch (value) {
 
@@ -156,19 +156,19 @@ The output:
 )
 
 $(SHELL
---- value: 1 ---
+-- value: 1 --
 case 1
 case 2
 case 10
---- value: 2 ---
+-- value: 2 --
 case 2
 case 10
---- value: 3 ---
+-- value: 3 --
 case 3
 default
---- value: 10 ---
+-- value: 10 --
 case 10
---- value: 20 ---
+-- value: 20 --
 default
 )