stream_merge_no_coalesce.ts

class MergeState<A> {
    constructor() {}
    left : A = null;
    left_present : boolean = false;
    right : A = null;
    right_present : boolean = false;
}

export class Stream<A> {
  .
  .
  .

    merge(s : Stream<A>, f : ((left : A, right : A) => A) | Lambda2<A,A,A>) : Stream<A> {
        const ff = Lambda2_toFunction(f);
        const mergeState = new MergeState<A>();
        let pumping = false;
        const out = new StreamWithSend<A>(null);
        const pump = () => {
            if (pumping) {
                return;
            }
            pumping = true;
            Transaction.currentTransaction.prioritized(out.getVertex__(), () => {
                if (mergeState.left_present && mergeState.right_present) {
                    out.send_(ff(mergeState.left, mergeState.right));
                } else if (mergeState.left_present) {
                    out.send_(mergeState.left);
                } else if (mergeState.right_present) {
                    out.send_(mergeState.right);
                }
                mergeState.left = null;
                mergeState.left_present = false;
                mergeState.right = null;
                mergeState.right_present = false;
                pumping = false;
            });
        };
        const vertex = new Vertex("merge", 0,
            [
                new Source(
                    this.vertex,
                    () => this.listen_(out.vertex, (a : A) => {
                        mergeState.left = a;
                        mergeState.left_present = true;
                        pump();
                    }, false)
                ),
                new Source(
                    s.vertex,
                    () => s.listen_(out.vertex, (a : A) => {
                        mergeState.right = a;
                        mergeState.right_present = true;
                        pump();
                    }, false)
                )
            ].concat(toSources(Lambda2_deps(f)))
        );
        out.vertex = vertex;
        return out;
    }


  .
  .
  .