Re: Type polymorphism and type variance

[Ali Çehreli]

On 12/05/2012 04:28 AM, Lubos Pintes wrote:

> where is the value of concrete T?
> Or perhaps I completely misunderstood this?
Maybe I misunderstand you. :) Are you pointing out that the class 
template that I have shown did not have any member variables? If so, 
they can have anything they want.

I have changed the program to include different members and even 
specialization (for dchar):

import std.stdio;

/* This defines what I want to do with my objects: */
interface MyInterface
{
    void foo();

    /* This is just a silly function to demonstrate that copying an object
     * must be the responsibility of that object because we do not know the
     * concerete type at this level. */
    MyInterface dup();
}

/* A class template that implements the interface */
class myGtype(T)
    if (!is(T == dchar))
  : MyInterface
{
    /* Here is a concrete value: */
    T value;

    /* The implementation can be arbitrarily complex for different T: */
    static if (is (T == S)) {
        S[string] aa;
    }

    this(T value)
    {
        this.value = value;

        static if (is (T == S)) {
            aa["hello"] = value;
        }
    }

    void foo()
    {
        /* This demonstrates how operations that depend on T can be used
         * inside this class template.
         *
         * specialOperationFor() could alternatively be a member function
         * template but I find it simpler when it is a free-standing 
function.
         */
        specialOperationFor!T(value);
    }

    /* This one simply uses 'value'. It could do anything else. */
    myGtype dup()
    {
        return new myGtype(value);
    }
}

/* It is possible to implement a specialization of the type completely
 * separately: */
class myGtype(T)
    if (is(T == dchar))
    : MyInterface
{
    void foo()
    {
        writeln("Inside myGtype!dchar.foo");
    }

    myGtype dup()
    {
        return new myGtype();
    }
}

void specialOperationFor(T : double)(double d)
{
    writefln("Special operation for double: %s", d);
}

struct S
{
    int i;
}

void specialOperationFor(T : S)(S s)
{
    writefln("Special operation for S: %s", s);
}

void main()
{
    MyInterface[] objects;

    objects ~= new myGtype!double(1.5);
    objects ~= new myGtype!int(42);
    objects ~= new myGtype!S(S(100));
    objects ~= new myGtype!dchar();

    foreach (o; objects) {
        o.foo();
    }

    // We can even copy them and the copies have the correct types:
    foreach (i, o; objects) {
        auto c = o.dup();
        writefln("Using the copy of item %s", i);
        c.foo();
    }
}

Ali