DIP74 - where is at?

[deadalnix via Digitalmars-d]

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.