Unclear magic using "return"

I got a bit confused following the explanation in http://exploringjs.com/es6/ch_iteration.html#_closing-iterators-via-return

The issue is related to the functions taking as input an iterable and returning an iterable: map, filter, slice and many others.

When you stop consuming one of the iterables returned by those, you can call “return”, as specified in the link above (or rely on for…of that is going to do that automatically). The problem is that I don’t see how we are able to close the previous iterable calling return on that.

I wrote this bit of code to verify my doubt:

const slice = require('./es2018/slice')

const inf = {
  next: () => ({ done: false, value: 'x' }),
  return: () => { // who is calling this ?
    console.log('close')
    return { done: true }
  }
}
 
const iter = {
  [Symbol.iterator]: () => inf
}

for (const i of slice(3, iter)) {
  console.log(i)
  break // this should fire "return" on the generator object created by slice
}

// x
// close

The good news is that, despite my concern it works fine (it calls return) I didn’t understand how this magic works though.

[conartist6]

I’ve figured out what’s going on with Babel failing. It was unpleasantly difficult. The problem is with slice, not with zip. Long story short, there’s a limitation in transform-regenerator. That limitation is described here: http://babeljs.io/docs/en/babel-plugin-transform-es2015-for-of/#options-loose. We have the loose option enabled:

      "presets": [
        ["@babel/preset-env", {
          "loose": true
        }]
      ]

Turning that option off unbreaks this test case at the cost of performance in the es5 code. I’d say we have no choice, the library code is only correct with strict on.

[conartist6]

Also TIL that you can write return yield* ....