D (programming language)

The D programming language is an object-oriented, imperative, multi-paradigm system programming language. D language originated as a re-engineering of C++, and D's design goals try combining the performance of compiled languages with the safety and expressive power of modern dynamic languages. Native D code is commonly as fast as equivalent C++ code, while being shorter and memory-safe.

Examples

Example 1
This example program prints its command line arguments. The main function is the entry point of a D program, and args is an array of strings representing the command line arguments. A string in D is an array of characters, represented by char[] in D1, or immutable(char)[] in D2.

import std.stdio: writefln;

void main(string[] args)
{
    foreach (i, arg; args)
        writefln("args[%d] = '%s'", i, arg);
}

The foreach statement can iterate over any collection. In this case, it is producing a sequence of indexes (i) and values (arg) from the array args. The index i and the value arg have their types inferred from the type of the array args.

Example 2
The following shows several D capabilities and D design trade-offs in a very short program. It iterates the lines of a text file named words.txt that contains a different word on each line, and prints all the words that are anagrams of other words.

import std.stdio, std.algorithm, std.range, std.string;

void main()
{
    dstring[][dstring] signs2words;
    foreach(dchar[] w; lines(File("words.txt")))
    {
        w = w.chomp().toLower();
        immutable key = w.dup.sort().release().idup;
        signs2words[key] ~= w.idup;
    }

    foreach(words; signs2words)
        if(words.length > 1)
            writefln(words.join(" "));
}

 signs2words is a built-in associative array that maps dstring (32-bit / char) keys to arrays of dstrings. It is similar to defaultdict(list) in Python.
 lines(File()) yields lines lazily, with the newline. It has to then be copied with idup to obtain a string to be used for the associative array values (the idup property of arrays returns an immutable duplicate of the array, which is required since the dstring type is actually immutable(dchar)[]). Built-in associative arrays require immutable keys.
 The ~= operator appends a new dstring to the values of the associate dynamic array.
 toLower, join and chomp are string functions that D allows to use with a method syntax. The name of such functions is often very similar to Python string methods. The toLower converts a string to lower case, join(" ") joins an array of strings into a single string using a single space as separator, and chomp removes a newline from the end of the string if one is present.
 The sort is an std.algorithm function that sorts the array in place, creating a unique signature for words that are anagrams of each other. The release() method on the return value of sort() is handy to keep the code as a single expression.
 The second foreach iterates on the values of the associative array, it's able to infer the type of words.
 key is assigned to an immutable variable, its type is inferred.
 UTF-32 dchar[] is used instead of normal UTF-8 char[] otherwise sort() refuses to sort it. There are more efficient ways to write this program, that use just UTF-8.

References

Further reading
 
 
  (distributed under CC-BY-NC-SA license). This book provides a basic level introduction.

Other websites

Programming languages