Programming with the D programming language
Added 'deprecated' that helps with deprecation process of library features, 'extern' that is for declaring external symbols, and 'extern()' that allows interacting with libraries of other languages (extern(C), extern(C++, std), etc.).
You can download most of the code samples that appear in the book as a .zip file.
The index section of the book.
Cooperative multitasking in D with fibers.
Pragmas that allow interactions with the compiler, including the most recent pragma(inline).
The rules that specify the execution order of chained operators and the expressions that they use.
"Instead of falling for getting things done quickly, 'Programming in D' focuses on getting things done properly, to the lasting benefit of its reader."
The .offsetof property to get the offsets of and the align attribute to specify the alignments of struct members.
Inheriting 'in' and 'out' blocks of interface and class functions.
__MODULE__, __FILE__, __LINE__, __FUNCTION__, and __PRETTY_FUNCTION__
The pragma directive
Defining functions, structs, and classes inside existing scopes.
Lvalues, rvalues, their differences, and 'auto ref' parameter type that can accept either kind.
Automatically generated index section for the PDF version of the book.
The attributes of the Throwable interface, collateral exceptions, and an example of accessing collateral exceptions through the .next property.
The @disable attribute to disable special functions of structs.
Assigning user defined attributes to type and variable declarations, testing the attributes at compile time, and compiling the program according to those attributes.
Using type traits in conditional compilation.
Multi-threaded programming in D by data sharing.
Useful range templates of the std.range module. Providing range capabilities depending on the capabilities on dependent ranges.
Template and string mixins that allow inserting compile-time generated code into the source code.
More features of D functions: auto, ref, auto ref, and inout return attributes; pure and nothrow behavioral attributes; and @safe, @trusted, and @system memory safety attributes.
Tuples, which combine values of different types and make them available similar to struct objects, and TypeTuple, which represents the concept of 'list of values' as seen in parameter lists, template argument lists, and array literal initialization lists.
The code examples in the Ranges chapter are made const-correct and they take advantage of UFCS.
Labels that give names to code lines and the goto statement that make program execution go to a label.
Sharing the same memory area for multiple members.
Providing foreach support for structs and classes.
Function pointers and delegates allow storing how the program should behave at a later time. Lambdas (anonymous function or function literals) make code more readable and reduce boilerplate code.
is expression, one of the most powerful compile-time features of the D programming language.
The D features that enable manipulating data bit-by-bit.
Pointers are variables that provide access to other variables. They are low-level capabilities of the microprocessor.
'alias this' enables automatic type conversions of user-defined types.
'alias' assigns aliases to existing names
Properties allow using member functions like member variables.
UFCS enables the member function syntax even for regular functions.
Preserving class invariants by limiting access to class members.
'destroy()' to call destructors explicitly and 'scoped()' to destroy objects automatically.
The 'interface' keyword to define class interfaces.
The Object class that is at the top of class hierarchies and its member functions toString(), opEquals(), opCmp(), and toHash().
Inheriting the members of existing classes.
The 'class' feature of the D programming language, which supports the object oriented programming (OOP) paradigm.
Defining the behaviors of operators for structs to allow their uses as convenient as the fundamental types.
Receiving LinkTerminated and OwnerTerminated exceptions as messages.
Explain the parameters of the functions of the std.parallelism module: Work unit size and buffer size.
The consequences of marking function parameters const or immutable.
Marking parameters as 'const ref' and member functions as 'const' in order to be able to use them with immutable variables as well.
Defining functions that are closely related to a struct inside the curly brackets of that struct definition.
The function overloading feature that enables defining multiple functions having the same name.
Default parameter values and variadic functions.
The 'struct' feature for defining higher-level concepts as user-defined types.