First, I have to say that it is wonderful that someone is taking a
serious look at this area again, and even better, you have come up with
a compiler patch to make it happen!
Some questions (assuming your patch or something like it gets into dmd):
Does this mean that I would be able to write this:
immutable(Foo)ref foo; // create a reference
foo = new immutable(Foo)(); // re-bind it (not sure about "new" syntax
for immutables)
Are there any other show-stopping syntax issues that are holding up
widespread adoption/rollout of const-correctness?
What do Walter and Andrei think?
Does anyone know what the plan is for rolling const-correctness
thoughout druntime and phobos (and shared/immutable in std.concurrency)?
Having to do casting all the time is a real drag. I for one would be
happy to help if help is needed.
On 06/12/10 11:21, Michel Fortin wrote:
After a recent discussion on this list about tail-const class
references, it became rather clear that someone interested would have
to implement the thing if we were to have it. So I did it. See
enhancement request 5325 for an explanation and a patch.
<http://d.puremagic.com/issues/show_bug.cgi?id=5325>
Let's hope Walter likes my patch.
In the tail-const thread, I proposed the challenge of making this code
work when an array of const object is passed as an argument:
T[] giveMeASortedArray(alias Predicate, T)(T[] t) {
// creating new array of the same length but with assignable
elements
auto copy = new Unqual!(typeof(t[0]))[t.length];
foreach (index, value; t)
copy[index] = value;
// sorting the copy
sort!(Predicate)(copy);
return copy;
}
Well, with the patch I made it now works!... irrespective of the type
attribute (const,immutable,shared,inout). The only modification
required to Phobos is to make to!string() compile when passed a
const(Object) because somehow 'sort' requires that.
Here is how the function is invoked:
void main() {
int*[] a = giveMeASortedArray!("a < b")(new int*[12]);
Object[] b = giveMeASortedArray!("a < b")(new Object[12]);
const(int*)[] c = giveMeASortedArray!("a < b")(new
const(int*)[12]);
const(Object)[] d = giveMeASortedArray!("cast(void*)a <
cast(void*)b")(new const(Object)[12]);
}
See the strange predicate for the const(Object) version? That's
because opCmp() in Object doesn't work with const.
Two minor modifications are required in Phobos to make the above
compile. First, to!string(const(Object)) needs an implementation
because somehow 'sort' requires it. Also template std.traits.isMutable
needed an adjustment so that swap()'s template constrains are satisfied.
--
Graham St Jack
