Proper way to handle types for JS reduce with a list having union of types?

Let's say we have a function segregateIds that separates a list of Ids into two parts by checking in a string-to-boolean map.

const segregateIds = (
  ids: string[] | number[],
  optionsById: Record<string, boolean>,
): { correctIds: string[] | number[]; incorrectIds: string[] | number[] } => {

  return ids.reduce<{ correctIds: string[] | number[]; incorrectIds: string[] | number[] }>(
    (accum: { correctIds: string[] | number[]; incorrectIds: string[] | number[] }, id: string | number) => {
      if (optionsById[id]) {
        accum.correctIds.push(id);
      } else {
        accum.incorrectIds.push(id);
      }

      return accum;
    },
    {
      correctIds: [],
      incorrectIds: [],
    }
  );
};

The problem here is that reduce is not accepting a list that has both string[] or number[]. Type coercion is a way to handle this. Is there something better?

Here is the Link to TS Playground

Expecting to resolve the TS error. Tried to type-coerce the accumulator, id but in vain. Tried using lodash reduce, partition but still error remains.

I can use Array<string|number> and pass to lodash partition but that will be tweaking the actual type as Array<string|number> is different from string[] | number[].

You can use generic type T to accept arrays of strings or numbers:

const segregateIds = <T extends string | number>(
  ids: T[],
  optionsById: Record<string, boolean>,
): { correctIds: T[]; incorrectIds: T[] } => {

  return ids.reduce<{ correctIds: T[]; incorrectIds: T[] }>(
    (accum: { correctIds: T[]; incorrectIds: T[] }, id: T) => {
      if (optionsById[id.toString()]) {
        accum.correctIds.push(id);
      } else {
        accum.incorrectIds.push(id);
      }

      return accum;
    },
    {
      correctIds: [],
      incorrectIds: [],
    }
  );

In addition to protob's answer.

Since you marked the question with the lodash tag, you can use _.partition() instead of reduce:

const segregateIds = <T extends string | number>(
  ids: T[],
  optionsById: Record<string, boolean>,
): { correctIds: T[]; incorrectIds: T[] } => {
  const [correctIds, incorrectIds] = partition(ids, id => optionsById[String(id)]);

  return {
    correctIds,
    incorrectIds
  };
}