use futures::stream::{self, StreamExt};

use futures::stream::StreamExt;

    stderr.execute(cursor::Hide)?;
    terminal::enable_raw_mode()?;
    let (mut input, _done) = events();
    let mut comparator = CompareContext {
        db,
        events: &mut input,
        out: &mut stderr,
        needs_newline: false,
    };

    let mut comparator = CompareContext::new(&db, &mut stderr)?;

    stderr.execute(cursor::Show)?;
    terminal::disable_raw_mode()?;

struct CompareContext<'a, W> {

struct CompareContext<'a, W: std::io::Write> {

    events: &'a mut stream::Abortable<EventStream>,

    events: EventStream,

}
impl<'a, W: std::io::Write> std::ops::Drop for CompareContext<'a, W> {
    fn drop(&mut self) {
        self.out.execute(cursor::Show).ok();
        terminal::disable_raw_mode().ok();
    }

    fn new(db: &'a AsyncConnection, out: &'a mut W) -> DynResult<Self> {
        out.execute(cursor::Hide)?;
        terminal::enable_raw_mode()?;
        Ok(Self {
            db,
            events: EventStream::new(),
            out,
            needs_newline: false,
        })
    }

pub fn events() -> (stream::Abortable<EventStream>, stream::AbortHandle) {
    stream::abortable(EventStream::new())
}

    match pick::pick(&db, args.count, args.gather).await {
        Ok(r) => Ok(r),
        Err(e) => {
            use crossterm::ExecutableCommand;
            let mut stderr = std::io::stderr();
            stderr.execute(crossterm::cursor::Show).ok();
            crossterm::terminal::disable_raw_mode().ok();
            Err(e)
        }
    }?;

    pick::pick(&db, args.count, args.gather).await?;