On Sunday, 11 October 2015 at 20:56:28 UTC, Jonathan M Davis
wrote:
To be fair, you haven't really said much better. You're
claiming that it's clear that it's a failure, whereas Andrei is
saying that he doesn't see a problem with it. No concrete
arguments are being given. The closest is that you think that
the fact that we need something like DIP 74 means that DIP 25's
advantage of being simple is lost and that that somehow shows
that DIP 25 is a failure.
OK first thing first, that is not how that works. DIP25 has been
out for a while, so one should have something to show for it.
What good thing came out of DIP25 ? That should be what is
discussed here rather than having to argue why it is not good
enough.
See my other messages here to see what isn't good with it. It
simply isn't allowing enough to pay for itself.
I don't think that it's at all clear that DIP 25 and DIP 74 are
even particularly related (and Manu has stated the same).
They are the same thing. If you can guarantee that some reference
does not escape in uncontrollable manner, you can have ref
counting as library. The need for DIP74 only arise because DIP25
cannot ensure that the reference does not escape.
But I have no idea how an ownership model for memory in general
would work. I'd probably have a much better idea if I had read
up on Rust (which I really haven't), but every discussion I've
seen on Rust's model seems to indicate that it gets pretty
complicated - complicated enough that while it might be more
correct, it risks being unusable for the average programmer. I
don't know how true that is, but I do think that if we're going
to seriously discuss an ownership model in D, we need something
concrete discuss and debate. I know that writing a DIP takes
time (even a small one; it surprised me how long it took to
write DIP 82 given how simple it is, and I've written DIPs
before), but if we don't have something like that to discuss,
then we're just going to be going in circles here. If you have
a concrete proposal that you think would really benefit D, then
please write up a DIP for it. We could all be way better off
for it. Maybe it'll be rejected, but without it, we're
definitely not going to end up with some kind of ownership
model like you want. And if you're right, then we will be worse
off. Concrete proposals are required to have concrete
discussions and move forward.
- Jonathan M Davis
Yes, you should definitively read on Rust, or read this :
https://github.com/isocpp/CppCoreGuidelines/blob/09aef9bd86d933bc1e1ffe344eb2e73d2de15685/docs/Lifetimes%20I%20and%20II%20-%20v0.9.1.pdf
Which is basically C++ adopting the idea, but no, it doesn't come
from Rut, no, I tell you, C++ invented a long time ago, C++
invented everything, stop doubting us.
Things is, Rust has that one mechanism to do everything. As a
result it is fairly complex, because it has to handle all common
cases. We can do something fairly similar, yet simpler, if we
accept to rely on the GC or unsafe constructs for things that do
not fit well in the model.
