Editing Generic programming (section)

====Templates in D====
The [[D (programming language)|D]] language supports templates based in design on C++. Most C++ template idioms work in D without alteration, but D adds some functionality:
* Template parameters in D are not restricted to just types and primitive values (as it was in C++ before C++20), but also allow arbitrary compile-time values (such as strings and struct literals), and aliases to arbitrary identifiers, including other templates or template instantiations.
* Template constraints and the <code>static if</code> statement provide an alternative to respectively C++'s [[C++ concepts]] and <code>if constexpr</code>.
* The <code>is(...)</code> expression allows speculative instantiation to verify an object's traits at compile time.
* The <code>auto</code> keyword and the <code>[[typeof]]</code> expression allow [[type inference]] for variable declarations and function return values, which in turn allows "Voldemort types" (types that do not have a global name).<ref>{{cite web |last=Bright |first=Walter |title=Voldemort Types in D |url =https://www.drdobbs.com/cpp/voldemort-types-in-d/232901591 |website=Dr. Dobbs |access-date=3 June 2015}}</ref>

Templates in D use a different syntax than in C++: whereas in C++ template parameters are wrapped in angular brackets (<code>Template<param1, param2></code>),
D uses an exclamation sign and parentheses: <code>Template!(param1, param2)</code>.
This avoids the [[Template (C++)#Advantages and disadvantages|C++ parsing difficulties]] due to ambiguity with comparison operators.
If there is only one parameter, the parentheses can be omitted.

Conventionally, D combines the above features to provide [[compile-time polymorphism]] using trait-based generic programming.
For example, an input [[Range (computer programming)#Range as an alternative to iterator|range]] is defined as any type that satisfies the checks performed by <code>isInputRange</code>, which is defined as follows:

<syntaxhighlight lang="d">
template isInputRange(R)
{
    enum bool isInputRange = is(typeof(
    (inout int = 0)
    {
        R r = R.init;     // can define a range object
        if (r.empty) {}   // can test for empty
        r.popFront();     // can invoke popFront()
        auto h = r.front; // can get the front of the range
    }));
}
</syntaxhighlight>

A function that accepts only input ranges can then use the above template in a template constraint:

<syntaxhighlight lang="d">
auto fun(Range)(Range range)
    if (isInputRange!Range)
{
    // ...
}
</syntaxhighlight>

=====Code generation=====
In addition to template metaprogramming, D also provides several features to enable compile-time code generation:
* The <code>import</code> expression allows reading a file from disk and using its contents as a string expression.
* Compile-time reflection allows enumerating and inspecting declarations and their members during compiling.
* User-defined [[Attribute (computing)|attributes]] allow users to attach arbitrary identifiers to declarations, which can then be enumerated using compile-time reflection.
* [[Compile-time function execution]] (CTFE) allows a subset of D (restricted to safe operations) to be interpreted during compiling.
* String mixins allow evaluating and compiling the contents of a string expression as D code that becomes part of the program.

Combining the above allows generating code based on existing declarations.
For example, D serialization frameworks can enumerate a type's members and generate specialized functions for each serialized type
to perform serialization and deserialization.
User-defined attributes could further indicate serialization rules.

The <code>import</code> expression and compile-time function execution also allow efficiently implementing [[domain-specific language]]s.
For example, given a function that takes a string containing an HTML template and returns equivalent D source code, it is possible to use it in the following way:

<syntaxhighlight lang="d">
// Import the contents of example.htt as a string manifest constant.
enum htmlTemplate = import("example.htt");

// Transpile the HTML template to D code.
enum htmlDCode = htmlTemplateToD(htmlTemplate);

// Paste the contents of htmlDCode as D code.
mixin(htmlDCode);
</syntaxhighlight>