cs50_rust

Simple input functions for Rust, inspired by CS50's C library.

Important: This is an unofficial project and is not affiliated with Harvard University or the CS50 course.

What is this?

If you've taken CS50, you know functions like get_int() and get_string() that make getting user input straightforward. This library brings similar functionality to Rust, helping beginners focus on learning programming concepts rather than fighting with input handling.

The functions in this library will automatically retry when given invalid input, just like their CS50 counterparts. If you ask for an integer and the user types "hello", it will ask again until it gets a valid number.

Installation

You have three ways to use this library:

Option 1: Install from crates.io (Easiest)

Add this to your Cargo.toml:

[dependencies]
cs50_rust = "1.0.0"

Or use cargo add:

cargo add cs50_rust

Option 2: Use directly from GitHub

If you want the latest development version, add this to your Cargo.toml:

[dependencies]
cs50_rust = { git = "https://github.com/richarddalves/cs50_rust" }

Option 3: Download and use locally

Clone the repository and use it as a local dependency:

git clone https://github.com/richarddalves/cs50_rust.git

Then in your project's Cargo.toml:

[dependencies]
cs50_rust = { path = "../path/to/cs50_rust" }

Usage

use cs50_rust::{get_int, get_string, get_float};

fn main() {
    let name = get_string("What's your name? ");
    let age = get_int("What's your age? ");
    let height = get_float("Height in meters: ");
    
    println!("Hello {}, you are {} years old and {:.2}m tall", 
             name, age, height);
}

Available Functions

Basic CS50 Functions

These are the main functions that match CS50's original library:

Additional Rust-Specific Functions

The library also provides functions for Rust's specific numeric types:

A Note on Float Types

In the original CS50 library, get_float() returns a 32-bit float and get_double() returns a 64-bit double. We maintain this distinction for compatibility. However, be aware that in Rust, f64 is generally preferred over f32 for most applications unless you have specific memory or performance constraints.

Boolean Input

The get_bool() function accepts several formats:

• true, false
• yes, no
• y, n
• 1, 0

All inputs are case-insensitive.

Examples

Simple Calculator

use cs50_rust::{get_int, get_char};

fn main() {
    let x = get_int("First number: ");
    let op = get_char("Operator (+, -, *, /): ");
    let y = get_int("Second number: ");
    
    let result = match op {
        '+' => x + y,
        '-' => x - y,
        '*' => x * y,
        '/' => x / y,
        _ => {
            println!("Invalid operator");
            return;
        }
    };
    
    println!("{} {} {} = {}", x, op, y, result);
}

Grade Average

use cs50_rust::get_float;

fn main() {
    let mut sum = 0.0;
    let count = 3;
    
    for i in 1..=count {
        let grade = get_float(&format!("Grade {}: ", i));
        sum += grade;
    }
    
    println!("Average: {:.2}", sum / count as f32);
}

Running the Examples

Clone the repository and run:

cargo run --example basic_usage

How It Works

Each function displays the prompt and waits for user input. If the input can't be parsed into the requested type, the prompt is shown again. This continues until valid input is received. This behavior matches CS50's library, where functions never fail but keep asking until they get valid input.

This approach is great for learning but might not be suitable for production code where you'd want proper error handling.

Building and Testing

# Build the library
cargo build

# Run tests
cargo test

# Generate documentation
cargo doc --open

License

Licensed under the Apache License, Version 2.0. See LICENSE for details.

Disclaimer

This project is not affiliated with, endorsed by, or sponsored by Harvard University, CS50, or any of their partners. CS50 is a registered trademark of Harvard University.

Contributing

Contributions are welcome. Please see CONTRIBUTING.md for guidelines.

Acknowledgments

• Inspired by CS50's C library
• Thanks to the Rust community for excellent documentation and tools
• Special thanks to Harvard's CS50 course for making computer science education accessible

Related Resources

• CS50 Course
• The Rust Programming Language Book
• Rust by Example

Made with ❤️ for CS50 students learning Rust