pub async fn run<F, A, T>(start: F) -> Result<T, Error>
    where
        F: FnOnce(Terminal) -> A + Send + 'static,
        A: Future<Output = T> + Send + 'static,
        T: Send + 'static,
    {
        Builder::default().run(start).await
    }
/// Runs the terminal application with the default settings, i.e. minumum
/// screen is 80x25, 20ms for frame rendering interval, and 20ms for event
/// polling from the OS.
///
/// Gives the application a handle to the terminal. When the given start
/// function finishes, the application's execution stops as well.
///
/// After that `start`'s future returns, terminal services such as screen
/// handle and events handle are not guaranteed to be available. One would
/// prefer spawning tasks that use the terminal handle by joining them, and
/// not detaching.
///
/// Returns an [`AlreadyRunning`] error if there is already an instance of
/// terminal services executing. In other words, one should not call
/// this function again if another call did not finish yet, otherwise it
/// will panic.
///
/// Beware! If the given `start` future returns a `Result`, then `run` will
/// return a double `Result`!!
Runs the terminal application with the default settings, i.e. minumum
screen is 80x25, 20ms for frame rendering interval, and 20ms for event
polling from the OS.

Gives the application a handle to the terminal. When the given start
function finishes, the application's execution stops as well.

After that `start`'s future returns, terminal services such as screen
handle and events handle are not guaranteed to be available. One would
prefer spawning tasks that use the terminal handle by joining them, and
not detaching.

Returns an [`AlreadyRunning`] error if there is already an instance of
terminal services executing. In other words, one should not call
this function again if another call did not finish yet, otherwise it
will panic.

Beware.
Runs the terminal application with the default settings i . e . minumum screen is 80x25 20ms for frame rendering interval and 20ms for event polling from the OS . Gives the application a handle to the terminal . When the given start function finishes the application ' s execution stops as well . After that ` start ` ' s future returns terminal services such as screen handle and events handle are not guaranteed to be available . One would prefer spawning tasks that use the terminal handle by joining them and not detaching . Returns an [ ` AlreadyRunning ` ] error if there is already an instance of terminal services executing . In other words one should not call this function again if another call did not finish yet otherwise it will panic . Beware .
pub async fn run<F, A, T>(start: F) -> Result<T, Error>
    where
        F: FnOnce(Terminal) -> A + Send + 'static,
        A: Future<Output = T> + Send + 'static,
        T: Send + 'static,
    {
        Builder::default().run(start).await
    }
pub async fn run < F , A , T > ( start : F ) -> Result < T , Error > where F : FnOnce ( Terminal ) -> A + Send + ' static , A : Future < Output = T > + Send + ' static , T : Send + ' static , { Builder :: default ( ) . run ( start ) . await }
Runs the terminal application with the default settings, i.e.
Runs the terminal application with the default settings i . e .
start
F
start
F