return T.toPromise(withApp(app, handler =>
   T.makeTask(cb => {
     request(handler)
       .get('/')
       .expect(200)
       .expect('hello', cb);
     return T.nonCanceler;
   })

function waitSignal(signal: string): T.Task<void> {
  return T.makeTask(cb => {
    process.once(signal as any, cb as any);
    return T.thunkCanceller(() => {
      process.removeListener(signal, cb as any);
    });
  });
}

export function writeSock<W extends Writable>(writable: W, buffer: Buffer): T.Task<void> {
  return T.makeTask({
    writable,
    buffer,
    handle: handleWriteSock,
    cancel: doNothingTask
  } as T.Computation<void>);
}

export function pipeStream<W extends Writable, R extends Readable>(ws: W, rs: R, opts?: { end?: boolean }): T.Task<void> {
  return T.makeTask(cb => {
    rs.pipe(ws, opts);
    const doEnd = (!opts || opts.end !== false) && (ws as any) !== process.stdout && (ws as any) !== process.stderr;
    const state: PipeState = {
      onError: null,
      onSuccess: null,
      resolved: false
    };
    if (doEnd) {
      state.onError = onErrorWS.bind(null, state, ws, cb);
      state.onSuccess = onSuccessWS.bind(null, state, ws, cb);
      ws.once('error', state.onError as any);
      ws.once('finish', state.onSuccess as any);
      return T.thunkCanceller(() => cleanUpListenerWS(state, ws));
    }
    // we not use automatic finish, so attach to readable
    state.onError = onErrorRS.bind(null, state, rs, cb);
    state.onSuccess = onSuccessRS.bind(null, state, rs, cb);
    rs.once('error', state.onError as any);
    rs.once('end', state.onSuccess as any);
    return T.thunkCanceller(() => cleanUpListenerRS(state, rs));
  });
}

export function readAVar<A>(avar: AVar<A>): Task<A> {
  return makeTask(new AVarRead(avar));
}