Why recursive generator function doesn't work in ES2015?

Question

I am trying to understand generators in ES2015 and have created a recursive factorial function with it. But it doesn't work. I have referred already existing question like this on the topic, but it doesn't help.

function* fact (n) {
   if (n < 2) {
     yield 1;
   } else {
     yield* (n * fact(n-1));
   }
}

let b = fact(5);
console.log(b.next());

Can anyone find any obvious issues I am missing here? I am using this in JSFiddle with JavaScript-1.7 here

You are not returning anything.. and you are saying that this is a recursive call. — Rajaprabhu Aravindasamy, May 12 '16 at 06:31
Yeah. With `yield` you don't need to return. Refer: http://www.2ality.com/2013/06/iterators-generators.html — Aditya Singh, May 12 '16 at 06:32
`fact` returns an *iterator*. What do you expect the result of multiplying a number with an iterator (`n * fact(n-1)`) to be? — Felix Kling, May 12 '16 at 06:33
Why is `fact` a generator in the first place? What kind of sequence do you want to produce? — Felix Kling, May 12 '16 at 06:36
Say I just want the intermediate values within the series of operations — Aditya Singh, May 12 '16 at 06:39
Based on your above comment I think the operation `n * fact(n-1)` is incorrect because it multiplies a number with a generator. Right? — Aditya Singh, May 12 '16 at 06:41
@RobG Exactly as you have mentioned. The sequence of all intermediate results as mentioned in the comment above — Aditya Singh, May 12 '16 at 06:42
So is this simply an exercise in getting a generator to call a generator (`yield*`), or to implement a factorial function using a recursive generator? I think I just answered my question… — RobG, May 12 '16 at 07:00
Can you provide the exact sequence of numbers you expect to get? What would the result of `Array.from(fact(5))` be? — Felix Kling, May 12 '16 at 07:02
Just an excercise to try out generators and see all the intermediate results in the recursive calls — Aditya Singh, May 12 '16 at 07:02
@FelixKling I had seen your posted answer and the tail recursive version looked exactly like what I wanted — Aditya Singh, May 12 '16 at 07:09

Felix Kling · Accepted Answer · 2016-05-12T07:23:41.077

Can anyone find any obvious issues I am missing here?

fact returns an iterator, yet you are trying to multiple it with a number: n * fact(n-1). That cannot work!

Because fact returns an iterator, but you also want to multiply the last value of the iterator with n (i.e. it is not tail-recursive), you cannot simply yield* it either.
You need to explicitly iterate over the result from the internal call, reemit the value and remember the last value so that you can multiple with it:

function* fact (n) {
   if (n < 2) {
     yield 1;
   } else {
     let last;
     for(last of fact(n-1)) {
       yield last;
     }
     yield n * last;
   }
}

Array.from(fact(5)); // [1, 2, 6, 24, 120]

If you change the function to be tail-recursive, it would be a bit shorter (and nicer), but the result would also be different (since we perform the operations in different order, at least in this implementation):

function* fact (n, acc=1) {
   yield acc
   if (n > 1) {
     yield* fact(n-1, acc * n);
   }
}
Array.from(fact(5)); // [1, 5, 20, 60, 120]

Personally I would just write a non-recursive version:

function* fact (n) {
  let result = 1;
  let i = 0;
  while (i < n) {
    yield result = result * ++i;
  }
}
Array.from(fact(5)); // [1, 2, 6, 24, 120]

The second tail recursive version is the perfect solution I was looking for. Thanks a lot :) — Aditya Singh, May 12 '16 at 07:23
@Aditya The tail recursive solution doesn't optimize tail calls though, because generator functions are not covered by TCO. So consider performance drawbacks and possible stack overflows. — , May 15 '16 at 11:55

score 3 · Answer 2 · answered May 12 '16 at 08:24

Just to add another tail-call recursive solution that returns the desired result, but takes three arguments (a slight variation from Felix Kling's second example):

function *factorial(n, add=1, cnt=1) {
  yield add;
  if (cnt < n) {
    cnt++;
    yield* factorial(n, add * cnt, cnt);
  }
}

Array.from(factorial(5));
// Array [ 1, 2, 6, 24, 120 ]

Why recursive generator function doesn't work in ES2015?

2 Answers2