Generics in D Programming Language

import std.stdio;
import std.algorithm;
import std.range;

// As an example of a generic function, `slicesIndex` takes
// a range of any type and an element of that type and returns
// the index of the first occurrence of v in s, or -1 if not present.
// The `T` type parameter is implicitly constrained to types that
// can be compared with `==`.
size_t slicesIndex(T)(T[] s, T v)
{
    return s.countUntil(v);
}

// As an example of a generic type, `List` is a
// singly-linked list with values of any type.
class List(T)
{
private:
    class Node
    {
        T value;
        Node next;
        this(T v) { value = v; }
    }

    Node head, tail;

public:
    void push(T v)
    {
        auto newNode = new Node(v);
        if (tail is null)
        {
            head = tail = newNode;
        }
        else
        {
            tail.next = newNode;
            tail = newNode;
        }
    }

    // AllElements returns all the List elements as an array.
    T[] allElements()
    {
        T[] result;
        for (Node current = head; current !is null; current = current.next)
        {
            result ~= current.value;
        }
        return result;
    }
}

void main()
{
    string[] s = ["foo", "bar", "zoo"];

    // When using generic functions in D, type inference is automatic.
    // We don't need to specify the type for `slicesIndex`.
    writeln("index of zoo: ", slicesIndex(s, "zoo"));

    // Create a List of integers
    auto lst = new List!int();
    lst.push(10);
    lst.push(13);
    lst.push(23);
    writeln("list: ", lst.allElements());
}

In D, generics are implemented using templates. The syntax is different from Go, but the concept is similar. Here are the key differences and adaptations:

Instead of using square brackets for type parameters, D uses parentheses.
D doesn’t have a comparable constraint like Go. Instead, it uses implicit constraints based on how the type is used in the function. In this case, the slicesIndex function implicitly requires that T can be compared with ==.
D’s standard library already provides a countUntil function that does what our slicesIndex function does, so we use that in the implementation.
D uses classes for reference types, so our List is implemented as a class rather than a struct.
D doesn’t have an exact equivalent to Go’s any type. In D, templates can be used with any type unless constraints are explicitly specified.
In D, we don’t need to specify type parameters when calling generic functions or constructing generic types if the compiler can infer the types.

When you run this program, you should see output similar to:

index of zoo: 2
list: [10, 13, 23]

This example demonstrates how D handles generics, which allows for writing flexible, reusable code that works with multiple types.

Struct Embedding in D Programming Language

Range Over Iterators in D Programming Language

Learn X By Example

Title here

Generics in D Programming Language