Debug help - Programming in D - extending tail slice terminates sharing unexpectedly. Page 69, 70

[Kapendev]

On Sunday, 19 October 2025 at 20:44:39 UTC, Brother Bill wrote:
> But incrementing the length of tailSlice by 1 breaks sharing.
> This is unexpected.

This is not really unexpected.
It's easier to think about it if you treat slices as structs with 
2 members, a pointer and a length. The important member is the 
pointer.

```d
int[] slice = [1, 3, 5, 7, 9, 11, 13, 15];
```

Here you create a "struct" with a pointer provided by the GC. The 
GC keeps track of the amount of items this pointer is pointing 
to. It's not really important how it is tracked. The safest 
assumption a user can make in any language is that the pointer 
owns the memory.

```d
int[] tailSlice = slice[$ / 2 .. $];
```

Here you create a new "struct" whose pointer differs from 
`slice`. The layout of the data now looks like this:

```
`slice` pointer    : ...*########...
`tailSlice` pointer: .......*####...
```

The pointer of `tailSlice` doesn't own the memory. It's a view 
into the memory owned by the `slice` pointer.

```
tailSlice.length += 1;
```

You are now changing the length of struct `tailSlice`. There is 
really no good way to know if the pointer of `tailSlice` is an 
item of `slice` or if the last item of `tailSlice` is the last 
item of `slice`, so the GC will copy the data to a new memory 
block and append one new item.

That's kinda it. If you try to append or remove items in cases 
like this, you will probably get a new pointer. If you want to 
use a slice as a dynamic array, it's a good idea to pass it by 
`ref` or pointer. Hope this helps.