Linked list, printing looks destructive.

[Alain De Vos]

On Monday, 25 April 2022 at 05:17:28 UTC, Salih Dincer wrote:
> On Monday, 25 April 2022 at 02:19:46 UTC, Ali Çehreli wrote:
>>
>> This type violates a fundamental rule: Containers and ranges 
>> are separate concepts. Your List is a container, not a range. 
>> I changed your code by moving the range functions to a Range 
>> [...]
>
> Dear Ali,
>
> I implemented a linkedlist over classical logic (*_leaf and 
> const *_root).  Now seeing the ranges approach I tried it but 
> without success. The following implementation can work with 
> foreach() though; as long as you call goRoot() :)
>
> ```d
> class List(dType) {
>   struct Node
>   {
>     dType item;
>     Node* next;
>   }
>   bool FIFO;
>   private Node * _leaf;
>
>   this(bool FIFO = true, dType item = dType.init) {
>     this.FIFO = FIFO;
>     if(FIFO) _leaf= new Node(item, null);
>     _root = cast(const)_leaf;
>   }
>
>   /*
>   auto opSlice() { return Range(_leaf); }
>   static struct Range {//*/
>     const Node * _root;
>
>     auto empty()
>     {
>       return !_leaf;
>     }
>
>     auto popFront()
>     {
>       return _leaf = _leaf.next;
>     }
>
>     dType front(Node * node = null)
>     {
>       dType result;
>       if(node)
>       {
>         result = (*node).item;
>       } else result = (*_leaf).item;
>
>       return result;
>     }
>   //}
>
>   alias Next = popFront;
>   alias pop = front;
>   alias push = InsertBack;
>
>   void InsertBack(dType item)
>   {
>     _leaf = new Node(item, _leaf);
>   }
>
>   void InsertFront(dType item)
>   {
>     (*_leaf).next = new Node(item, null);
>     Next;
>   }
>
>   auto goRoot()
>   {
>     return _leaf = cast(Node*)_root.next;
>   }
> }
>
> import std.stdio;
>
> enum FIFO { False, True }
> enum end = 20;
> void main()
> {
>   int firstNumber = 10;
>   auto FIFO_Stack = new List!int;
>   with(FIFO_Stack)
>   {
>     do {
>       InsertFront(firstNumber);
>     } while(++firstNumber <= end);
>
>     goRoot();
>
>     do pop.writef!"  %s"; while(Next);
>     writeln;
>   }
>
>   FIFO_Stack.goRoot();
>
>   foreach(stack; FIFO_Stack) {
>     stack.writeln;
>   }
> } /* OUTPUT:
>   10  11  12  13  14  15  16  17  18  19  20
> 10
> 11
> 12
> 13
> 14
> 15
> 16
> 17
> 18
> 19
> 20
> */
> ```
> SDB at 79

I implemented an alternative goroot it's called re_init and next 
program works.
Still I don't understand what is really going on.
Some state is lost using a class and you have restore it.
And the state is not lost using a struct.

```
cat test.d
import std.stdio: write,writeln;
import std.range: empty,popFront,front;

     struct Node {
     	int element;
     	Node * next;
     }

     class List {
     	Node * root=null;
     	Node * walker=null;
     	this(int[] AR){foreach(i ; AR)pushfront(i);}
     	bool empty() const {return !walker;}
     	void popFront() {walker=walker.next;}
     	float front() const {return walker.element;}
     	void pushfront(int element) {
     		Node * newnode=new Node();
     		newnode.element=element;
     		newnode.next=root;
     		root=newnode;
     		re_init();
     	}
     	void re_init(){walker=root;}
     }//List

     void main(){
     	List l=new List([3,2,1]);
     	l.writeln();
     	l.re_init();
     	l.writeln();
     }
     ```