%i for integers

The code snippet showing "foreach" is only indented by 2 spaces instead of the customary 3.

the code sample above also introduced the if statement

the large example should use size_t instead of uint

if ( mid < value ) return binarySearch( input[i + 1 .. $] );

if ( mid < value ) return binarySearch( input[i + 1..$], value );

Add right after the loop:

    if (!currentParagraph.empty) addParagraph(currentParagraph, info);

Add this line after split:

words = filter!(a => !a.empty)(words).array();

Andrej Mitrovic

Patrick O'Brien

31

"Any and all of ‹decl-expr›, ‹expr₁› and ‹expr₂› can be missing;"

Array expansion explanation suggests in a[] == ++i the right-hand side expression will be evaluated for each individual assignment,but that's not the case.

d = finder(10);

assert(d[1, 3, 5, 7, 9]) == []);

Better written as:

assert(finder(10)([1, 3, 5, 7, 9]) == []);

industry-strength

industrial-strength

(?)

...should be followed by assert(t.b == 5);

MB imports MA. Then B's static class constructors run before A's.

MB imports MA. Then A's static class constructors run before B's.

"x <= y is the same as !(y > x)"

"The presence of at least one constructor disables all of the field-oriented constructors discussed above"

Field initialization with {} syntax was never discussed.

Add note about "adding" to alias after its definition. It was not entirely clear that an alias also covers overloads not yet defined at the time of the alias.

const was actually introduced by C++ circa 1983, and migrated to C as part of ANSI C. The book suggests it was the other way around.

underscoresToCamelCase does not compile on latest dmd (toupper unknown and unknown import), and is not runnable at compile time.

Variant opDispatch(string m, Args)(Args args...) {

should have the "..." in the variadic list:

Variant opDispatch(string m, Args...)(Args args) {

Variant(Dynamic, Variant[]) {

The "delegate" keyword is required, and the "..." must be present in the signature.

delegate Variant(Dynamic, Variant[]...) {

obj.addMethod(“sayHello”, Variant(Dynamic, Variant[]) { writeln(“Hello World!”); return Variant(); });

obj.addMethod(“sayHello”, delegate Variant(Dynamic self, Variant[] args…) { writeln(“Hello World!”); return Variant(); });

Better yet, the writeln call should be writeln(args[0]) and the invocation should be obj.printMsg("Hello, world!") to illustrate how parameter passing works.

Christopher Jordan-Squire