How to use pure in D 2.0

Question

While playing around with D 2.0 I found the following problem:

Example 1:

pure string[] run1()
{
   string[] msg;
   msg ~= "Test";
   msg ~= "this.";
   return msg;
}

This compiles and works as expected.

When I try to wrap the string array in a class I find I can not get this to work:

class TestPure
{
    string[] msg;
    void addMsg( string s )
    {
       msg ~= s;
    }
};

pure TestPure run2()
{
   TestPure t = new TestPure();
   t.addMsg("Test");
   t.addMsg("this.");
   return t;
}

This code will not compile because the addMsg function is impure. I can not make that function pure since it alters the TestPure object. Am i missing something? Or is this a limitation?

The following does compile:

pure TestPure run3()
{
    TestPure t = new TestPure();
    t.msg ~= "Test";
    t.msg ~= "this.";
    return t;
}

Would the ~= operator not been implemented as a impure function of the msg array? How come the compiler does not complain about that in the run1 function?

Answer 1

Hi,

Please review the definition of pure functions:

• http://en.wikipedia.org/wiki/Pure_function
• http://www.digitalmars.com/d/2.0/function.html#pure-functions

Pure functions are functions that produce the same result for the same arguments. To that end, a pure function:

• has parameters that are all invariant or are implicitly convertible to invariant
• does not read or write any global mutable state

One of the effects of using pure functions is that they can be safely parallelized. However, it's not safe to execute several instances of your function in parallel, because they could both modify the class instance simultaneously, causing a synchronization problem.

Answer 2

Just a hunch, but this function doesn't always return the same result.

See, it returns a reference to some object, and while the object will always contain the same data, the objects returned by several calls to the same functions are not identical; that is, they don't have the same memory address.

When you return a reference to the object, you're essentially returning a memory address, which is going to be different across several calls.

Another way to think of it, part of the return value is the memory address of an object, which is dependent on some global state(s), and if the output of a function depends on global state, then it's not pure. Hell, it doesn't even have to depend on it; as long as a function reads a global state, then it's not pure. By calling "new", you are reading global state.

Answer 3

I think that your code is conceptually correct. However you may have found case where the compiler's semantic analysis is not as good as your brain's.

Consider the case where the class's source is not available. In that cases the compiler would have no way of telling that addMsg only modifies member variable so it can't allow you to call it from a pure function.

To allow it in your case, it would have to have special case handling for this type of usage. Every special case rule added makes the language more complicated (or, if left undocumented, makes it less portable)

Answer 4

Others have already pointed out that addMsg is not pure and cannot be pure because it mutates the state of the object.

The only way to make it pure is to encapsulate the changes you're making. The easiest way to do this is via return mutation, and there are two ways to implement this.

Firstly, you could do it like this:

class TestPure
{
    string[] msg;
    pure TestPure addMsg(string s)
    {
        auto r = new TestPure;
        r.msg = this.msg.dup;
        r.msg ~= s;
        return r;
    }
}

You need to copy the previous array because inside a pure function, the this reference is actually const. Note that you could do the copy better by allocating a new array of the final size and then copying the elements in yourself. You would use this function like so:

pure TestPure run3()
{
    auto t = new TestPure;
    t = t.addMsg("Test");
    t = t.addMsg("this.");
    return t;
}

This way, the mutation is confined to each pure function with changes passed out via return values.

An alternate way of writing TestPure would be to make the members const and do all the mutation before passing it to the constructor:

class TestPure
{
    const(string[]) msg;
    this()
    {
        msg = null;
    }
    this(const(string[]) msg)
    {
        this.msg = msg;
    }
    pure TestPure addMsg(string s)
    {
        return new TestPure(this.msg ~ s);
    }
}

Hope that helps.