On 3/4/2015 12:13 AM, deadalnix wrote:
> The #1 argument for DIP25 compared to alternative proposal was its simplicity. I
> assume at this point that we have empirical evidence that this is NOT the case.

The complexity of a free list doesn't remotely compare to that of adding an ownership system.

Besides, we expect to provide sample code for how to do this that can be pretty much cut&pasted by people implementing their own RC types.

Walter Bright:

> The complexity of a free list doesn't remotely compare to that of adding an ownership system.

A sound complete ownership system is the only good enough solution for D. That's my opinion.

Bye,
bearophile

On Wednesday, 4 March 2015 at 09:16:22 UTC, bearophile wrote:
> Walter Bright:
>
>> The complexity of a free list doesn't remotely compare to that of adding an ownership system.
>
> A sound complete ownership system is the only good enough solution for D. That's my opinion.
>
> Bye,
> bearophile

+1

---
Paolo

On Wednesday, 4 March 2015 at 09:06:01 UTC, Walter Bright wrote:
> On 3/4/2015 12:13 AM, deadalnix wrote:
>> The #1 argument for DIP25 compared to alternative proposal was its simplicity. I
>> assume at this point that we have empirical evidence that this is NOT the case.
>
> The complexity of a free list doesn't remotely compare to that of adding an ownership system.
>

A free list does not work as the data can be live. You cannot reuse it to maintain the free list. You need to maintain metadata about allocation in another structure.

Also you cannot free anything until all the refcount are to 0. This RC system will only cut it for short lived entities.

On Wednesday, 4 March 2015 at 10:03:13 UTC, deadalnix wrote:
> On Wednesday, 4 March 2015 at 09:06:01 UTC, Walter Bright wrote:
>> On 3/4/2015 12:13 AM, deadalnix wrote:
>>> The #1 argument for DIP25 compared to alternative proposal was its simplicity. I
>>> assume at this point that we have empirical evidence that this is NOT the case.
>>
>> The complexity of a free list doesn't remotely compare to that of adding an ownership system.
>>
>
> A free list does not work as the data can be live. You cannot reuse it to maintain the free list. You need to maintain metadata about allocation in another structure.
>
> Also you cannot free anything until all the refcount are to 0. This RC system will only cut it for short lived entities.

And come on, DIP25, DIP69 and DIP74 to get there. Come on, that is not even simpler than the alternative.

On Wednesday, 4 March 2015 at 09:16:22 UTC, bearophile wrote:
> Walter Bright:
>
>> The complexity of a free list doesn't remotely compare to that of adding an ownership system.
>
> A sound complete ownership system is the only good enough solution for D. That's my opinion.
>
> Bye,
> bearophile

+1

On 3/4/2015 2:06 AM, deadalnix wrote:
> And come on, DIP25, DIP69 and DIP74 to get there. Come on, that is not even
> simpler than the alternative.

DIP69 has pretty much been abandoned.

On 3/4/2015 2:03 AM, deadalnix wrote:
> A free list does not work as the data can be live.

It is a "to free" list.

> You need to maintain metadata about allocation in
> another structure.

I don't see why.

> Also you cannot free anything until all the refcount are to 0.

Right.

> This RC system will only cut it for short lived entities.

Not a problem if they aren't constantly reassigning the value.

On 3/4/2015 1:16 AM, bearophile wrote:
> Walter Bright:
>> The complexity of a free list doesn't remotely compare to that of adding an
>> ownership system.
> A sound complete ownership system is the only good enough solution for D. That's
> my opinion.

How do you type an an array of pointers with different owners?

How do you deal with the combinatoric explosion of template instantiations with all those different ownership types?

On Wednesday, 4 March 2015 at 10:50:54 UTC, Walter Bright wrote:

> How do you type an an array of pointers with different owners?

You mean an array of pointers to objects with different owners? The array is the owner of the objects it points to. Or else it should be @trusted?

> How do you deal with the combinatoric explosion of template instantiations with all those different ownership types?

Type erasure.