How to Create Interactive CLI Programs in Rust

Are you tired of boring command line programs that just spit out text and leave you feeling disconnected from your computer? Do you want to create interactive CLI programs that engage your users and make them feel like they're part of the action? Look no further than Rust, the modern programming language that's taking the world by storm.

In this article, we'll show you how to create interactive CLI programs in Rust that will keep your users engaged and excited. We'll cover everything from basic input/output to advanced features like progress bars and interactive menus. So grab your keyboard and let's get started!

Why Rust?

Before we dive into the nitty-gritty of creating interactive CLI programs in Rust, let's take a moment to talk about why Rust is the perfect language for this task.

First and foremost, Rust is fast. It's designed to be a systems programming language, which means it's optimized for performance and efficiency. This makes it ideal for CLI programs that need to process large amounts of data quickly.

Secondly, Rust is safe. It's designed to prevent common programming errors like null pointer dereferences and buffer overflows. This means that your CLI programs will be less likely to crash or cause security vulnerabilities.

Finally, Rust is modern. It has a vibrant community of developers who are constantly creating new libraries and tools to make programming easier and more fun. This means that you'll have access to a wealth of resources as you create your interactive CLI programs.

Getting Started

To create interactive CLI programs in Rust, you'll need to have Rust installed on your computer. If you haven't already done so, head over to the Rust website and follow the installation instructions for your operating system.

Once you have Rust installed, you can create a new Rust project by running the following command in your terminal:

cargo new my_project

This will create a new directory called my_project with some basic Rust files and a Cargo.toml file that describes your project's dependencies.

Basic Input/Output

The first step in creating an interactive CLI program is to handle input and output. Rust provides several ways to do this, but the simplest is to use the std::io module.

Here's an example program that reads a line of text from the user and prints it back out:

use std::io;

fn main() {
    println!("Enter some text:");
    let mut input = String::new();
    io::stdin().read_line(&mut input).unwrap();
    println!("You entered: {}", input.trim());
}

Let's break this down line by line:

• use std::io; imports the std::io module, which provides input/output functionality.
• println!("Enter some text:"); prints a message to the user.
• let mut input = String::new(); creates a new mutable String variable called input.
• io::stdin().read_line(&mut input).unwrap(); reads a line of text from the user and stores it in the input variable. The &mut syntax indicates that input is a mutable reference, which means that the read_line function can modify its contents.
• println!("You entered: {}", input.trim()); prints the user's input back out, with any leading or trailing whitespace removed.

Advanced Input/Output

While the basic input/output functionality provided by std::io is sufficient for many CLI programs, sometimes you need more advanced features like progress bars, colored output, or interactive menus. Fortunately, Rust has a number of libraries that make these features easy to implement.

Progress Bars

Progress bars are a great way to give your users feedback on long-running tasks. The indicatif library provides a simple way to create progress bars in Rust.

Here's an example program that uses indicatif to display a progress bar while it sleeps for five seconds:

use std::thread;
use std::time::Duration;
use indicatif::ProgressBar;

fn main() {
    let pb = ProgressBar::new(100);
    for i in 0..100 {
        pb.inc(1);
        thread::sleep(Duration::from_millis(50));
    }
    pb.finish_with_message("Done!");
}

Let's break this down line by line:

• use std::thread; and use std::time::Duration; import the std::thread and std::time modules, which we'll use to simulate a long-running task.
• use indicatif::ProgressBar; imports the ProgressBar struct from the indicatif library.
• let pb = ProgressBar::new(100); creates a new ProgressBar with a maximum value of 100.
• for i in 0..100 { pb.inc(1); thread::sleep(Duration::from_millis(50)); } updates the progress bar 100 times, with a 50 millisecond delay between each update.
• pb.finish_with_message("Done!"); finishes the progress bar and prints a message to the user.

Colored Output

Colored output is a great way to make your CLI programs more visually appealing and easier to read. The colored library provides a simple way to add color to your output in Rust.

Here's an example program that uses colored to print a message in red:

use colored::*;

fn main() {
    println!("{}", "This message is in red".red());
}

Let's break this down line by line:

• use colored::*; imports all of the functions and types from the colored library.
• println!("{}", "This message is in red".red()); prints the message "This message is in red" in red text.

Interactive Menus

Interactive menus are a great way to give your users options and let them choose what they want to do. The dialoguer library provides a simple way to create interactive menus in Rust.

Here's an example program that uses dialoguer to display a menu and get the user's choice:

use dialoguer::{Select, MultiSelect};

fn main() {
    let choices = &["Option 1", "Option 2", "Option 3"];
    let selected = Select::new()
        .items(choices)
        .default(0)
        .interact()
        .unwrap();
    println!("You chose: {}", choices[selected]);

    let selected = MultiSelect::new()
        .items(choices)
        .defaults(&[true, false, true])
        .interact()
        .unwrap();
    println!("You chose: {:?}", selected);
}

Let's break this down line by line:

• use dialoguer::{Select, MultiSelect}; imports the Select and MultiSelect structs from the dialoguer library.
• let choices = &["Option 1", "Option 2", "Option 3"]; creates an array of choices for the user to select from.
• let selected = Select::new() .items(choices) .default(0) .interact() .unwrap(); creates a new Select object with the choices and a default selection of the first option. The interact method displays the menu to the user and returns the index of the selected option.
• println!("You chose: {}", choices[selected]); prints the user's choice.
• let selected = MultiSelect::new() .items(choices) .defaults(&[true, false, true]) .interact() .unwrap(); creates a new MultiSelect object with the choices and a default selection of the first and third options. The interact method displays the menu to the user and returns a vector of boolean values indicating which options were selected.
• println!("You chose: {:?}", selected); prints the user's choices.

Conclusion

Creating interactive CLI programs in Rust is easy and fun, thanks to the language's speed, safety, and modern features. Whether you're building a simple tool or a complex application, Rust has the tools and libraries you need to make your program engaging and interactive.

In this article, we've covered the basics of input/output in Rust, as well as some advanced features like progress bars, colored output, and interactive menus. With these tools at your disposal, you'll be able to create CLI programs that keep your users engaged and excited.

So what are you waiting for? Start coding and see what you can create!

Editor Recommended Sites