BIg semantic issues with SList & DList

[monarch_dodra]

On Thursday, 13 September 2012 at 19:37:41 UTC, monarch_dodra 
wrote:
> On Wednesday, 12 September 2012 at 17:24:57 UTC, monarch_dodra
> wrote:
>> [SNIP]
> [SNIP]

I'll just copy paste here the 3 headers which contain examples, 
to give a quicker idea of what I went for:

111 CHAIN IMPLEMENTATION 111
/**
    Implements a doubly-linked list.

    $(D DList) uses neither reference nor value semantics. They 
can be seen as
    several different handles into an external chain of nodes. 
Several different
    $(D DList)s can all reference different points in a same chain.

    $(D DList.Range) is, for all intents and purposes, a DList 
with range
    semantics. The $(D DList.Range) has a view directly into the 
chain itself.
    It is not tied to its parent $(D DList), and may be used to 
operate on
    other lists (that point to the same chain).

    The ONLY operation that can invalidate a $(D DList) or $(D 
DList.Range), but
    which will invalidate BOTH, is the $(D remove) operation, if 
the cut Range
    overlaps with the boundaries of another DList or DList.Range.

    Example:
----
auto a = DList!int([3, 4]); //Create a new chain
auto b = a; //Point to the same chain
// (3 - 4)
assert(a[].equal([3, 4]));
assert(b[].equal([3, 4]));

b.stableInsertFront(1); //insert before of b
b.stableInsertBack(5);  //insert after of b
// (2 - (3 - 4) - 5)
assert(a[].equal([3, 4])); //a is not changed
assert(b[].equal([1, 3, 4, 5])); // but a is

a.stableInsertFront(2); //insert in front of a, this will insert 
"inside" the chain
// (1 - (2 - 3 - 4) - 5)
assert(a[].equal([2, 3, 4])); //a is modified
assert(b[].equal([1, 2, 3, 4, 5])); //and so is b;

a.remove(a[]); //remove all the elements of a;
// (1 - 5)
assert(a[].empty); //a is empty
assert(b[].equal([1, 5])); //b has lost some of its elements;

a.insert(2); //insert in a. This will create a new chain
// (2)
// (1 - 5)
assert(a[].equal([2])); //a is empty
assert(b[].equal([1, 5])); //b has lost some of its elements;
----
  */

222 HYBRID REFERENCE IMPLEMENATION 222
/**
    Implements a doubly-linked list.

    $(D DList) use reference semantics. They give a view into a 
bidirectional
    chain of nodes.

    $(D DList.Range) can be used to have $(D BidirectionalRange) 
view of the
    chain of nodes. $(D DList.Ranges) are almost never 
invalidated, but they
    may have access to nodes that are past the end of original $(D 
DList)'s,
    if that $(D DList) was shortened.

    Example:
----
auto a = DList!int([1, 2, 3]); //Create a new DList
auto b = a; //A reference to that DList
auto r = a[]; //A range view of the list

a.removeFront();
a.removeBack();
assert(a[].equal([2])); // both a and b have been affected
assert(b[].equal([2])); // both a and b have been affected
assert(r.equal([1, 2, 3])); //But the range remains unchanged

a.insertFront(1);
assert(a[].equal([1, 2])); // both a and b have been affected
assert(b[].equal([1, 2])); // both a and b have been affected
assert(r.equal([1, 1, 2, 3])); //But so has the range

auto c = a; //Create a third reference
a.clear();  //Detaches from the chain
assert(a[].empty); //a is now empty
assert(b[].equal([1, 2])); //But a and b are unchanged
assert(c[].equal([1, 2])); //But a and b are unchanged
assert(r.equal([1, 1, 2, 3]));

b.remove(b[]); //Do a hard removal of the actual elements
assert(b[].empty); //b is empty of course
assert(c[].empty); //but so is c
assert(r.equal([1, 3])); //and the range has lost an element: It 
was removed from the chain

b.insert(1); //Insert an element into b
assert(a[].empty); //a remains unchanged
assert(b[].equal([1])); //b has the new element
assert(c[].equal([1])); //and so does c
assert(r.equal([1, 3])); //r points to the old chain, so does not 
see this new element
----
  */

333 CLASSIC IMPLEMENTATION 333
/**
    Implements a doubly-linked list.

    $(D DList) use reference semantics.

    $(D DList.Range) may be used to have a $(D BidirectionalRange) 
view into
    the DList.

    Example:
----
auto a = DList!int([1, 2, 3]); //Create a new DList
auto b = a; //A reference to that DList

a.removeFront();
a.removeBack();
assert(a[].equal([2])); // both a and b have been affected
assert(b[].equal([2])); // both a and b have been affected

a.insertFront(1);
assert(a[].equal([1, 2])); // both a and b have been affected
assert(b[].equal([1, 2])); // both a and b have been affected

auto c = a; //Create a third reference
a.clear();  //Detaches from the chain
assert(a[].empty); //a is now empty
assert(b[].equal([1, 2])); //But a and b are unchanged
assert(c[].equal([1, 2])); //But a and b are unchanged

b.remove(b[]); //Do a hard removal of the actual elements
assert(b[].empty); //b is empty of course
assert(c[].empty); //but so is c

b.insert(1); //Insert an element into b
assert(a[].empty); //a remains unchanged
assert(b[].equal([1])); //b has the new element
assert(c[].equal([1])); //and so does c
----
  */
/*
There is not much to show here actually: Ranges are *immediatly* 
invalidated, and attempt to use an invalid range will assert 
pretty quickly.
  */