Array and IteratorObject reduce method type error

[2chanhaeng]

🔎 Search Terms

"Array IteratorObject reduce"

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about 5.6.

⏯ Playground Link

https://www.typescriptlang.org/play/?target=99&ts=5.6.3#code/GYVwdgxgLglg9mABAJwKYBMQVQHgCoA0iAygHwAUAsAFCKLABci5MYMsAhgDZPFEQhkaMFCZ4AlIgC8pEgRp1W7XvNqJ2qZGIDaAXUQAfRAEkomjlDjIA8gCMAVqmj5SqyQG8FiAPTf1wZgBBIQ4ATwA6GABnYOQwljNkcUk0KEEkDWRwtExscmAiJShxAG5EL1T09UTsjCxUfMK2YpKaAF8aGlBIWAQAKhQOMABzBo8vUJhULnREAEZWtUnp2YAmRbplmcQAZkWO6hoIBCi4LlRwrjhh8hz68nIOIltJGUQORABqRFsiAAYiHERmNkotjmBTudLtdbnU8o9nq9ZB9vr9EAAidGAoajcjJUpAA

💻 Code

function reduce<T, S>(
  f: (initial: S, current: T) => S,
  init: S,
  iter: T[] | IteratorObject<T>,
) {
  // if (Array.isArray(iter)) return iter.reduce(f, init); 
  return iter.reduce(f, init);
}

function* range() {
  yield 1;
  yield 2;
  yield 3;
}

console.log(reduce((a, b) => a + b, 0, range()));
console.log(reduce((a, b) => a + b, "", range()));

🙁 Actual behavior

The type error that should not occur appears at f in the line return iter.reduce(f, init); as follows:

Argument of type '(initial: S, current: T) => S' is not assignable to parameter of type '(previousValue: T, currentValue: T, currentIndex: number) => T'.
  Types of parameters 'initial' and 'previousValue' are incompatible.
    Type 'T' is not assignable to type 'S'.
      'S' could be instantiated with an arbitrary type which could be unrelated to 'T'.

🙂 Expected behavior

Both T[] and IteratorObject<T> have a reduce method, and the interfaces of the two methods are identical. Therefore, the error should not occur. For example, the type error disappears if the commented line is uncommented. All that line does is distinguish whether iter is a T[] or an IteratorObject<T>. In fact, the code after this conditional branch is identical. Therefore, this error should not exist.

Additional information about the issue

No response

[jcalz]

Feels like another #60006... unions of callables are not always callable (e.g., overloads and generics)

Personally I'd just work around it by manually widening to whatever callable type you think it should be in the first place, something like

function reduce<T, S>(
  f: (initial: S, current: T) => S,
  init: S,
  iter: T[] | IteratorObject<T>,
) {
  const i: {
    reduce<S>(callbackfn: (previousValue: S, currentValue: T) => S, initialValue: S): S
  } = iter;
  return i.reduce(f, init);
}

Playground

[typescript-bot]

This issue has been marked as "Duplicate" and has seen no recent activity. It has been automatically closed for house-keeping purposes.