scanln 0.1.1

//! The inverse of [`println`]
//!
//! [`scanln`] is a macro that reads a line from `stdin`, [removes the trailing
//! newline][0] (if present), and leaves other whitespace intact. It expands to
//! an expression that returns a [`String`], so it can be assigned to a variable
//! or used directly. [`scanln`] may take arguments like those to the [`print`]
//! macro, which can be used to generate a prompt.
//!
//! # Examples
//!
//! ## Simple prompt
//!
//! ```no_run
//! # #[macro_use] extern crate scanln;
//! let input = scanln!("> ");
//! ```
//!
//! This results in a prompt that looks like this (where `_` represents where
//! the user will start typing):
//!
//! ```text
//! > _
//! ```
//!
//! ## No prompt
//!
//! ```no_run
//! # #[macro_use] extern crate scanln;
//! let input = scanln!();
//! ```
//!
//! Result:
//!
//! ```text
//! _
//! ```
//!
//! ## Formatted prompt
//!
//! ```no_run
//! # #[macro_use] extern crate scanln;
//! let input = scanln!("{}", 0);
//! ```
//!
//! Result:
//!
//! ```text
//! 0_
//! ```
//!
//! [0]: https://users.rust-lang.org/t/remove-the-new-line-from-read-line/21380

/// The inverse of [`println`]
///
/// Invocations of [`scanln`] expand to an expression retuning a [`String`] that
/// contains a line of input from `stdin`. It can be invoked with arguments
/// identical to those of [`print`], and if so, those arguments will be used
/// to generate a prompt on `stdout`. Input will begin on the same line that the
/// prompt ends, if any. If no arguments are provided, input will start where
/// the cursor is, which is likely to be on its own empty line.
#[macro_export] macro_rules! scanln {
    // Get the actual input, stripping the trailing '\n' and/or '\r' if present
    () => {{
        let mut s = ::std::string::String::new();
        ::std::io::stdin().read_line(&mut s).unwrap();

        // TODO fix bizarre syntax, blocked on const generics:
        // https://github.com/rust-lang/rust/issues/39511
        s.trim_end_matches(&['\n', '\r'][..]).to_owned()
    }};

    // Print out a prompt, possibly with format arguments
    ( $($args:tt)* ) => {{
        print!("{}", format_args!($($args)*));

        // Flush stdout because it's line buffered and we didn't print a newline
        use ::std::io::Write;
        ::std::io::stdout().flush().unwrap();

        // Read input
        $crate::scanln!()
    }};
}