How to make a unique copy in a generic manner?

[Tommi]

How do you make a (deep) copy of a variable of any type? For 
example the following attempt at a generic next function doesn't 
work, because it modifies its argument if the argument is a 
reference type.

T next(T)(in T value)
    if (is(typeof(++[T.init][0]) == T))
{
    auto copy = cast(T) value;
    ++copy;
    return copy;
}
// For example, the following code outputs:
// 0
// 0
// 0
// 1

enum MyEnum
{
    first,
    second
}

struct MyStruct
{
    int m_value;
        
    ref MyStruct opUnary(string op)()
        if (op == "++")
    {
        ++m_value;
        return this;
    }
}

class MyClass
{
    int m_value;
        
    this(int value)
    {
        m_value = value;
    }
        
    ref MyClass opUnary(string op)()
        if (op == "++")
    {
        ++m_value;
        return this;
    }
}

void main(string[] args)
{
    auto intZero = 0;
    next(intZero);

    auto enumZero = MyEnum.first;
    next(enumZero);
        
    auto structZero = MyStruct(0);
    next(structZero);
        
    auto classZero = new MyClass(0);
    next(classZero);
        
    writeln(intZero);
    writeln(cast(int) enumZero);
    writeln(structZero.m_value);
    writeln(classZero.m_value);

    stdin.readln();
}