Coalesce free Cell::apply

cell_apply_no_coalesce.ts

export class Cell<A> {
  .
  .
  .
 /**
	 * Apply a value inside a cell to a function inside a cell. This is the
	 * primitive for all function lifting.
	 */
	static apply<A,B>(cf : Cell<(a : A) => B>, ca : Cell<A>, sources? : Source[]) : Cell<B> {
    	return Transaction.run(() => {
            let pumping = false;
    	    const state = new ApplyState<A,B>(),
                out = new StreamWithSend<B>(),
                cf_updates = Operational.updates(cf),
                ca_updates = Operational.updates(ca),
                pump = () => {
                    if (pumping) {
                        return;
                    }
                    pumping = true;
                    Transaction.currentTransaction.prioritized(out.getVertex__(), () => {
                        let f = state.f_present ? state.f : cf.sampleNoTrans__();
                        let a = state.a_present ? state.a : ca.sampleNoTrans__();
                        out.send_(f(a));
                        pumping = false;
                    });
                },
                src1 = new Source(
                        cf_updates.getVertex__(),
                        () => {
                            return cf_updates.listen_(out.getVertex__(), (f : (a : A) => B) => {
                                state.f = f;
                                state.f_present = true;
                                pump();
                            }, false);
                        }
                    ),
                src2 = new Source(
                        ca_updates.getVertex__(),
                        () => {
                            return ca_updates.listen_(out.getVertex__(), (a : A) => {
                                state.a = a;
                                state.a_present = true;
                                pump();
                            }, false);
                        }
                    );
            out.setVertex__(new Vertex("apply", 0,
                [src1, src2].concat(sources ? sources : [])
            ));
            return out.holdLazy(new Lazy<B>(() =>
                    cf.sampleNoTrans__()(ca.sampleNoTrans__())
                ));
        });
	}
  .
  .
  .