partition for streams

[scarf005]

being able to split a stream into two by condition would be highly useful.

https://hackage.haskell.org/package/base-4.19.0.0/docs/Data-List.html#v:partition

example implementation

export function partition<T, U extends T>(fn: (x: T) => x is U): Reducer<T, readonly [Stream<U>, Stream<Exclude<T, U>>]>
export function partition<T>(fn: (x: T) => boolean): Reducer<T, readonly [Stream<T>, Stream<T>]>
export function partition<T>(fn: (x: T) => boolean) {
  return Reducer.create(
    () => [Stream.empty(), Stream.empty()] as const,
    ([pass, fail], val: T) => (fn(val) ? ([pass.append(val), fail] as const) : ([pass, fail.append(val)] as const)),
    (state) => state
  )
}

wonder if this method is too inefficient?

[vitoke]

Partition is indeed a nice one. By chance I'm currently reworking/hopefully improving a large portion of the streams package. I'll bring this one into the mix.

[scarf005]

I was initially going to open a PR. Would it cause issues with your plan?

[vitoke]

Well I've been working on this update longer than expected, but it's also going to be quite big. I hope to release it in the coming week or so. Documentation is the main remaining issue.

My proposal for partition is adding the following reducer definition, which would also be added as a method in Stream:

  export const partition: {
    <T, T2 extends T, RT, RF = RT>(
      pred: (value: T, index: number) => value is T2,
      options: {
        collectorTrue: Reducer<T2, RT>;
        collectorFalse: Reducer<Exclude<T, T2>, RF>;
      }
    ): Reducer<T, [true: RT, false: RF]>;
    <T, T2 extends T>(
      pred: (value: T, index: number) => value is T2,
      options?: {
        collectorTrue?: undefined;
        collectorFalse?: undefined;
      }
    ): Reducer<T, [true: T2[], false: Exclude<T, T2>[]]>;
    <T, RT, RF = RT>(
      pred: (value: T, index: number) => boolean,
      options: {
        collectorTrue: Reducer<T, RT>;
        collectorFalse: Reducer<T, RF>;
      }
    ): Reducer<T, [true: RT, false: RF]>;
    <T>(
      pred: (value: T, index: number) => boolean,
      options?: {
        collectorTrue?: undefined;
        collectorFalse?: undefined;
      }
    ): Reducer<T, [true: T[], false: T[]]>;
  } 

Using this definition would lead to:

const test1 = partition(
  (v: number | string): v is string => typeof v === 'string'
);
// inferred type of test1: Reducer<string | number, [true: string[], false: number[]]>

const test2 = partition(
  (v: number | string): v is string => typeof v === 'string',
  { collectorTrue: Reducer.count, collectorFalse: Reducer.toJSSet() }
);
// inferred type of test2: Reducer<string | number, [true: number, false: Set<number>]>

The idea of the collectors is to allow you to specify in what form you want to materialise the streams. If you don't specify collectors, it will assume you want arrays. You can also collect to Streams as in your original proposal, but that would indeed be quite inefficient. You can still do that if you really want by supplying a reducer that reduces to a stream. But you are also free to directly create sets or any other structure. This is similar to the window reducer.

Curious to hear your thoughts..

[vitoke]

The PR has been merged and published. There are now Reducer.partition and Stream.partition functions added that can be used as described above. Thanks for the great suggestion! Let me know if it works as expected or if you have improvement ideas.

[scarf005]

collectorTrue and collectorFalse feel a bit verbose, tho. maybe collector: { pass, fail } could be a bit more consise?