How do you reverse an iterator's flow?

Question

Is it possible to access the previous value of an iterator, for example:

function* gen () {
   yield* [0,1,2,3]
}

var it = gen();

it.next().value // 0
it.next().value // 1
it.last().value // would be awesome if this was 0

This is strictly a curiosity question. I've been playing with generators lately and was wondering if anyone uses generators/iterators in this manner?

If so, I would love to see your solution. (Doesn't need to follow the above syntax) -Thanks

I meant the previous yield...Do you think I should reformat the code to make that more clear? — Joseph Barnes, Jun 08 '17 at 16:03
You cannot. The iterator protocol doesn't provide such an API. — Felix Kling, Jun 08 '17 at 16:07
@FelixKling But you can make a wrapper for generators; see my answer. — Michał Perłakowski, Jun 08 '17 at 16:08
@MichałPerłakowski: Sure, one can always implement their own solution :) — Felix Kling, Jun 08 '17 at 16:09
@FelixKling Sorry for an off-topic comment, but could you take a look at [my question](https://stackoverflow.com/q/44392831/3853934)? — Michał Perłakowski, Jun 08 '17 at 16:13

nils · Accepted Answer · 2017-06-08T16:36:47.257

JS iterators only know one direction: forwards. Meaning, if you would want to use your custom iterator with a for-loop or the like, it would ignore your custom properties. You could however create your own custom iterator for your own use only:

const obj = {
   values: [0,1,2,3],
   [Symbol.iterator]() {
     const values = this.values;
     const min = 0;
     const max = values.length - 1;

     let index = -1;

     return {
       next() {
        index = Math.min(index + 1, max);
        return { value: values[index], done: index >= max };
       },
       prev() {
        index = Math.max(index - 1, min);
        return { value: values[index], done: index <= min };
       }
     }
   }
}

var it = obj[Symbol.iterator]();

console.log(it.next().value); // 0
console.log(it.next().value); // 1
console.log(it.prev().value); // would be awesome if this was 0
console.log(it.prev().value); // would be awesome if this was 0
console.log(it.prev().value); // would be awesome if this was 0
console.log(it.next().value); // would be awesome if this was 1

Michał Perłakowski · Answer 2 · 2017-06-08T16:15:36.970

4

You can wrap the generator in a function that saves previous yields:

const wrapGenerator = gen => (...args) => {
  const it = gen(...args);
  let previous, current;
  return {
    next: () => {
      const r = it.next();
      previous = current;
      current = r.value;
      return r;
    },
    previous: () => ({ value: previous })
  };
};

const gen = wrapGenerator(function * () {
  yield * [0, 1, 2, 3];
});

const it = gen();

console.log(it.next().value);
console.log(it.next().value);
console.log(it.previous().value);

I changed the function name to previous to avoid confusion (last could mean "the last item").

edited Jun 08 '17 at 16:15

answered Jun 08 '17 at 15:56

Michał Perłakowski

88,409
26
156
177

1

The OP used `last` as a reference to time, but it would be confused with *last item*. Why not call the method `prev` or `previous`? – Majid Fouladpour Jun 08 '17 at 16:13
@MajidFouladpour `prev` might lead to the expectation that it advances the generator in the opposite direction, which it doesn't – Bergi Jun 08 '17 at 16:16

score 1 · Answer 3 · answered Jun 08 '17 at 16:08

1

No, this is not generally possible. Iterators can only be advanced, not reversed or anything else.

Of course you can write your own iterator wrapper that caches the last value and makes it accessible in whatever way you like.

answered Jun 08 '17 at 16:08

Bergi

630,263
148
957
1,375

How do you reverse an iterator's flow?

3 Answers3