function shutdownServer(
  state: ServerState
): T.Task<void> {
  return T.sequencePar([
    T.liftEff(null, state.connections, destroAllConnections),
    closeServer(state.server)
  ]) as any;
}

 function commit(state: AppState<M, Q, S>): T.Task<AppState<M, Q, S>> {
   return T.liftEff(null, state, commitRender)
     .then(runSubs(state.interpret, app.subs(state.model))
     .chain(tickInterpret =>
       tickInterpret.tick()
         .map(nextInterpret =>
           ({ snabbdom: state.snabbdom
           , model: state.model
           , interpret: nextInterpret
           , needsRender: false})))
     );
 }

function connectAndTrapSignal(
  state: ServerState,
  settings: Z.Settings
): T.Task<void> {
  return T.sequencePar([
    T.liftEff(null, state, registerRequestHandler),
    listenConnection(state, settings)
  ]).chain(() => {
    return T.race([
      waitSignal('SIGINT'),
      waitSignal('SIGTERM'),
      settings.killToken == null ? T.never : takeAVar(settings.killToken)
    ]);
  });
}

export function status<A>(avar: AVar<A>): Task<Status<A>> {
  return liftEff(null, () => avar.status);
}

export function killAVar(error: Error, avar: AVar<any>): Task<void> {
  return liftEff(null, error, avar, _killAVar);
}

export function readRef<A>(ref: Ref<A>): T.Task<A> {
  return T.liftEff(null, ref, _readRef);
}

 return T.toPromise(t.chain(b => {
   return T.liftEff(null, () => {
     assert.deepEqual(a, b);
   });
 }));

 writeHead(st: H.Status, headers: H.ResponseHeaders): T.Task<void> {
   return T.liftEff(this.response, st, headers, this.response.writeHead);
 }

function defaultOnException(mreq: P.Maybe<IncomingMessage>, err: Error): T.Task<void> {
  return T.liftEff(null, mreq, err, defaultOnExceptionEff);
}