.chain(q2 => {
   if (q2.length === 0) {
     return R.writeRef(machine, st)
       .then(R.writeRef(queue, []));
   }
   return loop(st);
 });

 return co(function* () {
   yield takeAVar(needsRunning);
   const a: A = yield maybe(set.task, identity, applyMaybe(modify, ma)) as Task<A>;
   yield writeRef(currRef, right(a));
   yield putAVar(responseVar, a);
   yield delay(set.delay);
   const responseVar_: AVar<A> = yield newEmptyAVar;
   yield writeRef(currRef, left(responseVar_));
   return loop(responseVar_, just(a));
 });

 function check(merge: (_: W) => W, s: State<W>): [State<W>, T.Task<void>] {
   if (s.tag === StateType.NOREAPER) {
     throw new Error('unexpected NoReaper (2)');
   }
   let wl = merge(s.workload);
   return settings.isNull(wl)
     ? [{ tag: StateType.NOREAPER }, R.writeRef(tidRef, void 0)]
     : [{ tag: StateType.WORKLOAD, workload: wl }, reaper(settings, stateRef, tidRef) ];
 }

 .chain(sbs => {
   let nkey = sbs.fresh.toString();
   return writeRef(subsRef, S.assign({}, sbs, {
     fresh: sbs.fresh + 1,
     sbs: S.assign({}, sbs.cbs, {
       [nkey]: cb
     })
   })).map(v => remove(nkey));
 });

 .chain(step => {
   return R.writeRef(machine, step).then(T.pure(inst));
 });

function inactive(ms: MutableStatus): T.Task<void> {
  return RV.writeRef(ms, Status.INACTIVE);
}

function refresh(ms: MutableStatus): T.Task<void> {
  return RV.writeRef(ms, Status.ACTIVE);
}

 .chain(fib => R.writeRef(tidRef, fib));