Iterators in JavaScript and remembering position

Question

This is an attempt to write a function link that creates a linked list from an array:

function link(list) {
 let next = tail = null;
 for(let i = list.length-1; i >= 0; i--) { 
 const value = list[i]; 
 next = { value, next };
 }
 let cursor = head = next;
 function* iterator() {
 while(cursor.next) {
 yield cursor;
 cursor = cursor.next
 }
 yield cursor;
 }
 return {
 [Symbol.iterator]: iterator,
 head,
 tail,
 };
}
console.log(...link([1,2,3,4]));

The iterator maintains a cursor to remember its position in the iteration.

This feels wrong and brittle.

Is it?

If so, how should the iterator be implemented here.

• I wrestled a bear once.: the structure youre generating feels wrong to me. i feel like you should get the code that consumes this structure reviewed and figure out a way to use a flat array instead.
• 52d6c6af: I am walking from the right of the supplied list creating objects (list elements). Each time I create a list element I hold a reference to it and use that when populating the next property of the "previous" element. Can you explain which aspect feels wrong to you?
• I wrestled a bear once.: The structure you're building doesn't really add any value to the data. You're not really doing anything here except re-arranging data. Your final structure will require more than a simple loop to interate and there's no easy way to get a length from it without referring to the original object. Unless you require this structure for a web service or something the whole thing just feels unintuitive to me. Just my 0.02.
• 52d6c6af: It's a linked list (albeit without insert, delete etc). Is it not?
• I wrestled a bear once.: What it is is more complicated than necessary. The question I'm asking is why is it a linked list? You may have a perfectly legitimate reason for doing what you're doing I just can't see the point on my end. Carry on..

Answer 1

How about the following recursive approach

function link(list) {
 if(!list.length)
 return [];
 let [car, ...cdr] = list;
 return {
 car,
 cdr: link(cdr),
 [Symbol.iterator]: function*() {
 yield this;
 yield *this.cdr;
 }
 }
}
ls = link([1, 2, 3, 4])
for (let t of ls)
 console.log(t.car)

• 52d6c6af: I think this implementation is fantastic.

Answer 2

The number one problem with the code as originally written was that cursor was maintained at instance- rather than iterator-invocation level.

This is what "felt wrong" to me, although I could not articulate it at the time.

The following updated implementation moves the position of the cursor variable to solve this issue.

function link(list) {
 let next = tail = null;
 for(let i = list.length-1; i >= 0; i--) { 
 const value = list[i]; 
 next = { value, next };
 }
 function* iterator() {
 let cursor = this.head;
 while(cursor.next) {
 yield cursor;
 cursor = cursor.next
 }
 yield cursor;
 }
 return {
 [Symbol.iterator]: iterator,
 head: next,
 tail,
 };
}
var ll = link([1,2,3,4]);
console.log(...ll);
console.log(...ll);