Code sample fixes and additions, updated symbol names.

arrays.dd

@@ -800,7 +800,7 @@ try
 	array[i] = 5;
     }
 }
-catch (ArrayBoundsError)
+catch (RangeError)
 {
     // terminate loop
 }
@@ -1394,5 +1394,5 @@ Macros:
 	WIKI=Arrays
 	DOLLAR=$
 	FOO=
-	CATEGORY_SPEC=$0
-	DOLLAR=$
+	CATEGORY_SPEC=$0
+	DOLLAR=$

class.dd

@@ -385,7 +385,7 @@ A a = new A(3);
 $(OL
 	$(LI Storage is allocated for the object.
 	If this fails, rather than return $(B null), an 
-	$(B OutOfMemoryException) is thrown.
+	$(B OutOfMemoryError) is thrown.
 	Thus, tedious checks for null references are unnecessary.
 	)
 
@@ -1178,7 +1178,7 @@ $(SECTION3 <a name="ConstClass">Const, Immutable and Shared Classes</a>,
 Macros:
 	TITLE=Classes
 	WIKI=Class
-	CATEGORY_SPEC=$0
+	CATEGORY_SPEC=$0
 	GLINK=$(LINK2 #$0, $(I $0))
 	GNAME=<a name=$0>$(I $0)</a>
 	DOLLAR=$

const3.dd

@@ -317,25 +317,44 @@ $(SECTION2 Immutable Member Functions,
 
 ---
 struct S
-{   int x;
+{   
+    int x;
 
-    immutable void foo()
+    void foo() immutable
     {
-	x = 4;	    // error, x is immutable
-	this.x = 4; // error, x is immutable
+        x = 4;	    // error, x is immutable
+        this.x = 4; // error, x is immutable
     }
+}
 ---
+    $(P Note that using $(D_KEYWORD immutable) on the left hand side of a method does not apply to the return type:
+    )
 
-    $(P The $(D_KEYWORD const) and $(D_KEYWORD immutable) function
-    attributes
-    can also appear after the closing parenthesis of
-    the parameter list:
+---
+struct S
+{
+    immutable int[] bar()  // bar is still immutable, return type is not!
+    {
+    }
+}
+---
+    $(P To make the return type $(D_KEYWORD immutable), you need to surround the return type with parentheses:
     )
 
 ---
 struct S
 {
-    void bar() immutable
+    immutable(int[]) bar()  // bar is now mutable, return type is immutable.
+    {
+    }
+}
+---
+    $(P To make both the return type and the method $(D_KEYWORD immutable), you can write:
+    )
+---
+struct S
+{
+    immutable(int[]) bar() immutable
     {
     }
 }
@@ -566,7 +585,7 @@ Macros:
 	N=$(TD $(RED No))
 	TITLE=Const and Immutable
 	WIKI=ConstInvariant
-	CATEGORY_SPEC=$0
+	CATEGORY_SPEC=$0
 	NO=<td class="compNo">No</td>
 	NO1=<td class="compNo"><a href="$1">No</a></td>
 	YES=<td class="compYes">Yes</td>

dll.dd

@@ -35,7 +35,7 @@ $(D_S Writing Win32 DLLs in D,
 
 --------------------------------
 import std.c.windows.windows;
-import core.dll_helper;
+import core.sys.windows.dll;
 
 __gshared HINSTANCE g_hInst;
 
@@ -629,4 +629,4 @@ C:>
 Macros:
 	TITLE=Writing Win32 DLLs
 	WIKI=DLLs
-	CATEGORY_HOWTOS=$0
+	CATEGORY_HOWTOS=$0

expression.dd

@@ -1231,10 +1231,10 @@ void main()
 {
   // cast array literal
   const short[] ct = cast(short[]) [cast(byte)1, 1];
-  writeln(ct);  // writes [1 1]
+  writeln(ct);  // writes [1, 1]
 
   // cast other array expression
-  short[] rt = cast(short[]) [cast(byte)1, 1].dup;
+  short[] rt = cast(short[]) [cast(byte)1, cast(byte)1].dup;
   writeln(rt);  // writes [257]
 }
 ---
@@ -1931,7 +1931,7 @@ void main()
 Macros:
 	TITLE=Expressions
 	WIKI=Expression
-	CATEGORY_SPEC=$0
+	CATEGORY_SPEC=$0
 	GLINK=$(LINK2 #$0, $(I $0))
 	GNAME=<a name=$0>$(I $0)</a>
 	DOLLAR=$

function.dd

@@ -426,10 +426,10 @@ $(V2
 	same name in the base class, even if the types of the parameters
 	in the base class functions are different. If, through
 	implicit conversions to the base class, those other functions do
-	get called, an $(CODE std.HiddenFuncError) exception is raised:
+	get called, a $(CODE core.exception.HiddenFuncError) exception is raised:
 	)
 ---
-import std.hiddenfunc;
+import core.exception;
 
 class A
 {
@@ -442,15 +442,16 @@ class B : A
 }
 
 void foo(A a)
-{   int i;
+{   
+    int i;
     try
     {
         a.$(B set)(3);   // error, throws runtime exception since
                     // A.set(int) should not be available from B
     }
     catch ($(B HiddenFuncError) o)
     {
-	i = 1;
+        i = 1;
     }
     assert(i == 1);
 }
@@ -696,6 +697,11 @@ int foo(in int x, out int y, ref int z, int q);
 	The $(B in) storage class is equivalent to $(B const scope).
 	)
 
+    $(P
+    The $(B scope) storage class means that references in the parameter
+    cannot be escaped (e.g. assigned to a global variable).
+    )
+
 	$(P
 	If no storage class is specified, the parameter becomes a mutable
 	copy of its argument.
@@ -1071,12 +1077,12 @@ int sum(int[3] ar ...)
 class Foo
 {
     int x;
-    char[] s;
+    string s;
 
-    this(int x, char[] s)
+    this(int x, string s)
     {
-	this.x = x;
-	this.s = s;
+        this.x = x;
+        this.s = s;
     }
 }