lackluster partition with conditional types

partition.ts

type Pred<T, U extends T> = (v: T) => v is U;

function filter<T, U extends T>(coll: T[], pred: Pred<T, U>): U[] {
  const seed: U[] = [];
  return coll.reduce((acc: U[], val: T) => {
    if (pred(val)) {
      return [...acc, val];
    }
    return acc;
  }, seed);
}

type Tuple<T, U> = [T, U];
type ArrayTuple<T, U> = Tuple<T[], U[]>;
type Partition<T, U extends T> = ArrayTuple<U, Exclude<T, U>>;

function partition<T, U extends T>(coll: T[], pred: Pred<T, U>): Partition<T, U> {
  const yes = filter(coll, pred);
  const antiPred: Pred<T, Exclude<T, U>> = (val: T): val is Exclude<T, U> => !pred(val);
  const no = filter(coll, antiPred);
  return [yes, no];
  // const seed: Partition<T, U> = [[], []];
  // return coll.reduce((acc: Partition<T, U>, val: T) => {
  //   const [yes, no] = acc;
  //   if (pred(val)) {
  //     const p: Partition<T, U> = [[...yes, val], no];
  //     return p;
  //   }
  //   const p: Partition<T, U> = [yes, [...no, val]]; // does not compile b/c val is T
  //   return p;
  // }, seed);
}