Add std::io::input simple input function.

[sHaDoW-54]

Condenses the normal input process into one function. This is good for new rust users who don't understand the normal process and for users who don't require special functionality.

Especially with new rust users looking to make small programs, input can be a tricky thing for them to grasp, especially when other languages do this much simpler.

EX:
Python : user_input = input("Enter: ")
Ruby: user_input = gets
C#: user_input = Console.ReadLine();

So this...

use std::io::{stdin,stdout,Write};
let mut s=String::new();
print!("Please enter some text: ");
let _=stdout().flush();
stdin().read_line(&mut s).expect("Did not enter a correct string");
if let Some('\n')=s.chars().next_back() {
    s.pop();
}
if let Some('\r')=s.chars().next_back() {
    s.pop();
}
println!("You typed: {}",s);

Would turn into this...

use std::io::input;
let user_input = input("Please enter some text: ");
println!("You typed: {}", user_input);

[rust-highfive]

Thanks for the pull request, and welcome! The Rust team is excited to review your changes, and you should hear from @Mark-Simulacrum (or someone else) soon.

If any changes to this PR are deemed necessary, please add them as extra commits. This ensures that the reviewer can see what has changed since they last reviewed the code. Due to the way GitHub handles out-of-date commits, this should also make it reasonably obvious what issues have or haven't been addressed. Large or tricky changes may require several passes of review and changes.

Please see the contribution instructions for more information.

[pickfire]

I would suggest having two set of API, input() and inputln().

pub fn inputln(prompt: &str) -> String {}

pub fn input() -> String {}

I could think of a use like

let name = inputln("name: ");
let age = input();

I also don't know if it will be good to have -> T or generics here using Into<T>.

I wonder if these kind of pull request requires a FCP first.

Sidenote: @sHaDoW-54 can you please format the code with rustfmt and use ```rust?

[retep998]

I think this would be a very useful addition to std as it really is a major hurdle for simple console prompts to be so complicated.

[retep998]

Given these functions would start out as unstable, and it really is just one or two functions, at most we'd want a libs team FCP. A full RFC is overkill. If someone wants to come up with a more comprehensive solution in the meantime, by all means, but that shouldn't block the unstable addition of these simple functions. I regularly write simple Rust scripts where I'd love to quickly read some input but it's always such a hassle to pull out the stdio machinery to do it so these functions are perfect for me.

[the8472]

I agree we could just have one function, though I don't think they need to know some/none. The function could have the signature of prompt and users who want input without writing anything can just pass an empty string.

Seconded. There's essentially no performance benefit for having a no-output version. An empty string is a constant and the performance is limited by the human anyway.

* the name feels off (I like `read_input` better)

How about read_line or readline (like gnu readline)?

[pickfire]

Seconded. There's essentially no performance benefit for having a no-output version. An empty string is a constant and the performance is limited by the human anyway.

Oh, why merge prompt and input? I think it should be separated. Why print an empty string when you can not print at all? It looks like an extra useless step is being called when user have input(""). If this is the case, I rather it be a macro instead like input!() or input!("prompt") or even input!("prompt {}", name) (from print!).

[sHaDoW-54]

@pickfire Do you mean something like the difference between unwrap() and expect("message") where one gives and output and the other doesn't? If so, i think this is a good idea since it is already established with these two functions, so why not input()?

[pickfire]

@sHaDoW-54 I meant something like println! where you could use it to print just an empty line println!() or print some stuff println!("hello {}", 123). Note that for our case, we currently does not have input() after your last change, it requires people to do a syscall to print nothing which is extra while needing to use it with input(""). In my personal opinion, I prefer the previous behavior where we have input() and prompt("text"), or we could follow how the macros for printing like input!() and input!("text") such as the current print!, println!, eprint!, eprintln!, write!, writeln!, assert!, assert_eq!, assert_ne! and format! (this have no output) macros.

[steveklabnik]

Left some suggestions to move the code examples in line with the standard style, that is, import types, but don't import functions directly.

One thing to consider about adding functionality like this is its impact on docs. Consider https://doc.rust-lang.org/stable/book/ch02-00-guessing-game-tutorial.html, which is where it would be used in the book; this function would decently simplify the very beginning.

[bors]

☔ The latest upstream changes (presumably #73265) made this pull request unmergeable. Please resolve the merge conflicts.

[JohnCSimon]

@sHaDoW-54
Ping from triage: can you please address the merge conflicts?

[Dylan-DPC-zz]

reworked in #75435

[pickfire]

I wrote the design in https://hackmd.io/@G8ZK5BSuQPOxvEQWVZSxng/By2UUacFD/edit, hopefully it covers the design space.